text stringlengths 11 4.05M |
|---|
package main
import (
"fmt"
"math"
)
func main() {
array := []int{3, 2, 1, 20, 5, 6, 42, -2, 4, 3}
result := mergeSort(array)
fmt.Println(result)
}
func mergeSort(subArray []int) []int {
if len(subArray) == 1 {
return subArray
}
if len(subArray) == 2 {
return sort(subArray)
}
mid := int(math.Floor(float64(len(subArray)) / 2))
array1 := mergeSort(subArray[:mid])
array2 := mergeSort(subArray[mid:])
merge := merge(array1, array2)
fmt.Printf("sorted merge: %v\n", merge)
return merge
}
func merge(low, high []int) []int {
sorted := make([]int, len(low)+len(high))
lowIndex := 0
highIndex := 0
for i := range sorted {
if lowIndex > len(low)-1 {
sorted[i] = high[highIndex]
highIndex++
continue
} else if highIndex > len(high)-1 {
sorted[i] = low[lowIndex]
lowIndex++
continue
}
if low[lowIndex] < high[highIndex] {
sorted[i] = low[lowIndex]
lowIndex++
} else {
sorted[i] = high[highIndex]
highIndex++
}
}
return sorted
}
func sort(subArray []int) []int {
if subArray[1] < subArray[0] {
swap(subArray, 0, 1)
}
return subArray
}
func swap(array []int, first int, second int) {
if array[first] == array[second] {
return
}
swap := array[first]
array[first] = array[second]
array[second] = swap
}
|
/*
MIT License
Copyright (c) 2020-2021 Kazuhito Suda
This file is part of NGSI Go
https://github.com/lets-fiware/ngsi-go
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
package ngsilib
import (
"bytes"
"errors"
"testing"
"github.com/stretchr/testify/assert"
)
func TestNgsiIntiConfig(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := ""
err := ngsi.InitConfig(&filename)
assert.NoError(t, err)
}
var configData = `{
"brokers": {
"orion": {
"brokerHost": "https://orion",
"ngsiType": "v2"
}
}
}`
func TestIntiConfigBrokerList(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := ""
ngsi.ConfigFile.SetFileName(&filename)
ngsi.serverList = make(ServerList)
broker := &Server{ServerHost: "http://orion"}
ngsi.serverList["orion"] = broker
ngsi.configVresion = "1"
err := initConfig(ngsi, ngsi.ConfigFile)
assert.NoError(t, err)
}
func TestIntiConfigBrokerEOF(t *testing.T) {
ngsi := testNgsiLibInit()
filename := "config.json"
ngsi.ConfigFile = &MockIoLib{}
ngsi.ConfigFile.SetFileName(&filename)
ngsi.CacheFile = &MockIoLib{}
ngsi.CacheFile.SetFileName(&filename)
ngsi.FileReader = &MockFileLib{readFile: []byte("")}
err := initConfig(ngsi, ngsi.ConfigFile)
assert.NoError(t, err)
}
func TestIntiConfigBrokerListNoVersion(t *testing.T) {
ngsi := testNgsiLibInit()
filename := "config.json"
ngsi.ConfigFile = &MockIoLib{}
ngsi.ConfigFile.SetFileName(&filename)
ngsi.CacheFile = &MockIoLib{}
ngsi.CacheFile.SetFileName(&filename)
ngsi.FileReader = &MockFileLib{readFile: []byte(configData)}
err := initConfig(ngsi, ngsi.ConfigFile)
assert.NoError(t, err)
}
func TestIntiConfigNoFileName(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
s := `{}`
ngsi.FileReader = &MockFileLib{readFile: []byte(s)}
err := initConfig(ngsi, ngsi.ConfigFile)
assert.NoError(t, err)
}
func TestIntiConfigFileName(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
s := `{}`
ngsi.FileReader = &MockFileLib{readFile: []byte(s)}
err := initConfig(ngsi, ngsi.ConfigFile)
assert.NoError(t, err)
}
func TestIntiConfigExistsFile(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
s := `{}`
ngsi.FileReader = &MockFileLib{readFile: []byte(s)}
err := initConfig(ngsi, ngsi.ConfigFile)
assert.NoError(t, err)
}
func TestIntiConfigBatchFlag(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
s := `{}`
ngsi.FileReader = &MockFileLib{readFile: []byte(s)}
f := true
ngsi.BatchFlag = &f
err := initConfig(ngsi, ngsi.ConfigFile)
assert.NoError(t, err)
}
func TestIntiConfigErrorNoFileName(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{HomeDirErr: errors.New("error homedir")}
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 1, ngsiErr.ErrNo)
assert.Equal(t, "error homedir", ngsiErr.Message)
}
}
func TestIntiConfigErrorFileName(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{PathAbsErr: errors.New("error path abs")}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 2, ngsiErr.ErrNo)
assert.Equal(t, "error path abs config", ngsiErr.Message)
}
}
func TestIntiConfigErrorOpen(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{OpenErr: errors.New("open error")}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 3, ngsiErr.ErrNo)
assert.Equal(t, "open config: no such file or directory", ngsiErr.Message)
}
}
func TestIntiConfigErrorDecode(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
s := `{"contexts":{"data-model":"context","etsi":1,"json":["context"]}}`
ngsi.FileReader = &MockFileLib{readFile: []byte(s)}
ngsi.JSONConverter = &MockJSONLib{EncodeErr: errors.New("json error"), DecodeErr: errors.New("json error")}
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 4, ngsiErr.ErrNo)
assert.Equal(t, "json error", ngsiErr.Message)
}
}
func TestIntiConfigErrorVersion(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := ""
ngsi.ConfigFile.SetFileName(&filename)
ngsi.LogWriter = &bytes.Buffer{}
ngsi.serverList = make(ServerList)
broker := &Server{ServerHost: "http://orion", NgsiType: "v2"}
ngsi.serverList["orion"] = broker
ngsi.configVresion = "err"
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 5, ngsiErr.ErrNo)
assert.Equal(t, "error: config file version", ngsiErr.Message)
}
}
func TestIntiConfigErrorParam(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := ""
ngsi.ConfigFile.SetFileName(&filename)
ngsi.LogWriter = &bytes.Buffer{}
ngsi.serverList = make(ServerList)
broker := &Server{ServerHost: "http://orion", NgsiType: "v1"}
ngsi.serverList["orion"] = broker
ngsi.configVresion = "1"
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 6, ngsiErr.ErrNo)
assert.Equal(t, "error in config file", ngsiErr.Message)
}
}
func TestIntiConfigErrorContext(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := ""
ngsi.ConfigFile.SetFileName(&filename)
ngsi.LogWriter = &bytes.Buffer{}
ngsi.contextList = make(ContextsInfo)
ngsi.contextList["ld"] = "context"
ngsi.configVresion = "1"
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 6, ngsiErr.ErrNo)
assert.Equal(t, "error in config file", ngsiErr.Message)
}
}
func TestIntiConfigContext(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
s := `{"version":"1","contexts":{"data-model":"context","etsi":1,"json":["context"]}}`
ngsi.FileReader = &MockFileLib{readFile: []byte(s)}
j := ngsi.JSONConverter
ngsi.JSONConverter = &MockJSONLib{EncodeErr: errors.New("json error"), Jsonlib: j}
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 6, ngsiErr.ErrNo)
assert.Equal(t, "error in config file", ngsiErr.Message)
}
}
func TestIntiConfigErrorSaveError(t *testing.T) {
ngsi := testNgsiLibInit()
filename := "config.json"
ngsi.ConfigFile = &MockIoLib{TruncateErr: errors.New("error")}
ngsi.ConfigFile.SetFileName(&filename)
ngsi.CacheFile = &MockIoLib{}
ngsi.CacheFile.SetFileName(&filename)
ngsi.FileReader = &MockFileLib{readFile: []byte(configData)}
err := initConfig(ngsi, ngsi.ConfigFile)
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 7, ngsiErr.ErrNo)
assert.Equal(t, "error", ngsiErr.Message)
}
}
func TestSaveConfigFile(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
err := ngsi.saveConfigFile()
assert.NoError(t, err)
}
func TestSaveConfigFileErrorOpenFile(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{OpenErr: errors.New("open error")}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
err := ngsi.saveConfigFile()
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 1, ngsiErr.ErrNo)
assert.Equal(t, "open error", ngsiErr.Message)
}
}
/*
func TestSaveConfigFileErrorClose(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{CloseErr: errors.New("close error")}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
err := ngsi.saveConfigFile()
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 2, ngsiErr.ErrNo)
assert.Equal(t, "close error", ngsiErr.Message)
}
}
*/
func TestSaveConfigFileErrorTrancate(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{TruncateErr: errors.New("trancate error")}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
err := ngsi.saveConfigFile()
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 3, ngsiErr.ErrNo)
assert.Equal(t, "trancate error", ngsiErr.Message)
}
}
func TestSaveConfigFileErrorEncode(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{EncodeErr: errors.New("encode error")}
filename := "config"
ngsi.ConfigFile.SetFileName(&filename)
err := ngsi.saveConfigFile()
if assert.Error(t, err) {
ngsiErr := err.(*LibError)
assert.Equal(t, 4, ngsiErr.ErrNo)
assert.Equal(t, "encode error", ngsiErr.Message)
}
}
func TestSaveConfigFileEmpty(t *testing.T) {
ngsi := testNgsiLibInit()
ngsi.ConfigFile = &MockIoLib{}
filename := ""
ngsi.ConfigFile.SetFileName(&filename)
err := ngsi.saveConfigFile()
assert.NoError(t, err)
}
func TestGetPreviousArgs(t *testing.T) {
ngsi := testNgsiLibInit()
actual := ngsi.GetPreviousArgs()
expected := ngsi.PreviousArgs
assert.Equal(t, expected, actual)
}
func TestSavePreviousArgs(t *testing.T) {
ngsi := testNgsiLibInit()
filename := ""
ngsi.ConfigFile.SetFileName(&filename)
err := ngsi.SavePreviousArgs()
assert.NoError(t, err)
}
func TestSavePreviousArgsNoSave(t *testing.T) {
ngsi := testNgsiLibInit()
filename := ""
ngsi.ConfigFile.SetFileName(&filename)
ngsi.PreviousArgs.UsePreviousArgs = false
err := ngsi.SavePreviousArgs()
assert.NoError(t, err)
}
func TestMigration(t *testing.T) {
config := NgsiConfig{}
config.DeprecatedBrokers = ServerList{}
config.DeprecatedBrokers["orion"] = &Server{DeprecatedBrokerHost: "http://orion"}
migration(&config)
expected := "http://orion"
assert.Equal(t, expected, config.Servers["orion"].ServerHost)
assert.Equal(t, "", config.Servers["orion"].DeprecatedBrokerHost)
}
|
package chatroom
import (
"fmt"
"net"
"strings"
"strconv"
)
var JOIN_CHATROOM_RESPONSE_PROTOCOL = [5]string{"JOINED_CHATROOM", "SERVER_IP", "PORT", "ROOM_REF", "JOIN_ID"}
var SEND_MESSAGE_REPSONSE_PROTOCOL = [3]string{"CHAT", "CLIENT_NAME", "MESSAGE"}
var LEAVE_CHATROOM_RESPONSE_PROTOCOL = [2]string{"LEFT_CHATROOM", "JOIN_ID"}
// list of all chatRoomsRef , each chatroom's index in the list is it's reference
var chatRoomsRef = make(map[string]int)
// map of all users names, it's index is this user's join id
var userNamesJoinId = make(map[string]int)
// list of all users' corresponding group,
var usersCorrespondingGroup = make(map[string][]int)
// list of users' connection e.g users_conns[0].send(message)
var usersConns = make(map[string]net.Conn)
func RequestJoinChatroom(request string, clientConn net.Conn, port string) bool{
// Parse request for essential information
var requestLines = strings.Split(request, "\n")
var roomName = strings.Split(requestLines[0], ":")[1]
var clientName = strings.Split(requestLines[3], ":")[1]
//Join the chatroom
if _, exists := chatRoomsRef[roomName]; !exists{
createChatroom(roomName)
}
roomRef, joinId := joinChatroom(roomName, clientName, clientConn)
//responds to the client that the joiniing is sucecesful
returnMessage := JOIN_CHATROOM_RESPONSE_PROTOCOL[0] + ":" + roomName + "\n"
returnMessage = returnMessage + JOIN_CHATROOM_RESPONSE_PROTOCOL[1] + ":" + getIpAddress() + "\n"
returnMessage = returnMessage + JOIN_CHATROOM_RESPONSE_PROTOCOL[2] + ":" + port + "\n"
returnMessage = returnMessage + JOIN_CHATROOM_RESPONSE_PROTOCOL[3] + ":" + roomRef + "\n"
returnMessage = returnMessage + JOIN_CHATROOM_RESPONSE_PROTOCOL[4] + ":" + joinId + "\n"
clientConn.Write([]byte(returnMessage))
//broadcast the joining of new members in the chat room
message := fmt.Sprintf("CHAT:%s\nCLIENT_NAME:%s\nMESSAGE:%s has joined this chatroom.\n\n", roomRef, clientName, clientName)
broadCastWithinRoom(message, roomRef)
//print "JOIN SUCCESFULLY\n"
return true
}
func RequestLeavingChatroom(request string,clientConn net.Conn, serverPort string) bool{
//Parse request for essential information
requestLines := strings.Split(request, "\n")
roomRef := strings.Split(requestLines[0], ":")[1]
joinId := strings.Split(requestLines[1], ":")[1]
clientName := strings.Split(requestLines[2], ":")[1]
//responds to the client
returnMessage := LEAVE_CHATROOM_RESPONSE_PROTOCOL[0] + ":" + roomRef + "\n"
returnMessage = returnMessage + LEAVE_CHATROOM_RESPONSE_PROTOCOL[1] + ":" + joinId + "\n"
fmt.Printf("Sent Response:\n" + returnMessage)
clientConn.Write([]byte(returnMessage))
message := fmt.Sprintf("CHAT:%s\nCLIENT_NAME:%s\nMESSAGE:%s has left chatroom.\n\n", roomRef, clientName, clientName)
broadCastWithinRoom(message, roomRef)
leaveChatroom(clientName, roomRef)
return true
}
func RequestSendMessage(request string, clientConn net.Conn, serverPort string) bool {
//Parse request for essential information
requestLines := strings.Split(request, "\n")
roomRef := strings.Split(requestLines[0], ":")[1]
//joinId := strings.Split(requestLines[1], ":")[1]
clientName := strings.Split(requestLines[2], ":")[1]
message := strings.Split(requestLines[3], ":")[1]
message = fmt.Sprintf("CHAT: %s\nCLIENT_NAME: %s\nMESSAGE: %s\n\n", roomRef, clientName, message)
broadCastWithinRoom(message, roomRef)
return true
}
func RequestDisconnect(request string, clientConn net.Conn, serverPort string) bool{
// Parse request for essential information
requestLines := strings.Split(request, "\n")
clientName := strings.Split(requestLines[2], ":")[1]
joinId := userNamesJoinId[clientName]
fmt.Printf("Disconnection:")
fmt.Printf("Client:", clientName)
fmt.Printf("ID:", joinId)
// fmt.Printf("Room:", usersCorrespondingGroup[joinId])
for _, roomRef := range usersCorrespondingGroup[clientName] {
message := fmt.Sprintf("CHAT:%d\nCLIENT_NAME:%s\nMESSAGE:%s has left chatroom.\n\n", roomRef, clientName, clientName)
broadCastWithinRoom(message, strconv.Itoa(roomRef))
}
usersConns[clientName].Close()
delete( usersCorrespondingGroup, clientName)
delete( chatRoomsRef, clientName)
delete( userNamesJoinId, clientName)
delete( usersConns, clientName)
return true
}
func Kill(){
for _, c := range usersConns {
c.Write([]byte("Killing the service!"))
c.Close()
}
}
func createChatroom(roomName string) {
// add new chatromm
fmt.Printf("Create CHATRoom", roomName)
chatRoomsRef[roomName] = len(chatRoomsRef)
}
func joinChatroom(roomName string, userName string, clientConn net.Conn) (string, string){
//get the ref of the chat room
ref := chatRoomsRef[roomName]
//add new user
fmt.Println("User Conn:" + clientConn.LocalAddr().String() + "\n")
joinId := userNamesJoinId[userName]
if _, exists := usersConns[userName]; exists {
// if user connection existis, then simply add new group to users chatroom record
fmt.Printf("Client Conn Exists")
usersCorrespondingGroup[userName] = append(usersCorrespondingGroup[userName], ref)
} else if _, exists := userNamesJoinId[userName]; exists {
// if user existis but user connection doesn't exists, then simply add new group and new connection to users chatroom record
fmt.Printf("Client Name exists")
usersCorrespondingGroup[userName] = append(usersCorrespondingGroup[userName], ref)
usersConns[userName] = clientConn
} else {
joinId = len(usersConns)
userNamesJoinId[userName] = len(userNamesJoinId)
usersCorrespondingGroup[userName] = append(usersCorrespondingGroup[userName], ref)
usersConns[userName] = clientConn
fmt.Printf("Add new user %s with join id %d", userName, joinId)
}
return strconv.Itoa(ref), strconv.Itoa(joinId)
}
func broadCastWithinRoom(message string, roomRef string) {
fmt.Printf("BroadCasting:\n", message, "\n" )
fmt.Printf("Who is leaving?: " + roomRef + "\n")
roomRef = strings.Replace(roomRef, " ", "", -1)
roomRefInt, _ := strconv.Atoi(roomRef)
for uname, conn := range usersConns {
fmt.Printf("JOIN ID: " + uname + "\n" )
fmt.Printf("Client: " + strconv.Itoa(userNamesJoinId[uname]) + "\n")
for _, group := range usersCorrespondingGroup[uname] {
fmt.Printf("Group: " + strconv.Itoa(group) + "roomRef: " + strconv.Itoa(roomRefInt) + "\n")
if (group - roomRefInt == 0) {
fmt.Printf("Broadcasting to: " + strconv.Itoa(group) + "\n")
conn.Write([]byte(message))
}
}
}
}
func leaveChatroom(clientName string, room string) {
roomInt, _ := strconv.Atoi(room)
var newUserGroup []int
for ref, _ := range usersCorrespondingGroup[clientName] {
if (ref != roomInt) {
newUserGroup = append(newUserGroup, ref)
} else {
fmt.Printf(clientName + " is leaving " + room + "\n")
}
}
usersCorrespondingGroup[clientName] = newUserGroup
}
func getIpAddress() string{
ifaces, _ := net.Interfaces()
// handle err
for _, i := range ifaces {
addrs, _ := i.Addrs()
// handle err
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
return ip.String()
}
}
return ""
}
|
package main
import (
"crypto/md5"
"fmt"
"html/template"
"io"
"log"
"net/http"
"os"
"path/filepath"
"regexp"
"strconv"
"strings"
"time"
)
func sayhelloName(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
fmt.Println(r.Form)
fmt.Println("path", r.URL.Path)
fmt.Println(r.Form["url_long"])
for k, v := range r.Form {
fmt.Println("key:", k, "val:", strings.Join(v, ""))
}
fmt.Fprintf(w, "Hello astaxie!")
}
func validateValues(r *http.Request) error {
if len(r.Form["username"][0]) == 0 {
return fmt.Errorf("username is nil")
}
age, err := strconv.Atoi(r.Form.Get("age"))
if err != nil {
return err
}
if age > 120 {
return fmt.Errorf("age is too large")
}
// regular expression
m, err := regexp.MatchString("^[0-9]+$", r.Form.Get("age"))
if err != nil {
return nil
}
if !m {
return fmt.Errorf("age is not int")
}
// pull down menue
// <select name="fruit">
// <option value="apple">apple</option>
// <option value="pear">pear</option>
// <option value="banane">banane</option>
// </select>
fruit := []string{"apple", "pear", "banana"}
for _, v := range fruit {
if v != r.Form.Get("fruit") {
return fmt.Errorf("%v is not registered", v)
}
}
return nil
}
// baseFileName means the name that is excluded file extension
func getTmpl(baseFileName string) string {
path := filepath.Join(os.Getenv("GOPATH"), "bin", "tpl", baseFileName+".gtpl")
return path
}
func login(w http.ResponseWriter, r *http.Request) {
fmt.Println("method:", r.Method)
if r.Method == "GET" {
crutime := time.Now().Unix()
h := md5.New()
io.WriteString(h, strconv.FormatInt(crutime, 10))
token := fmt.Sprintf("%x", h.Sum(nil))
tmpl := getTmpl("login")
fmt.Println(tmpl)
t, err := template.ParseFiles(tmpl)
if err != nil {
fmt.Fprintf(w, "%+v", err)
return
}
t.Execute(w, token)
} else {
r.ParseForm()
token := r.Form.Get("token")
if token != "" {
} else {
}
fmt.Println("username:", template.HTMLEscapeString(r.Form["username"][0]))
fmt.Println("password:", template.HTMLEscapeString(r.Form["password"][0]))
}
}
func upload(w http.ResponseWriter, r *http.Request) {
fmt.Println("method:", r.Method)
if r.Method == "GET" {
crutime := time.Now().Unix()
h := md5.New()
io.WriteString(h, strconv.FormatInt(crutime, 10))
token := fmt.Sprintf("%x", h.Sum(nil))
t, err := template.ParseFiles(getTmpl("upload"))
if err != nil {
fmt.Fprintf(w, "%+v", err)
return
}
t.Execute(w, token)
} else {
r.ParseMultipartForm(32 << 20)
file, handler, err := r.FormFile("uploadfile")
if err != nil {
fmt.Println(err)
return
}
defer file.Close()
fmt.Fprintf(w, "%v", handler.Header)
err = os.MkdirAll("./test", 0777)
if err != nil {
fmt.Println(err)
return
}
f, err := os.OpenFile("./test/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fmt.Println(err)
return
}
defer f.Close()
io.Copy(f, file)
}
}
func main() {
http.HandleFunc("/", sayhelloName)
http.HandleFunc("/login", login)
http.HandleFunc("/upload", upload)
err := http.ListenAndServe(":9090", nil)
if err != nil {
log.Fatal("ListenAndServe:", err)
}
}
|
package router
import (
"github.com/gin-gonic/gin"
"github.com/zhulinwei/go-dc/pkg/controller"
)
type IUserRouter interface {
InitRouter(r *gin.Engine)
}
type UserRouter struct {
UserController controller.IUserController
}
func BuildUserRouter () IUserRouter {
return UserRouter{
UserController: controller.BuildUserController(),
}
}
func (userRouter UserRouter) InitRouter(r *gin.Engine) {
route := r.Group("/test1")
route.GET("/ping", userRouter.UserController.Ping)
route.POST("/users", userRouter.UserController.SaveUser)
route.GET("/users/:name", userRouter.UserController.QueryUserByName)
route.PUT("/users/:name", userRouter.UserController.UpdateUserByName)
route.DELETE("/users/:name", userRouter.UserController.RemoveUserByName)
}
|
package main
import (
"fmt"
"log"
)
const dimensions int = 32
func setupMagicSquareData(d int) ([][]int, error) {
var output [][]int
if d < 4 || d%4 != 0 {
return [][]int{}, fmt.Errorf("Square dimension must be a positive number which is divisible by 4")
}
var bits uint = 0x9669 // 0b1001011001101001
size := d * d
mult := d / 4
for i, r := 0, 0; r < d; r++ {
output = append(output, []int{})
for c := 0; c < d; i, c = i+1, c+1 {
bitPos := c/mult + (r/mult)*4
if (bits & (1 << uint(bitPos))) != 0 {
output[r] = append(output[r], i+1)
} else {
output[r] = append(output[r], size-i)
}
}
}
return output, nil
}
func main() {
data, err := setupMagicSquareData(dimensions)
if err != nil {
log.Fatal(err)
}
magicConstant := (dimensions * (dimensions*dimensions + 1)) / 2
for _, r := range data {
for _, c := range r {
fmt.Printf("%5d", c)
}
fmt.Println()
}
fmt.Printf("\nMagic Constant: %d\n", magicConstant)
}
|
package main
type list struct {
first *list_node
last *list_node
}
type list_node struct {
prev *list_node
next *list_node
data interface{}
}
func (self *list) Append(x interface{}) {
new_node := new(list_node)
new_node.data = x
if (*self).first == nil {
self.first = new_node
self.last = new_node
}
new_node.prev = self.last
new_node.next = self.first
self.last = new_node
new_node.prev.next = new_node
new_node.next.prev = new_node
}
func (self *list) Len() (length int) {
if self.first != nil {
length++
}
for f := self.first; f != self.last; f = f.next {
length++
}
return
}
|
//
// Title : Distinct
// Author : Richie Varghese
// Date : 24/12/2020
//
// distict : given an array A consisting of N integers, returns the number of distinct values in array A.
// For example, given array A consisting of six elements such that:
// A[0] = 2 A[1] = 1 A[2] = 1
// A[3] = 2 A[4] = 3 A[5] = 1
// the function should return 3, because there are 3 distinct values appearing in array A, namely 1, 2 and 3.
//
// Functions : distinct ---> returns number of distinct elements in an array
//
// Result : https://app.codility.com/demo/results/trainingNKFWWC-5VW/
//
package distinct
//
// Distinct function returns number of distinct elements in an array
//
// INPUT : input []int;
// RETURN : distinctEntries int
//
func Distinct(input []int) int {
var distinctEntries = make(map[int]bool)
// iterate on each entry from input array
for _, entry := range input {
distinctEntries[entry] = true
}
return len(distinctEntries)
}
|
// Copyright 2014 The Cockroach Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the License. See the AUTHORS file
// for names of contributors.
//
// Author: Tobias Schottdorf
package log
// TestVAndModule tests that module-level logging isn't broken.
// It is deactivated since it messes with the logging and we don't want that.
// However, it's a good sanity check while refactoring our logging.
//
// func TestVAndVModule(t *testing.T) {
// clog.SetVerbosity(8)
// if !V(7) {
// t.Fatalf("verbosity is broken")
// }
// Infof("test")
// clog.SetVerbosity(0)
// clog.SetVModule("log_test=8")
// if !V(7) {
// t.Fatalf("module-level verbosity broken")
// }
// }
|
package message
type IncomingMessage struct {
Repository struct {
Status string
RepoUrl string `json:"repo_url"`
Owner string
IsPrivate bool `json:"is_private"`
Name string
StarCount int `json:"star_count"`
RepoName string `json:"repo_name"`
}
Push_data struct {
PushedAt int `json:"pushed_at"`
Images []string
Pusher string
}
}
|
package main
//133. 克隆图
//给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。
//
//图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。
// * Definition for a Node.
type Node struct {
Val int
Neighbors []*Node
}
func cloneGraph(node *Node) *Node {
if node == nil{
return nil
}
dic := make(map[*Node]*Node)
var clone func(root *Node)*Node
clone = func(root *Node)*Node{
if dic[root] != nil{
return dic[root]
}
head := &Node{
Val: root.Val,
Neighbors: make([]*Node, 0),
}
dic[root] = head
for _, v := range root.Neighbors {
if dic[v] == nil {
dic[v] = clone(v)
}
head.Neighbors = append(head.Neighbors, dic[v])
}
return head
}
return clone(node)
}
|
package docker
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/opspec-io/opctl/util/vruntime"
)
var _ = Context("localPath", func() {
Context("when runtime.GOOS == windows", func() {
fakeRuntime := new(vruntime.Fake)
fakeRuntime.GOOSReturns("windows")
objectUnderTest := _containerProvider{
runtime: fakeRuntime,
}
Context("when path contains drive letter", func() {
It("should trim preceeding slash and add colon proceeding drive letter", func() {
/* arrange */
expected := "c:/DummyPath"
/* act */
actual := objectUnderTest.localPath("/c/DummyPath")
/* assert */
Expect(actual).To(Equal(expected))
})
})
})
})
|
package model
import (
"gorm.io/datatypes"
)
type SchedulerCluster struct {
Model
Name string `gorm:"column:name;size:256;uniqueIndex;not null" json:"name"`
BIO string `gorm:"column:bio;size:1024" json:"bio"`
Config datatypes.JSONMap `gorm:"column:config;not null" json:"config"`
ClientConfig datatypes.JSONMap `gorm:"column:client_config;not null" json:"client_config"`
CDNClusters []CDNCluster `gorm:"many2many:cdn_cluster_scheduler_cluster;" json:"-"`
Schedulers []Scheduler `json:"-"`
SecurityGroupID *uint
SecurityGroup SecurityGroup `json:"-"`
}
|
package code
import "github.com/pgavlin/warp/wasm"
type StaticScope struct {
module *wasm.Module
ImportedFunctions []uint32
ImportedGlobals []wasm.GlobalVar
Tables int
Memories int
Locals []wasm.ValueType
}
func NewStaticScope(m *wasm.Module) *StaticScope {
s := StaticScope{module: m}
if m.Import != nil {
for _, i := range m.Import.Entries {
switch i := i.Type.(type) {
case wasm.FuncImport:
s.ImportedFunctions = append(s.ImportedFunctions, i.Type)
case wasm.TableImport:
s.Tables++
case wasm.MemoryImport:
s.Memories++
case wasm.GlobalVarImport:
s.ImportedGlobals = append(s.ImportedGlobals, i.Type)
}
}
}
if m.Table != nil {
s.Tables += len(m.Table.Entries)
}
if m.Memory != nil {
s.Memories += len(m.Memory.Entries)
}
return &s
}
func (s *StaticScope) GetLocalType(localidx uint32) (wasm.ValueType, bool) {
if localidx >= uint32(len(s.Locals)) {
return 0, false
}
return s.Locals[int(localidx)], true
}
func (s *StaticScope) GetGlobalType(globalidx uint32) (wasm.GlobalVar, bool) {
if globalidx < uint32(len(s.ImportedGlobals)) {
return s.ImportedGlobals[int(globalidx)], true
}
globalidx -= uint32(len(s.ImportedGlobals))
if s.module.Global == nil || globalidx >= uint32(len(s.module.Global.Globals)) {
return wasm.GlobalVar{}, false
}
return s.module.Global.Globals[int(globalidx)].Type, true
}
func (s *StaticScope) GetFunctionSignature(funcidx uint32) (wasm.FunctionSig, bool) {
if funcidx < uint32(len(s.ImportedFunctions)) {
return s.GetType(s.ImportedFunctions[int(funcidx)])
}
funcidx -= uint32(len(s.ImportedFunctions))
if s.module.Function == nil || funcidx >= uint32(len(s.module.Function.Types)) {
return wasm.FunctionSig{}, false
}
return s.GetType(s.module.Function.Types[int(funcidx)])
}
func (s *StaticScope) GetType(typeidx uint32) (wasm.FunctionSig, bool) {
if s.module.Types == nil || typeidx >= uint32(len(s.module.Types.Entries)) {
return wasm.FunctionSig{}, false
}
return s.module.Types.Entries[int(typeidx)], true
}
func (s *StaticScope) SetFunction(sig wasm.FunctionSig, body wasm.FunctionBody) {
s.Locals = s.Locals[:0]
s.Locals = append(s.Locals, sig.ParamTypes...)
for _, l := range body.Locals {
for i := uint32(0); i < l.Count; i++ {
s.Locals = append(s.Locals, l.Type)
}
}
}
func (s *StaticScope) HasTable(tableidx uint32) bool {
return tableidx < uint32(s.Tables)
}
func (s *StaticScope) HasMemory(memoryidx uint32) bool {
return memoryidx < uint32(s.Memories)
}
|
package giantbomb
type Response struct {
StatusCode int64 `json:"status_code"`
Error string `json:"error"`
TotalResults int64 `json:"number_of_total_results"`
PageResults int64 `json:"number_of_page_results"`
Limit int64 `json:"limit"`
Offset int64 `json:"offset"`
}
|
package main
import (
"flag"
"fmt"
"log"
"time"
"gopkg.in/mgo.v2"
)
type TestDoc struct {
ID int `bson:"id"`
}
var mongourl string
func main() {
flag.StringVar(&mongourl, "mongourl", "", "")
flag.Parse()
log.Printf("start dial to %s", mongourl)
// replSet initiate got NodeNotElectable: This node, mongo2:27017, with _id MemberId(1)
// is not electable under the new configuration version 1 for replica set rs0 while validating
// session, err := mgo.Dial(mongourl1 + "," + mongourl2 + "/?connect=direct")
session, err := mgo.Dial(mongourl)
if err != nil {
message := fmt.Sprintf("dial to %s failed: %s", mongourl, err)
log.Fatal(message)
}
defer session.Close()
log.Printf("connect %v", session)
// session.SetMode(mgo.Monotonic, true)
db := session.DB("test")
collection := db.C("test")
ticker := time.NewTicker(1 * time.Second)
i := 1
for range ticker.C {
doc := TestDoc{i}
err := collection.Insert(doc)
i++
if err != nil {
log.Printf("insert %v failed: %s", doc, err)
}
n, err := collection.Count()
if err != nil {
log.Printf("get count failed: %s", err)
continue
}
log.Printf("got count: %d", n)
}
}
|
package main
import "fmt"
import "time"
func main() {
//go-routines are functions that are executing concurrently with other code.
//various ways to start go-routines
go sayHello() // a normal function as defined below called with go keyword
//Following construct is called as anonymous function
//Look at the () on line 14 we are valling the function at the same time we have defined it.
go func() {
fmt.Println("baee- bye")
}()
// third way
// define the function without the name and assign it to a variable
sayHola := func() {
fmt.Println("hello in spanish")
}
go sayHola()
//adding time sleep so that go-routines have chance to execute
time.Sleep(1000 * time.Millisecond)
}
func sayHello() {
fmt.Println("hello")
}
//co-routines - piece of code that can stop execution waiting for input to arrive(i.e. they are blocked) and resume when input is available.
//co-routines are non-preemptive(something that cannot be interrupted(if they are not themselves blocked)).
//go-routines do NOT define their own suspension or resumption
//go runtime observes the behaviour of go-routines and suspends them if they are blocked or resumes when they are unblocked
//green threads - threads managed by langunage runtime
//go-routines(100) --> go run time(this has green threads)(80 green threads) --> OS threads(70)
// P M --> N
//M:N Schedular M green threads are mapped to N OS threads
//go-routines are scheduled to run on Green threads
//when go-routines > green threads, scheduler distributes the go-routines across the green threads
//when some go-routines blocks others are scheduled to run.
//fork-join model of concurrency
//when a go-routine is created it splits off as a child of parent go-routine(fork)
//The goroutine will be created and scheduled with Go’s runtime to execute
//it is now expected to run concurrently with the parent go-routine on different green thread
//meanwhile, the parent's code is still executing
//At some future indeterminate point the child go-routine is expected to get executed
//If the child go-routine rejoins the parent go-routine it is called as join(join)
//If there is no join point, there is no guarantee that the child goroutine is executed.
//As soon as main go-routine finishes the program execution ends.
//In above example, child go-routines were able to execute because there was sleep introduced.
//But sleep is not acutal join , it introduces race condition.
//see next example to see how can we create join in go programs.
|
// Copyright (c) 2013 Mathieu Turcotte
// Licensed under the MIT license.
package browserchannel
import (
"errors"
"io"
"log"
"net/http"
"strconv"
)
const dataChannelCapacity = 128
// The back channel interface shared between the XHR and HTML implementations.
type backChannel interface {
getRequestId() string
isReusable() bool
setChunked(bool)
isChunked() bool
send(data []byte) error
discard()
wait()
}
// Common bookeeping information shared between the chunked XHR and HTML
// variants.
type backChannelBase struct {
sid SessionId
rid string
w http.ResponseWriter
chunked bool
bytesSent int
dataChan chan []byte
err error
}
func (b *backChannelBase) getRequestId() string {
return b.rid
}
func (b *backChannelBase) isReusable() bool {
return b.chunked && b.bytesSent < 10*1024 && b.err == nil
}
func (b *backChannelBase) setChunked(chunked bool) {
b.chunked = chunked
}
func (b *backChannelBase) send(data []byte) (err error) {
select {
case b.dataChan <- data:
b.bytesSent += len(data)
// Optimistically assumes that all the data was written successfully.
// If an error occurs, the protocol will recover by its own means.
default:
log.Printf("%s[%s] back channel full\n", b.sid, b.rid)
err = errors.New("data channel full")
b.err = err
}
return
}
func (b *backChannelBase) isChunked() bool {
return b.chunked
}
// The chunked XHR back channel implementation.
type xhrBackChannel struct {
backChannelBase
}
func (b *xhrBackChannel) wait() {
for data := range b.dataChan {
log.Printf("%s[%s] xhr back channel send: %s\n", b.sid, b.rid, data)
str := strconv.FormatInt(int64(len(data)), 10) + "\n" + string(data)
io.WriteString(b.w, str)
b.w.(http.Flusher).Flush()
}
log.Printf("%s[%s] bind wait done\n", b.sid, b.rid)
}
func (b *xhrBackChannel) discard() {
log.Printf("%s[%s] xhr back channel close\n", b.sid, b.rid)
close(b.dataChan)
}
// The chunked HTML back channel implementation used for IE9 and older.
type htmlBackChannel struct {
backChannelBase
paddingSent bool
domain string
}
func (b *htmlBackChannel) wait() {
for data := range b.dataChan {
log.Printf("%s[%s] html back channel send: %s\n", b.sid, b.rid, data)
if !b.paddingSent {
writeHtmlHead(b.w)
writeHtmlDomain(b.w, b.domain)
}
writeHtmlRpc(b.w, string(data))
if !b.paddingSent {
writeHtmlPadding(b.w)
b.paddingSent = true
}
b.w.(http.Flusher).Flush()
}
writeHtmlDone(b.w)
log.Printf("%s[%s] bind wait done\n", b.sid, b.rid)
}
func (b *htmlBackChannel) discard() {
log.Printf("%s %s html back channel close\n", b.sid, b.rid)
close(b.dataChan)
}
func newBackChannel(sid SessionId, w http.ResponseWriter, html bool,
domain string, rid string) (bc backChannel) {
base := backChannelBase{
sid: sid,
rid: rid,
w: w,
dataChan: make(chan []byte, dataChannelCapacity)}
if html {
bc = &htmlBackChannel{backChannelBase: base, domain: domain}
} else {
bc = &xhrBackChannel{base}
}
return
}
|
package state
import (
"github.com/aergoio/aergo/types"
)
// BlockInfo contains BlockHash and StateRoot
type BlockInfo struct {
BlockHash types.BlockID
StateRoot types.HashID
}
// BlockState contains BlockInfo and statedb for block
type BlockState struct {
StateDB
BpReward []byte //final bp reward, increment when tx executes
receipts types.Receipts
CodeMap map[types.AccountID][]byte
}
// NewBlockInfo create new blockInfo contains blockNo, blockHash and blockHash of previous block
func NewBlockInfo(blockHash types.BlockID, stateRoot types.HashID) *BlockInfo {
return &BlockInfo{
BlockHash: blockHash,
StateRoot: stateRoot,
}
}
// GetStateRoot return bytes of bi.StateRoot
func (bi *BlockInfo) GetStateRoot() []byte {
if bi == nil {
return nil
}
return bi.StateRoot.Bytes()
}
// NewBlockState create new blockState contains blockInfo, account states and undo states
func NewBlockState(states *StateDB) *BlockState {
return &BlockState{
StateDB: *states,
CodeMap: make(map[types.AccountID][]byte),
}
}
func (bs *BlockState) AddReceipt(r *types.Receipt) {
bs.receipts = append(bs.receipts, r)
}
func (bs *BlockState) Receipts() types.Receipts {
return bs.receipts
}
|
// This file was generated by data-gen. Do not edit.
// CLDR version: 40.0
package locale
import (
"reflect"
"testing"
)
func TestRanges(t *testing.T) {
ranges := Ranges{1, 2, 3, 4}
n := ranges.Len()
if n != 2 {
t.Errorf("unexpected length: %d", n)
}
for i := 0; i < n; i++ {
rng := ranges.At(i)
if rng.LowerBound != int(ranges[2*i]) || rng.UpperBound != int(ranges[2*i+1]) {
t.Errorf("unexpected range for index %d: %v", i, rng)
}
}
}
func TestPluralRules(t *testing.T) {
collectRules := func(r PluralRules) []PluralRule {
var res []PluralRule
r.Iter(func(rule PluralRule) bool {
res = append(res, rule)
return true
})
return res
}
rules := PluralRules{}
collected := collectRules(rules)
if len(collected) != 0 {
t.Errorf("unexpected plural rules: %+v", collected)
}
rules = PluralRules{
rel: relation{0x1285, 0x1, 0x1, 0x1000},
}
collected = collectRules(rules)
expected := []PluralRule{
{Operand: IntegerDigits, ModuloExp: 2, Operator: NotEqual, Ranges: Ranges{0x1, 0x1}, Connective: Conjunction},
{Operand: IntegerDigits, ModuloExp: 0, Operator: Equal, Ranges: Ranges{}, Connective: None},
}
if !reflect.DeepEqual(collected, expected) {
t.Errorf("unexpected plural rules: %+v", collected)
}
}
func TestLookupPlural(t *testing.T) {
// cardinal plurals
testLookupPlural(t, "cardinal", CardinalPlural, map[Locale]Plural{
0x0001: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0002: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0003: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0004: {},
0x0005: {},
0x0006: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x0007: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x0008: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0009: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x000a: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x000b: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x000c: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x000d: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x000e: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x000f: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0010: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0011: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0012: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0013: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0014: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0015: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0016: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0017: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0018: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0019: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x001a: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x001b: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x001c: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x001d: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x001e: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x001f: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0020: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0021: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0022: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0023: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0024: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0025: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0026: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x15e)}, {Tag: Many, rel: relations.relation(0x133)}},
0x0027: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0028: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0029: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x002a: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x002b: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x002c: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x002d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x002e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x002f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0030: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0031: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0032: {},
0x0033: {},
0x0034: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Few, rel: relations.relation(0xf8)}, {Tag: Many, rel: relations.relation(0x9c)}, {}, {}},
0x0035: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Few, rel: relations.relation(0xf8)}, {Tag: Many, rel: relations.relation(0x9c)}, {}, {}},
0x0036: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0037: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0038: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0039: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x003a: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x003b: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x003c: {},
0x003d: {},
0x003e: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x003f: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0040: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0041: {},
0x0042: {},
0x0043: {},
0x0044: {{Tag: One, rel: relations.relation(0xcc)}, {Tag: Two, rel: relations.relation(0xe8)}, {Tag: Few, rel: relations.relation(0x10a)}, {Tag: Many, rel: relations.relation(0x88)}, {}},
0x0045: {{Tag: One, rel: relations.relation(0xcc)}, {Tag: Two, rel: relations.relation(0xe8)}, {Tag: Few, rel: relations.relation(0x10a)}, {Tag: Many, rel: relations.relation(0x88)}, {}},
0x0046: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0047: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0048: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x0049: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x004a: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x004b: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x004c: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x004d: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x004e: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x004f: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0050: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0051: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0052: {},
0x0053: {},
0x0054: {},
0x0055: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0056: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0057: {{Tag: One, rel: relations.relation(0x2b0)}, {}, {}, {}, {}},
0x0058: {{Tag: One, rel: relations.relation(0x2b0)}, {}, {}, {}, {}},
0x0059: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x005a: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x005b: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x005c: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x005d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x005e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x005f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0060: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x82)}, {Tag: Many, rel: relations.relation(0x203)}, {}, {}},
0x0061: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x82)}, {Tag: Many, rel: relations.relation(0x203)}, {}, {}},
0x0062: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1d2)}, {Tag: Many, rel: relations.relation(0x1f1)}},
0x0063: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1d2)}, {Tag: Many, rel: relations.relation(0x1f1)}},
0x0064: {{Tag: One, rel: relations.relation(0x184)}, {}, {}, {}, {}},
0x0065: {{Tag: One, rel: relations.relation(0x184)}, {}, {}, {}, {}},
0x0066: {{Tag: One, rel: relations.relation(0x184)}, {}, {}, {}, {}},
0x0067: {},
0x0068: {},
0x0069: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x006a: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x006b: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x006c: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x006d: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x006e: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x006f: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0070: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0071: {},
0x0072: {},
0x0073: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0074: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0075: {{Tag: One, rel: relations.relation(0x286)}, {Tag: Two, rel: relations.relation(0x295)}, {Tag: Few, rel: relations.relation(0x29e)}, {}, {}},
0x0076: {{Tag: One, rel: relations.relation(0x286)}, {Tag: Two, rel: relations.relation(0x295)}, {Tag: Few, rel: relations.relation(0x29e)}, {}, {}},
0x0077: {},
0x0078: {},
0x0079: {},
0x007a: {},
0x007b: {},
0x007c: {},
0x007d: {},
0x007e: {},
0x007f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0080: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0081: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0082: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0083: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0084: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0085: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0086: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0087: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0088: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0089: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x008a: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x008b: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x008c: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x008d: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x008e: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x008f: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0090: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0091: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0092: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0093: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0094: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0095: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0096: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0097: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0098: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0099: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x009a: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x009b: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x009c: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x009d: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x009e: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x009f: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a0: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a1: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a2: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a3: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a4: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a5: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a6: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a7: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a8: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00a9: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00aa: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ab: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ac: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ad: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ae: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00af: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b0: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b1: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b2: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b3: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b4: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b5: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b6: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b7: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b8: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00b9: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ba: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00bb: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00bc: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00bd: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00be: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00bf: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c0: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c1: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c2: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c3: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c4: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c5: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c6: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c7: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c8: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00c9: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ca: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00cb: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00cc: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00cd: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ce: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00cf: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d0: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d1: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d2: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d3: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d4: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d5: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d6: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d7: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d8: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00d9: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00da: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00db: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00dc: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00dd: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00de: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00df: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e0: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e1: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e2: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e3: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e4: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e5: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e6: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e7: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e8: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00e9: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ea: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00eb: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ec: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ed: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ee: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x00ef: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x00f0: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x00f1: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00f2: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00f3: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00f4: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00f5: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00f6: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00f7: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00f8: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00f9: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00fa: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00fb: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00fc: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00fd: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00fe: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x00ff: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0100: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0101: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0102: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0103: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0104: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0105: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0106: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0107: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0108: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0109: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x010a: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x010b: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x010c: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x010d: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x010e: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x010f: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0110: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0111: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0112: {},
0x0113: {},
0x0114: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0115: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0116: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0117: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0118: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0119: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x011a: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x011b: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x011c: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x011d: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x011e: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x011f: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0120: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0121: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0122: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0123: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0124: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0125: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0126: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0127: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0128: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0129: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x012a: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x012b: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x012c: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x012d: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x012e: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x012f: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0130: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0131: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0132: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0133: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0134: {{Tag: One, rel: relations.relation(0x2b0)}, {}, {}, {}, {}},
0x0135: {{Tag: One, rel: relations.relation(0x2b0)}, {}, {}, {}, {}},
0x0136: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0137: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0138: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0139: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x013a: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x013b: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x013c: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x013d: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x013e: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x013f: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0140: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0141: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0142: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0143: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0144: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0145: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0146: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0147: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0148: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0149: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x014a: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x014b: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x014c: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x014d: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x014e: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x014f: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0150: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0151: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0152: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0153: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0154: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0155: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0156: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0157: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0158: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0159: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x015a: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x015b: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x015c: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x015d: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x015e: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x015f: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0160: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0161: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0162: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0163: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0164: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0165: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0166: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0167: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0168: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0169: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x016a: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x016b: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x016c: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1e2)}, {Tag: Many, rel: relations.relation(0x1f4)}, {}},
0x016d: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1e2)}, {Tag: Many, rel: relations.relation(0x1f4)}, {}},
0x016e: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1e2)}, {Tag: Many, rel: relations.relation(0x1f4)}, {}},
0x016f: {{Tag: One, rel: relations.relation(0x18d)}, {Tag: Two, rel: relations.relation(0x1c7)}, {Tag: Few, rel: relations.relation(0x1da)}, {}, {}},
0x0170: {{Tag: One, rel: relations.relation(0x18d)}, {Tag: Two, rel: relations.relation(0x1c7)}, {Tag: Few, rel: relations.relation(0x1da)}, {}, {}},
0x0171: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0172: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0173: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0174: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0175: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0176: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0177: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0178: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0179: {},
0x017a: {},
0x017b: {{Tag: One, rel: relations.relation(0x236)}, {Tag: Two, rel: relations.relation(0x254)}, {Tag: Few, rel: relations.relation(0x272)}, {Tag: Many, rel: relations.relation(0x203)}, {}},
0x017c: {{Tag: One, rel: relations.relation(0x236)}, {Tag: Two, rel: relations.relation(0x254)}, {Tag: Few, rel: relations.relation(0x272)}, {Tag: Many, rel: relations.relation(0x203)}, {}},
0x017d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x017e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x017f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0180: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0181: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0182: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0183: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Two, rel: relations.relation(0x7c)}, {Tag: Many, rel: relations.relation(0x2ca)}, {}, {}},
0x0184: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Two, rel: relations.relation(0x7c)}, {Tag: Many, rel: relations.relation(0x2ca)}, {}, {}},
0x0185: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0186: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x0187: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x0188: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x0189: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x018a: {{Tag: One, rel: relations.relation(0x286)}, {Tag: Two, rel: relations.relation(0x295)}, {Tag: Few, rel: relations.relation(0x29e)}, {}, {}},
0x018b: {{Tag: One, rel: relations.relation(0x286)}, {Tag: Two, rel: relations.relation(0x295)}, {Tag: Few, rel: relations.relation(0x29e)}, {}, {}},
0x018c: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x018d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x018e: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x018f: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x0190: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0191: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0192: {},
0x0193: {},
0x0194: {},
0x0195: {},
0x0196: {},
0x0197: {},
0x0198: {{Tag: One, rel: relations.relation(0x1f7)}, {}, {}, {}, {}},
0x0199: {{Tag: One, rel: relations.relation(0x1f7)}, {}, {}, {}, {}},
0x019a: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x019b: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x019c: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x019d: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x019e: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x019f: {},
0x01a0: {},
0x01a1: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01a2: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01a3: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01a4: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01a5: {},
0x01a6: {},
0x01a7: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01a8: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01a9: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x01aa: {{Tag: One, rel: relations.relation(0x6a)}, {}, {}, {}, {}},
0x01ab: {},
0x01ac: {},
0x01ad: {},
0x01ae: {},
0x01af: {},
0x01b0: {},
0x01b1: {},
0x01b2: {},
0x01b3: {},
0x01b4: {},
0x01b5: {},
0x01b6: {},
0x01b7: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01b8: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01b9: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01ba: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01bb: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01bc: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01bd: {},
0x01be: {},
0x01bf: {},
0x01c0: {},
0x01c1: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x01c2: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x01c3: {},
0x01c4: {},
0x01c5: {},
0x01c6: {},
0x01c7: {},
0x01c8: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01c9: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01ca: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01cb: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01cc: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01cd: {},
0x01ce: {},
0x01cf: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {}, {}, {}},
0x01d0: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {}, {}, {}},
0x01d1: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01d2: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01d3: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x136)}, {Tag: Few, rel: relations.relation(0x153)}, {Tag: Many, rel: relations.relation(0x8e)}},
0x01d4: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x136)}, {Tag: Few, rel: relations.relation(0x153)}, {Tag: Many, rel: relations.relation(0x8e)}},
0x01d5: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01d6: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01d7: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x6d)}, {}, {}, {}},
0x01d8: {{Tag: Zero, rel: relations.relation(0x161)}, {Tag: One, rel: relations.relation(0x6d)}, {}, {}, {}},
0x01d9: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01da: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01db: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01dc: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01dd: {},
0x01de: {},
0x01df: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x01e0: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x01e1: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x01e2: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x01e3: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x01e4: {},
0x01e5: {},
0x01e6: {},
0x01e7: {},
0x01e8: {},
0x01e9: {{Tag: One, rel: relations.relation(0xd6)}, {Tag: Few, rel: relations.relation(0xfe)}, {Tag: Many, rel: relations.relation(0x10)}, {}, {}},
0x01ea: {{Tag: One, rel: relations.relation(0xd6)}, {Tag: Few, rel: relations.relation(0xfe)}, {Tag: Many, rel: relations.relation(0x10)}, {}, {}},
0x01eb: {},
0x01ec: {},
0x01ed: {},
0x01ee: {},
0x01ef: {},
0x01f0: {},
0x01f1: {{Tag: Zero, rel: relations.relation(0xa5)}, {Tag: One, rel: relations.relation(0xb7)}, {}, {}, {}},
0x01f2: {{Tag: Zero, rel: relations.relation(0xa5)}, {Tag: One, rel: relations.relation(0xb7)}, {}, {}, {}},
0x01f3: {},
0x01f4: {},
0x01f5: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01f6: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01f7: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01f8: {},
0x01f9: {},
0x01fa: {},
0x01fb: {},
0x01fc: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x01fd: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x01fe: {},
0x01ff: {},
0x0200: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0201: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0202: {},
0x0203: {},
0x0204: {{Tag: One, rel: relations.relation(0x245)}, {}, {}, {}, {}},
0x0205: {{Tag: One, rel: relations.relation(0x245)}, {}, {}, {}, {}},
0x0206: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0207: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0208: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0209: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x020a: {},
0x020b: {},
0x020c: {},
0x020d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x020e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x020f: {},
0x0210: {},
0x0211: {},
0x0212: {},
0x0213: {},
0x0214: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Few, rel: relations.relation(0x164)}, {Tag: Many, rel: relations.relation(0x130)}, {}, {}},
0x0215: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Few, rel: relations.relation(0x164)}, {Tag: Many, rel: relations.relation(0x130)}, {}, {}},
0x0216: {},
0x0217: {},
0x0218: {},
0x0219: {},
0x021a: {},
0x021b: {},
0x021c: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x021d: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x021e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x021f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0220: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0221: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0222: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0223: {},
0x0224: {},
0x0225: {},
0x0226: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0227: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0228: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0229: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x022a: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x022b: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x022c: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x022d: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x022e: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x022f: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0230: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0231: {},
0x0232: {},
0x0233: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0234: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0235: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0236: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0237: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0238: {},
0x0239: {},
0x023a: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x023b: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x023c: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x023d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x023e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x023f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0240: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0241: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0242: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0243: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0244: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x0245: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x0246: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x0247: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x0248: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x0249: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x024a: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x024b: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x20f)}, {}, {}},
0x024c: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x20f)}, {}, {}},
0x024d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x024e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x024f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0250: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0251: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0252: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0253: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0254: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0255: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0256: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0257: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0258: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x0259: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x025a: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x025b: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x025c: {{Tag: One, rel: relations.relation(0x6a)}, {Tag: Many, rel: relations.relation(0x1)}, {}, {}, {}},
0x025d: {},
0x025e: {},
0x025f: {},
0x0260: {},
0x0261: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0262: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0263: {},
0x0264: {},
0x0265: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x206)}, {}, {}, {}},
0x0266: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x206)}, {}, {}, {}},
0x0267: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x206)}, {}, {}, {}},
0x0268: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0269: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x026a: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x026b: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x026c: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x026d: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x026e: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x026f: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x0270: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x0271: {},
0x0272: {},
0x0273: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0274: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0275: {},
0x0276: {},
0x0277: {},
0x0278: {},
0x0279: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x027a: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x027b: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x027c: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x027d: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x027e: {},
0x027f: {},
0x0280: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0281: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0282: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0283: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0284: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0285: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0286: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0287: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x0288: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x0289: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x028a: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x028b: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x028c: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x028d: {},
0x028e: {},
0x028f: {},
0x0290: {},
0x0291: {{Tag: One, rel: relations.relation(0x64)}, {Tag: Few, rel: relations.relation(0x1cc)}, {}, {}, {}},
0x0292: {{Tag: One, rel: relations.relation(0x64)}, {Tag: Few, rel: relations.relation(0x1cc)}, {}, {}, {}},
0x0293: {{Tag: One, rel: relations.relation(0x64)}, {Tag: Few, rel: relations.relation(0x1cc)}, {}, {}, {}},
0x0294: {{Tag: One, rel: relations.relation(0x64)}, {Tag: Few, rel: relations.relation(0x1cc)}, {}, {}, {}},
0x0295: {{Tag: One, rel: relations.relation(0x64)}, {Tag: Few, rel: relations.relation(0x1cc)}, {}, {}, {}},
0x0296: {{Tag: One, rel: relations.relation(0x172)}, {}, {}, {}, {}},
0x0297: {{Tag: One, rel: relations.relation(0x172)}, {}, {}, {}, {}},
0x0298: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x82)}, {Tag: Many, rel: relations.relation(0x203)}, {}, {}},
0x0299: {{Tag: One, rel: relations.relation(0x76)}, {Tag: Few, rel: relations.relation(0x82)}, {Tag: Many, rel: relations.relation(0x203)}, {}, {}},
0x029a: {{Tag: One, rel: relations.relation(0x280)}, {Tag: Two, rel: relations.relation(0x28f)}, {Tag: Few, rel: relations.relation(0x2a7)}, {}, {}},
0x029b: {{Tag: One, rel: relations.relation(0x280)}, {Tag: Two, rel: relations.relation(0x28f)}, {Tag: Few, rel: relations.relation(0x2a7)}, {}, {}},
0x029c: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x029d: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {}, {}, {}},
0x029e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x029f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a0: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a1: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a2: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a3: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a4: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a5: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a6: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a7: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a8: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02a9: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02aa: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02ab: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02ac: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02ad: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02ae: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02af: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02b0: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02b1: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02b2: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02b3: {{Tag: One, rel: relations.relation(0x245)}, {Tag: Few, rel: relations.relation(0x263)}, {}, {}, {}},
0x02b4: {},
0x02b5: {},
0x02b6: {},
0x02b7: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02b8: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02b9: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02ba: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02bb: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02bc: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02bd: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02be: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02bf: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02c0: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c1: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c2: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c3: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c4: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c5: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c6: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c7: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c8: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02c9: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02ca: {},
0x02cb: {},
0x02cc: {},
0x02cd: {},
0x02ce: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x02cf: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x02d0: {{Tag: One, rel: relations.relation(0x16f)}, {}, {}, {}, {}},
0x02d1: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02d2: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02d3: {},
0x02d4: {},
0x02d5: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02d6: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02d7: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02d8: {},
0x02d9: {},
0x02da: {},
0x02db: {},
0x02dc: {{Tag: One, rel: relations.relation(0x17b)}, {}, {}, {}, {}},
0x02dd: {{Tag: One, rel: relations.relation(0x17b)}, {}, {}, {}, {}},
0x02de: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02df: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02e0: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x02e1: {{Tag: One, rel: relations.relation(0x23c)}, {Tag: Few, rel: relations.relation(0x25a)}, {Tag: Many, rel: relations.relation(0x224)}, {}, {}},
0x02e2: {},
0x02e3: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02e4: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02e5: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x02e6: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02e7: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02e8: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02e9: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02ea: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02eb: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02ec: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02ed: {},
0x02ee: {},
0x02ef: {},
0x02f0: {},
0x02f1: {},
0x02f2: {},
0x02f3: {},
0x02f4: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02f5: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02f6: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02f7: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02f8: {},
0x02f9: {},
0x02fa: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02fb: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02fc: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02fd: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02fe: {},
0x02ff: {},
0x0300: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0301: {{Tag: One, rel: relations.relation(0x76)}, {}, {}, {}, {}},
0x0302: {},
0x0303: {},
0x0304: {},
0x0305: {},
0x0306: {},
0x0307: {},
0x0308: {},
0x0309: {},
0x030a: {},
0x030b: {},
0x030c: {},
0x030d: {},
0x030e: {},
0x030f: {},
0x0310: {},
0x0311: {},
0x0312: {},
0x0313: {},
0x0314: {},
0x0315: {},
0x0316: {},
0x0317: {},
0x0318: {},
0x0319: {},
0x031a: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
0x031b: {{Tag: One, rel: relations.relation(0x64)}, {}, {}, {}, {}},
})
// ordinal plurals
testLookupPlural(t, "ordinal", OrdinalPlural, map[Locale]Plural{
0x0001: {},
0x0002: {},
0x0003: {},
0x0004: {},
0x0005: {},
0x0006: {},
0x0007: {},
0x0008: {},
0x0009: {},
0x000a: {},
0x000b: {},
0x000c: {},
0x000d: {},
0x000e: {},
0x000f: {},
0x0010: {},
0x0011: {},
0x0012: {},
0x0013: {},
0x0014: {},
0x0015: {},
0x0016: {},
0x0017: {},
0x0018: {},
0x0019: {},
0x001a: {},
0x001b: {},
0x001c: {},
0x001d: {},
0x001e: {},
0x001f: {},
0x0020: {},
0x0021: {},
0x0022: {},
0x0023: {},
0x0024: {},
0x0025: {},
0x0026: {},
0x0027: {{Tag: One, rel: relations.relation(0x19c)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0028: {{Tag: One, rel: relations.relation(0x19c)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0029: {},
0x002a: {},
0x002b: {},
0x002c: {},
0x002d: {{Tag: One, rel: relations.relation(0x19)}, {Tag: Few, rel: relations.relation(0x2f)}, {Tag: Many, rel: relations.relation(0x4b)}, {}, {}},
0x002e: {{Tag: One, rel: relations.relation(0x19)}, {Tag: Few, rel: relations.relation(0x2f)}, {Tag: Many, rel: relations.relation(0x4b)}, {}, {}},
0x002f: {{Tag: One, rel: relations.relation(0x19)}, {Tag: Few, rel: relations.relation(0x2f)}, {Tag: Many, rel: relations.relation(0x4b)}, {}, {}},
0x0030: {{Tag: One, rel: relations.relation(0x19)}, {Tag: Few, rel: relations.relation(0x2f)}, {Tag: Many, rel: relations.relation(0x4b)}, {}, {}},
0x0031: {{Tag: One, rel: relations.relation(0x19)}, {Tag: Few, rel: relations.relation(0x2f)}, {Tag: Many, rel: relations.relation(0x4b)}, {}, {}},
0x0032: {},
0x0033: {},
0x0034: {{Tag: Few, rel: relations.relation(0xf2)}, {}, {}, {}, {}},
0x0035: {{Tag: Few, rel: relations.relation(0xf2)}, {}, {}, {}, {}},
0x0036: {},
0x0037: {},
0x0038: {},
0x0039: {},
0x003a: {},
0x003b: {},
0x003c: {},
0x003d: {},
0x003e: {{Tag: One, rel: relations.relation(0x19c)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x003f: {{Tag: One, rel: relations.relation(0x19c)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0040: {{Tag: One, rel: relations.relation(0x19c)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0041: {},
0x0042: {},
0x0043: {},
0x0044: {},
0x0045: {},
0x0046: {},
0x0047: {},
0x0048: {},
0x0049: {},
0x004a: {},
0x004b: {},
0x004c: {},
0x004d: {{Tag: One, rel: relations.relation(0x192)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1e5)}, {}, {}},
0x004e: {{Tag: One, rel: relations.relation(0x192)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1e5)}, {}, {}},
0x004f: {{Tag: One, rel: relations.relation(0x192)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1e5)}, {}, {}},
0x0050: {{Tag: One, rel: relations.relation(0x192)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1e5)}, {}, {}},
0x0051: {{Tag: One, rel: relations.relation(0x192)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1e5)}, {}, {}},
0x0052: {},
0x0053: {},
0x0054: {},
0x0055: {},
0x0056: {},
0x0057: {},
0x0058: {},
0x0059: {},
0x005a: {},
0x005b: {},
0x005c: {},
0x005d: {},
0x005e: {},
0x005f: {},
0x0060: {},
0x0061: {},
0x0062: {{Tag: Zero, rel: relations.relation(0x16a)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1df)}, {Tag: Many, rel: relations.relation(0x1ee)}},
0x0063: {{Tag: Zero, rel: relations.relation(0x16a)}, {Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1c4)}, {Tag: Few, rel: relations.relation(0x1df)}, {Tag: Many, rel: relations.relation(0x1ee)}},
0x0064: {},
0x0065: {},
0x0066: {},
0x0067: {},
0x0068: {},
0x0069: {},
0x006a: {},
0x006b: {},
0x006c: {},
0x006d: {},
0x006e: {},
0x006f: {},
0x0070: {},
0x0071: {},
0x0072: {},
0x0073: {},
0x0074: {},
0x0075: {},
0x0076: {},
0x0077: {},
0x0078: {},
0x0079: {},
0x007a: {},
0x007b: {},
0x007c: {},
0x007d: {},
0x007e: {},
0x007f: {},
0x0080: {},
0x0081: {},
0x0082: {},
0x0083: {},
0x0084: {},
0x0085: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0086: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0087: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0088: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0089: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x008a: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x008b: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x008c: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x008d: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x008e: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x008f: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0090: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0091: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0092: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0093: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0094: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0095: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0096: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0097: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0098: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x0099: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x009a: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x009b: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x009c: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x009d: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x009e: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x009f: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a0: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a1: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a2: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a3: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a4: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a5: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a6: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a7: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a8: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00a9: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00aa: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ab: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ac: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ad: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ae: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00af: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b0: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b1: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b2: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b3: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b4: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b5: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b6: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b7: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b8: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00b9: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ba: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00bb: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00bc: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00bd: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00be: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00bf: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c0: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c1: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c2: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c3: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c4: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c5: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c6: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c7: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c8: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00c9: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ca: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00cb: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00cc: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00cd: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ce: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00cf: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d0: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d1: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d2: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d3: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d4: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d5: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d6: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d7: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d8: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00d9: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00da: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00db: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00dc: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00dd: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00de: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00df: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e0: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e1: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e2: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e3: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e4: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e5: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e6: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e7: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e8: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00e9: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ea: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00eb: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ec: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ed: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ee: {{Tag: One, rel: relations.relation(0xb1)}, {Tag: Two, rel: relations.relation(0xe2)}, {Tag: Few, rel: relations.relation(0x104)}, {}, {}},
0x00ef: {},
0x00f0: {},
0x00f1: {},
0x00f2: {},
0x00f3: {},
0x00f4: {},
0x00f5: {},
0x00f6: {},
0x00f7: {},
0x00f8: {},
0x00f9: {},
0x00fa: {},
0x00fb: {},
0x00fc: {},
0x00fd: {},
0x00fe: {},
0x00ff: {},
0x0100: {},
0x0101: {},
0x0102: {},
0x0103: {},
0x0104: {},
0x0105: {},
0x0106: {},
0x0107: {},
0x0108: {},
0x0109: {},
0x010a: {},
0x010b: {},
0x010c: {},
0x010d: {},
0x010e: {},
0x010f: {},
0x0110: {},
0x0111: {},
0x0112: {},
0x0113: {},
0x0114: {},
0x0115: {},
0x0116: {},
0x0117: {},
0x0118: {},
0x0119: {},
0x011a: {},
0x011b: {},
0x011c: {},
0x011d: {},
0x011e: {},
0x011f: {},
0x0120: {},
0x0121: {},
0x0122: {},
0x0123: {},
0x0124: {},
0x0125: {},
0x0126: {},
0x0127: {},
0x0128: {},
0x0129: {},
0x012a: {},
0x012b: {},
0x012c: {},
0x012d: {},
0x012e: {},
0x012f: {},
0x0130: {},
0x0131: {},
0x0132: {},
0x0133: {},
0x0134: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0135: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0136: {},
0x0137: {},
0x0138: {},
0x0139: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x013a: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x013b: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x013c: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x013d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x013e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x013f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0140: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0141: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0142: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0143: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0144: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0145: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0146: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0147: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0148: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0149: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x014a: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x014b: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x014c: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x014d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x014e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x014f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0150: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0151: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0152: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0153: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0154: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0155: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0156: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0157: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0158: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0159: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x015a: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x015b: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x015c: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x015d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x015e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x015f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0160: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0161: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0162: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0163: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0164: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0165: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0166: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0167: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0168: {},
0x0169: {},
0x016a: {},
0x016b: {},
0x016c: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x016d: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x016e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x016f: {{Tag: One, rel: relations.relation(0x18d)}, {Tag: Two, rel: relations.relation(0x1c7)}, {Tag: Few, rel: relations.relation(0x1d5)}, {}, {}},
0x0170: {{Tag: One, rel: relations.relation(0x18d)}, {Tag: Two, rel: relations.relation(0x1c7)}, {Tag: Few, rel: relations.relation(0x1d5)}, {}, {}},
0x0171: {},
0x0172: {},
0x0173: {},
0x0174: {},
0x0175: {},
0x0176: {},
0x0177: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0178: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0179: {},
0x017a: {},
0x017b: {},
0x017c: {},
0x017d: {},
0x017e: {},
0x017f: {},
0x0180: {},
0x0181: {},
0x0182: {},
0x0183: {},
0x0184: {},
0x0185: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0186: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0187: {},
0x0188: {},
0x0189: {},
0x018a: {},
0x018b: {},
0x018c: {{Tag: One, rel: relations.relation(0x197)}, {}, {}, {}, {}},
0x018d: {{Tag: One, rel: relations.relation(0x197)}, {}, {}, {}, {}},
0x018e: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x018f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0190: {},
0x0191: {},
0x0192: {},
0x0193: {},
0x0194: {},
0x0195: {},
0x0196: {},
0x0197: {},
0x0198: {},
0x0199: {},
0x019a: {{Tag: Many, rel: relations.relation(0x1bb)}, {}, {}, {}, {}},
0x019b: {{Tag: Many, rel: relations.relation(0x1bb)}, {}, {}, {}, {}},
0x019c: {{Tag: Many, rel: relations.relation(0x1bb)}, {}, {}, {}, {}},
0x019d: {{Tag: Many, rel: relations.relation(0x1bb)}, {}, {}, {}, {}},
0x019e: {{Tag: Many, rel: relations.relation(0x1bb)}, {}, {}, {}, {}},
0x019f: {},
0x01a0: {},
0x01a1: {},
0x01a2: {},
0x01a3: {},
0x01a4: {},
0x01a5: {},
0x01a6: {},
0x01a7: {{Tag: One, rel: relations.relation(0x73)}, {Tag: Many, rel: relations.relation(0x58)}, {}, {}, {}},
0x01a8: {{Tag: One, rel: relations.relation(0x73)}, {Tag: Many, rel: relations.relation(0x58)}, {}, {}, {}},
0x01a9: {},
0x01aa: {},
0x01ab: {},
0x01ac: {},
0x01ad: {},
0x01ae: {},
0x01af: {},
0x01b0: {},
0x01b1: {},
0x01b2: {},
0x01b3: {},
0x01b4: {},
0x01b5: {},
0x01b6: {},
0x01b7: {{Tag: Many, rel: relations.relation(0x11c)}, {}, {}, {}, {}},
0x01b8: {{Tag: Many, rel: relations.relation(0x11c)}, {}, {}, {}, {}},
0x01b9: {},
0x01ba: {},
0x01bb: {},
0x01bc: {},
0x01bd: {},
0x01be: {},
0x01bf: {},
0x01c0: {},
0x01c1: {},
0x01c2: {},
0x01c3: {},
0x01c4: {},
0x01c5: {},
0x01c6: {},
0x01c7: {},
0x01c8: {},
0x01c9: {},
0x01ca: {},
0x01cb: {},
0x01cc: {},
0x01cd: {},
0x01ce: {},
0x01cf: {},
0x01d0: {},
0x01d1: {},
0x01d2: {},
0x01d3: {{Tag: One, rel: relations.relation(0x1ad)}, {Tag: Many, rel: relations.relation(0x1e8)}, {}, {}, {}},
0x01d4: {{Tag: One, rel: relations.relation(0x1ad)}, {Tag: Many, rel: relations.relation(0x1e8)}, {}, {}, {}},
0x01d5: {},
0x01d6: {},
0x01d7: {},
0x01d8: {},
0x01d9: {},
0x01da: {},
0x01db: {},
0x01dc: {},
0x01dd: {},
0x01de: {},
0x01df: {},
0x01e0: {},
0x01e1: {},
0x01e2: {},
0x01e3: {},
0x01e4: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01e5: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x01e6: {},
0x01e7: {},
0x01e8: {},
0x01e9: {},
0x01ea: {},
0x01eb: {},
0x01ec: {},
0x01ed: {},
0x01ee: {},
0x01ef: {},
0x01f0: {},
0x01f1: {},
0x01f2: {},
0x01f3: {},
0x01f4: {},
0x01f5: {},
0x01f6: {},
0x01f7: {},
0x01f8: {},
0x01f9: {},
0x01fa: {},
0x01fb: {},
0x01fc: {},
0x01fd: {},
0x01fe: {},
0x01ff: {},
0x0200: {},
0x0201: {},
0x0202: {},
0x0203: {},
0x0204: {{Tag: One, rel: relations.relation(0x13)}, {Tag: Two, rel: relations.relation(0x29)}, {Tag: Many, rel: relations.relation(0x45)}, {}, {}},
0x0205: {{Tag: One, rel: relations.relation(0x13)}, {Tag: Two, rel: relations.relation(0x29)}, {Tag: Many, rel: relations.relation(0x45)}, {}, {}},
0x0206: {},
0x0207: {},
0x0208: {},
0x0209: {},
0x020a: {},
0x020b: {},
0x020c: {},
0x020d: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {}, {}},
0x020e: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {}, {}},
0x020f: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0210: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0211: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0212: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0213: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0214: {},
0x0215: {},
0x0216: {},
0x0217: {},
0x0218: {},
0x0219: {},
0x021a: {},
0x021b: {},
0x021c: {},
0x021d: {},
0x021e: {},
0x021f: {},
0x0220: {},
0x0221: {},
0x0222: {},
0x0223: {},
0x0224: {},
0x0225: {},
0x0226: {{Tag: One, rel: relations.relation(0x1aa)}, {}, {}, {}, {}},
0x0227: {{Tag: One, rel: relations.relation(0x1aa)}, {}, {}, {}, {}},
0x0228: {{Tag: One, rel: relations.relation(0x1aa)}, {}, {}, {}, {}},
0x0229: {},
0x022a: {},
0x022b: {},
0x022c: {},
0x022d: {},
0x022e: {},
0x022f: {},
0x0230: {},
0x0231: {},
0x0232: {},
0x0233: {},
0x0234: {},
0x0235: {},
0x0236: {},
0x0237: {},
0x0238: {},
0x0239: {},
0x023a: {},
0x023b: {},
0x023c: {},
0x023d: {},
0x023e: {},
0x023f: {{Tag: One, rel: relations.relation(0x1a3)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0240: {{Tag: One, rel: relations.relation(0x1a3)}, {Tag: Two, rel: relations.relation(0x1cf)}, {Tag: Few, rel: relations.relation(0x1e5)}, {Tag: Many, rel: relations.relation(0x1f1)}, {}},
0x0241: {},
0x0242: {},
0x0243: {},
0x0244: {},
0x0245: {},
0x0246: {},
0x0247: {},
0x0248: {},
0x0249: {},
0x024a: {},
0x024b: {},
0x024c: {},
0x024d: {},
0x024e: {},
0x024f: {},
0x0250: {},
0x0251: {},
0x0252: {},
0x0253: {},
0x0254: {},
0x0255: {},
0x0256: {},
0x0257: {},
0x0258: {},
0x0259: {},
0x025a: {},
0x025b: {},
0x025c: {},
0x025d: {},
0x025e: {},
0x025f: {},
0x0260: {},
0x0261: {},
0x0262: {},
0x0263: {},
0x0264: {},
0x0265: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0266: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0267: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x0268: {},
0x0269: {},
0x026a: {},
0x026b: {},
0x026c: {},
0x026d: {},
0x026e: {},
0x026f: {},
0x0270: {},
0x0271: {},
0x0272: {},
0x0273: {},
0x0274: {},
0x0275: {},
0x0276: {},
0x0277: {},
0x0278: {},
0x0279: {},
0x027a: {},
0x027b: {},
0x027c: {},
0x027d: {},
0x027e: {},
0x027f: {},
0x0280: {{Tag: Many, rel: relations.relation(0x1bb)}, {}, {}, {}, {}},
0x0281: {{Tag: Many, rel: relations.relation(0x1bb)}, {}, {}, {}, {}},
0x0282: {},
0x0283: {},
0x0284: {},
0x0285: {},
0x0286: {},
0x0287: {},
0x0288: {},
0x0289: {},
0x028a: {},
0x028b: {},
0x028c: {},
0x028d: {},
0x028e: {},
0x028f: {},
0x0290: {},
0x0291: {},
0x0292: {},
0x0293: {},
0x0294: {},
0x0295: {},
0x0296: {},
0x0297: {},
0x0298: {},
0x0299: {},
0x029a: {},
0x029b: {},
0x029c: {},
0x029d: {},
0x029e: {},
0x029f: {},
0x02a0: {},
0x02a1: {},
0x02a2: {},
0x02a3: {},
0x02a4: {},
0x02a5: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x116)}, {}, {}, {}},
0x02a6: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x116)}, {}, {}, {}},
0x02a7: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x116)}, {}, {}, {}},
0x02a8: {{Tag: One, rel: relations.relation(0x181)}, {Tag: Many, rel: relations.relation(0x116)}, {}, {}, {}},
0x02a9: {},
0x02aa: {},
0x02ab: {},
0x02ac: {},
0x02ad: {},
0x02ae: {},
0x02af: {},
0x02b0: {},
0x02b1: {},
0x02b2: {},
0x02b3: {},
0x02b4: {},
0x02b5: {},
0x02b6: {},
0x02b7: {{Tag: One, rel: relations.relation(0xdc)}, {}, {}, {}, {}},
0x02b8: {{Tag: One, rel: relations.relation(0xdc)}, {}, {}, {}, {}},
0x02b9: {{Tag: One, rel: relations.relation(0xdc)}, {}, {}, {}, {}},
0x02ba: {{Tag: One, rel: relations.relation(0xdc)}, {}, {}, {}, {}},
0x02bb: {},
0x02bc: {},
0x02bd: {},
0x02be: {},
0x02bf: {},
0x02c0: {},
0x02c1: {},
0x02c2: {},
0x02c3: {},
0x02c4: {},
0x02c5: {},
0x02c6: {},
0x02c7: {},
0x02c8: {},
0x02c9: {},
0x02ca: {},
0x02cb: {},
0x02cc: {},
0x02cd: {},
0x02ce: {},
0x02cf: {},
0x02d0: {},
0x02d1: {{Tag: Few, rel: relations.relation(0x128)}, {}, {}, {}, {}},
0x02d2: {{Tag: Few, rel: relations.relation(0x128)}, {}, {}, {}, {}},
0x02d3: {},
0x02d4: {},
0x02d5: {},
0x02d6: {},
0x02d7: {},
0x02d8: {},
0x02d9: {},
0x02da: {},
0x02db: {},
0x02dc: {},
0x02dd: {},
0x02de: {},
0x02df: {},
0x02e0: {{Tag: Few, rel: relations.relation(0x104)}, {}, {}, {}, {}},
0x02e1: {{Tag: Few, rel: relations.relation(0x104)}, {}, {}, {}, {}},
0x02e2: {},
0x02e3: {},
0x02e4: {},
0x02e5: {},
0x02e6: {},
0x02e7: {},
0x02e8: {},
0x02e9: {},
0x02ea: {},
0x02eb: {},
0x02ec: {},
0x02ed: {},
0x02ee: {},
0x02ef: {},
0x02f0: {},
0x02f1: {},
0x02f2: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02f3: {{Tag: One, rel: relations.relation(0x181)}, {}, {}, {}, {}},
0x02f4: {},
0x02f5: {},
0x02f6: {},
0x02f7: {},
0x02f8: {},
0x02f9: {},
0x02fa: {},
0x02fb: {},
0x02fc: {},
0x02fd: {},
0x02fe: {},
0x02ff: {},
0x0300: {},
0x0301: {},
0x0302: {},
0x0303: {},
0x0304: {},
0x0305: {},
0x0306: {},
0x0307: {},
0x0308: {},
0x0309: {},
0x030a: {},
0x030b: {},
0x030c: {},
0x030d: {},
0x030e: {},
0x030f: {},
0x0310: {},
0x0311: {},
0x0312: {},
0x0313: {},
0x0314: {},
0x0315: {},
0x0316: {},
0x0317: {},
0x0318: {},
0x0319: {},
0x031a: {},
0x031b: {},
})
}
func testLookupPlural(t *testing.T, typ string, lookup func(Locale) Plural, expected map[Locale]Plural) {
for loc, expectedPlural := range expected {
plural := lookup(loc)
if !reflect.DeepEqual(plural, expectedPlural) {
t.Fatalf("unexpected plural for %s", loc.String())
}
}
}
func TestRelation(t *testing.T) {
rel := relation{0x548b, 0x0, 0x0, 0x0, 0x0, 0x77}
if op := rel.operand(); op != 5 {
t.Errorf("unexpected operand: %d", op)
}
if modexp := rel.modexp(); modexp != 4 {
t.Errorf("unexpected modulo exponent: %d", modexp)
}
if op := rel.operator(); op != 1 {
t.Errorf("unexpected operator: %d", op)
}
if rc := rel.rangeCount(); rc != 2 {
t.Errorf("unexpected range count: %d", rc)
}
if c := rel.connective(); c != 3 {
t.Errorf("unexpected connective: %d", c)
}
if r := rel.ranges(); !reflect.DeepEqual(r, rel[1:5]) {
t.Errorf("unexpected ranges: %v", r)
}
if nxt := rel.next(); !reflect.DeepEqual(nxt, rel[5:]) {
t.Errorf("unexpected next value: %v", nxt)
}
}
func TestRelationLookup(t *testing.T) {
lookup := relationLookup{1, 2, 3}
if r := lookup.relation(0); len(r) != 0 {
t.Errorf("unexpected relation: %v", r)
}
if r := lookup.relation(1); !reflect.DeepEqual(r, relation(lookup)) {
t.Errorf("unexpected relation: %v", r)
}
if r := lookup.relation(2); !reflect.DeepEqual(r, relation(lookup[1:])) {
t.Errorf("unexpected relation: %v", r)
}
}
func TestPluralRule(t *testing.T) {
const rule pluralRule = 0x4007
if tag := rule.tag(); tag != 2 {
t.Errorf("unexpected tag: %d", tag)
}
if rid := rule.relationID(); rid != 7 {
t.Errorf("unexpected relation id: %d", rid)
}
}
|
package main
import "fmt"
type Stu struct {
Name string
Age int
Address string
}
func main() {
students := make(map[string]Stu)
stu01 := Stu{
"tom",
18,
"aaa",
}
stu02 := Stu{
"jerry",
19,
"bbb",
}
students["001"] = stu01
students["002"] = stu02
fmt.Println(students)
for k, v := range students {
fmt.Printf("stu number is %v\n", k)
fmt.Printf("stu name is %v\n", v.Name)
fmt.Printf("stu age is %v\n", v.Age)
fmt.Printf("stu add is %v\n", v.Address)
fmt.Println()
}
}
|
package main
import (
"fmt"
)
/**
* @brief { reads and integer ans checks for errors, an rune input is an error }
*
* @param name The name of the variable, for error log
*
* @return { the readed value }
*/
func readcheck(name string) int {
var aux int
_, err := fmt.Scanf("%d", &aux)
if err != nil {
fmt.Println("There is a problem to read the variable ", name)
return -1
}
return aux
}
func main() {
// path := make([][]int, 192)
var landmarks int
var friends int
landmarks = readcheck("landmarks")
friends = readcheck("friends")
fmt.Println(landmarks)
fmt.Println(friends)
}
|
package conf
//应用端口
type AppConfig struct {
Port string
}
//数据库配置信息
type MySqlConfig struct {
Username string
Password string
FdnUrl string
GtyUrl string
}
type LoggerConfig struct {
LoggerPath string
LoggerLevel string
}
type ProjectConfig struct {
Mysql MySqlConfig
LoggerInfo LoggerConfig
AppConfig AppConfig
}
|
package main
import "fmt"
func fact(x uint) uint{
if x == 0 {
return 1
}
return x * fact(x - 1)
}
|
package controllers
import (
"strconv"
"github.com/itang/gotang"
"github.com/revel/revel"
"github.com/itang/yunshang/main/app/models"
"github.com/itang/yunshang/modules/oauth"
)
type socialAuther struct {
}
func (p *socialAuther) IsUserLogin(ctx *revel.Controller) (int64, bool) {
us, ok := ctx.Session["uid"]
i, err := strconv.Atoi(us)
return int64(i), ok && err == nil
}
func (p *socialAuther) LoginUser(ctx *revel.Controller, uid int64, socialType oauth.SocialType) (string, error) {
passport, ok := ctx.AppController.(*Passport)
gotang.Assert(ok, "FROM passport")
user, ok := passport.userApi().GetUserById(uid)
revel.INFO.Printf("user:id %v, %v", user.Id, user)
gotang.Assert(ok, "user not exists")
if !ok || !user.Enabled {
passport.Flash.Error("用户信息不存在或被禁用，有任何疑问请联系本站客服！")
return "/passport/login", nil
}
passport.setLoginSession(models.ToSessionUser(user))
// 执行登录后操作
go passport.userApi().DoUserLogin(&user)
return "/", nil
}
|
package problem0056
import "math/rand"
// Interval Definition for an interval.
type Interval struct {
Start int
End int
}
func merge(its []Interval) []Interval {
if len(its) <= 1 {
return its
}
quickSort(its)
res := make([]Interval, 0, len(its))
temp := its[0]
for i := 1; i < len(its); i++ {
if its[i].Start <= temp.End {
temp.End = max(temp.End, its[i].End)
continue
}
res = append(res, temp)
temp = its[i]
}
res = append(res, temp)
return res
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
func quickSort(is []Interval) {
if len(is) <= 1 {
return
}
j := rand.Intn(len(is))
is[0], is[j] = is[j], is[0]
j = partition(is)
quickSort(is[0:j])
quickSort(is[j+1:])
}
func partition(is []Interval) int {
i, j := 1, len(is)-1
for {
for is[i].Start <= is[0].Start && i < len(is)-1 {
i++
}
for is[0].Start <= is[j].Start && j > 0 {
j--
}
if i >= j {
break
}
is[i], is[j] = is[j], is[i]
}
is[0], is[j] = is[j], is[0]
return j
}
|
// Copyright 2015 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package ddl
import (
"context"
"testing"
"time"
"github.com/pingcap/tidb/infoschema"
"github.com/pingcap/tidb/kv"
"github.com/pingcap/tidb/meta"
"github.com/pingcap/tidb/parser/ast"
"github.com/pingcap/tidb/parser/model"
"github.com/pingcap/tidb/sessionctx"
"github.com/pingcap/tidb/store/mockstore"
"github.com/pingcap/tidb/table"
"github.com/pingcap/tidb/types"
"github.com/pingcap/tidb/util/mock"
"github.com/stretchr/testify/require"
)
type DDLForTest interface {
// SetInterceptor sets the interceptor.
SetInterceptor(h Interceptor)
}
// SetInterceptor implements DDL.SetInterceptor interface.
func (d *ddl) SetInterceptor(i Interceptor) {
d.mu.Lock()
defer d.mu.Unlock()
d.mu.interceptor = i
}
// generalWorker returns the general worker.
func (d *ddl) generalWorker() *worker {
return d.workers[generalWorker]
}
// GetMaxRowID is used for test.
func GetMaxRowID(store kv.Storage, priority int, t table.Table, startHandle, endHandle kv.Key) (kv.Key, error) {
return getRangeEndKey(store, priority, t, startHandle, endHandle)
}
func testNewDDLAndStart(ctx context.Context, options ...Option) (*ddl, error) {
// init infoCache and a stub infoSchema
ic := infoschema.NewCache(2)
ic.Insert(infoschema.MockInfoSchemaWithSchemaVer(nil, 0), 0)
options = append(options, WithInfoCache(ic))
d := newDDL(ctx, options...)
err := d.Start(nil)
return d, err
}
func createMockStore(t *testing.T) kv.Storage {
store, err := mockstore.NewMockStore()
require.NoError(t, err)
return store
}
func testNewContext(d *ddl) sessionctx.Context {
ctx := mock.NewContext()
ctx.Store = d.store
return ctx
}
func getSchemaVer(t *testing.T, ctx sessionctx.Context) int64 {
err := ctx.NewTxn(context.Background())
require.NoError(t, err)
txn, err := ctx.Txn(true)
require.NoError(t, err)
m := meta.NewMeta(txn)
ver, err := m.GetSchemaVersion()
require.NoError(t, err)
return ver
}
type historyJobArgs struct {
ver int64
db *model.DBInfo
tbl *model.TableInfo
tblIDs map[int64]struct{}
}
func checkEqualTable(t *testing.T, t1, t2 *model.TableInfo) {
require.Equal(t, t1.ID, t2.ID)
require.Equal(t, t1.Name, t2.Name)
require.Equal(t, t1.Charset, t2.Charset)
require.Equal(t, t1.Collate, t2.Collate)
require.Equal(t, t1.PKIsHandle, t2.PKIsHandle)
require.Equal(t, t1.Comment, t2.Comment)
require.Equal(t, t1.AutoIncID, t2.AutoIncID)
}
func checkHistoryJob(t *testing.T, job *model.Job) {
require.Equal(t, job.State, model.JobStateSynced)
}
func checkHistoryJobArgs(t *testing.T, ctx sessionctx.Context, id int64, args *historyJobArgs) {
txn, err := ctx.Txn(true)
require.NoError(t, err)
tran := meta.NewMeta(txn)
historyJob, err := tran.GetHistoryDDLJob(id)
require.NoError(t, err)
require.Greater(t, historyJob.BinlogInfo.FinishedTS, uint64(0))
if args.tbl != nil {
require.Equal(t, historyJob.BinlogInfo.SchemaVersion, args.ver)
checkEqualTable(t, historyJob.BinlogInfo.TableInfo, args.tbl)
return
}
// for handling schema job
require.Equal(t, historyJob.BinlogInfo.SchemaVersion, args.ver)
require.Equal(t, historyJob.BinlogInfo.DBInfo, args.db)
// only for creating schema job
if args.db != nil && len(args.tblIDs) == 0 {
return
}
}
func buildCreateIdxJob(dbInfo *model.DBInfo, tblInfo *model.TableInfo, unique bool, indexName string, colName string) *model.Job {
return &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionAddIndex,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{unique, model.NewCIStr(indexName),
[]*ast.IndexPartSpecification{{
Column: &ast.ColumnName{Name: model.NewCIStr(colName)},
Length: types.UnspecifiedLength}}},
}
}
func testCreatePrimaryKey(t *testing.T, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, colName string) *model.Job {
job := buildCreateIdxJob(dbInfo, tblInfo, true, "primary", colName)
job.Type = model.ActionAddPrimaryKey
ctx.SetValue(sessionctx.QueryString, "skip")
err := d.doDDLJob(ctx, job)
require.NoError(t, err)
v := getSchemaVer(t, ctx)
checkHistoryJobArgs(t, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
return job
}
func testCreateIndex(t *testing.T, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, unique bool, indexName string, colName string) *model.Job {
job := buildCreateIdxJob(dbInfo, tblInfo, unique, indexName, colName)
ctx.SetValue(sessionctx.QueryString, "skip")
err := d.doDDLJob(ctx, job)
require.NoError(t, err)
v := getSchemaVer(t, ctx)
checkHistoryJobArgs(t, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
return job
}
func testAddColumn(t *testing.T, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, args []interface{}) *model.Job {
job := &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionAddColumn,
Args: args,
BinlogInfo: &model.HistoryInfo{},
}
ctx.SetValue(sessionctx.QueryString, "skip")
err := d.doDDLJob(ctx, job)
require.NoError(t, err)
v := getSchemaVer(t, ctx)
checkHistoryJobArgs(t, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
return job
}
func testAddColumns(t *testing.T, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, args []interface{}) *model.Job {
job := &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionAddColumns,
Args: args,
BinlogInfo: &model.HistoryInfo{},
}
ctx.SetValue(sessionctx.QueryString, "skip")
err := d.doDDLJob(ctx, job)
require.NoError(t, err)
v := getSchemaVer(t, ctx)
checkHistoryJobArgs(t, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
return job
}
func buildDropIdxJob(dbInfo *model.DBInfo, tblInfo *model.TableInfo, indexName string) *model.Job {
tp := model.ActionDropIndex
if indexName == "primary" {
tp = model.ActionDropPrimaryKey
}
return &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: tp,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{model.NewCIStr(indexName)},
}
}
func testDropIndex(t *testing.T, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, indexName string) *model.Job {
job := buildDropIdxJob(dbInfo, tblInfo, indexName)
ctx.SetValue(sessionctx.QueryString, "skip")
err := d.doDDLJob(ctx, job)
require.NoError(t, err)
v := getSchemaVer(t, ctx)
checkHistoryJobArgs(t, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
return job
}
func buildRebaseAutoIDJobJob(dbInfo *model.DBInfo, tblInfo *model.TableInfo, newBaseID int64) *model.Job {
return &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionRebaseAutoID,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{newBaseID},
}
}
func TestGetIntervalFromPolicy(t *testing.T) {
policy := []time.Duration{
1 * time.Second,
2 * time.Second,
}
var (
val time.Duration
changed bool
)
val, changed = getIntervalFromPolicy(policy, 0)
require.Equal(t, val, 1*time.Second)
require.True(t, changed)
val, changed = getIntervalFromPolicy(policy, 1)
require.Equal(t, val, 2*time.Second)
require.True(t, changed)
val, changed = getIntervalFromPolicy(policy, 2)
require.Equal(t, val, 2*time.Second)
require.False(t, changed)
val, changed = getIntervalFromPolicy(policy, 3)
require.Equal(t, val, 2*time.Second)
require.False(t, changed)
}
|
package ring
import (
"fmt"
"time"
"github.com/cortexproject/cortex/pkg/ring"
"github.com/cortexproject/cortex/pkg/ring/kv"
"github.com/prometheus/client_golang/prometheus"
)
// New creates a new distributed consistent hash ring. It shadows the cortex
// ring.New method so we can use our own replication strategy for repl factor = 2
func New(cfg ring.Config, name, key string, reg prometheus.Registerer) (*ring.Ring, error) {
if cfg.ReplicationFactor == 2 {
return newEventuallyConsistentRing(cfg, name, key, reg)
}
return ring.New(cfg, name, key, reg)
}
func newEventuallyConsistentRing(cfg ring.Config, name, key string, reg prometheus.Registerer) (*ring.Ring, error) {
codec := ring.GetCodec()
// Suffix all client names with "-ring" to denote this kv client is used by the ring
store, err := kv.NewClient(
cfg.KVStore,
codec,
kv.RegistererWithKVName(reg, name+"-ring"),
)
if err != nil {
return nil, err
}
return ring.NewWithStoreClientAndStrategy(cfg, name, key, store, &EventuallyConsistentStrategy{})
}
// EventuallyConsistentStrategy represents a repl strategy with a consistency of 1 on read and
// write. Note this is NOT strongly consistent! It is _eventually_ consistent :)
type EventuallyConsistentStrategy struct {
}
// Filter decides, given the set of ingesters eligible for a key,
// which ingesters you will try and write to and how many failures you will
// tolerate.
// - Filters out dead ingesters so the one doesn't even try to write to them.
// - Checks there is enough ingesters for an operation to succeed.
// The ingesters argument may be overwritten.
func (s *EventuallyConsistentStrategy) Filter(ingesters []ring.InstanceDesc, op ring.Operation, replicationFactor int, heartbeatTimeout time.Duration, zoneAwarenessEnabled bool) ([]ring.InstanceDesc, int, error) {
minSuccess := 1
// Skip those that have not heartbeated in a while. NB these are still
// included in the calculation of minSuccess, so if too many failed ingesters
// will cause the whole write to fail.
for i := 0; i < len(ingesters); {
if ingesters[i].IsHealthy(op, heartbeatTimeout, time.Now()) {
i++
} else {
ingesters = append(ingesters[:i], ingesters[i+1:]...)
}
}
// This is just a shortcut - if there are not minSuccess available ingesters,
// after filtering out dead ones, don't even bother trying.
if len(ingesters) < minSuccess {
err := fmt.Errorf("at least %d live replicas required, could only find %d",
minSuccess, len(ingesters))
return nil, 0, err
}
return ingesters, len(ingesters) - minSuccess, nil
}
func (s *EventuallyConsistentStrategy) ShouldExtendReplicaSet(ingester ring.InstanceDesc, op ring.Operation) bool {
// We do not want to Write to Ingesters that are not ACTIVE, but we do want
// to write the extra replica somewhere. So we increase the size of the set
// of replicas for the key. This means we have to also increase the
// size of the replica set for read, but we can read from Leaving ingesters,
// so don't skip it in this case.
// NB dead ingester will be filtered later by DefaultReplicationStrategy.Filter().
if op == ring.Write && ingester.State != ring.ACTIVE {
return true
} else if op == ring.Read && (ingester.State != ring.ACTIVE && ingester.State != ring.LEAVING) {
return true
}
return false
}
|
package main
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
func dfs(tr *TreeNode, d int, ans *[]int) {
if tr == nil {
return
}
if d > len(*ans) {
*ans = append(*ans, tr.Val)
} else {
(*ans)[d-1] = max((*ans)[d-1], tr.Val)
}
dfs(tr.Left, d+1, ans)
dfs(tr.Right, d+1, ans)
}
func largestValues(root *TreeNode) []int {
ans := make([]int, 0)
dfs(root, 1, &ans)
return ans
}
func main() {
}
|
package crd
import (
"fmt"
"testing"
"github.com/ghodss/yaml"
"github.com/stretchr/testify/assert"
meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func TestMarshal(t *testing.T) {
d := Database{
ObjectMeta: meta_v1.ObjectMeta{Name: "my_db", Namespace: "default"},
TypeMeta: meta_v1.TypeMeta{Kind: "Database", APIVersion: "k8s.io/v1"},
Spec: DatabaseSpec{
BackupRetentionPeriod: 10,
Class: "db.t2.micro",
DBName: "database_name",
Engine: "postgres",
Iops: 1000,
MultiAZ: true,
Password: PasswordSecret{Key: "key", Name: "DB-Secret"},
PubliclyAccessible: false,
Size: 20,
StorageEncrypted: true,
StorageType: "gp2",
Username: "dbuser",
},
}
j, err := yaml.Marshal(d)
assert.NoError(t, err)
assert.NotNil(t, j)
fmt.Println(string(j))
}
|
package image_classify
import "github.com/kingjh/baidu-ai-go-sdk"
type ImageClassifyClient struct {
*gosdk.Client
}
func NewImageClassifyClient(apiKey, secretKey string) *ImageClassifyClient {
return &ImageClassifyClient{
Client: gosdk.NewClient(apiKey, secretKey),
}
}
|
package plugins
import(
"reflect"
)
type KubernetesPlugin struct {
name string
kubeconfig_path string
}
func NewKubernetesPlugin() Plugin {
return &KubernetesPlugin{
kubeconfig_path: "~/.kube/config",
}
}
func (k *KubernetesPlugin) Equal(p Plugin) bool {
a, ok := p.(*KubernetesPlugin)
if ok {
return *k == *a
}
return false
}
func (k *KubernetesPlugin) Configure(name string, settings map[string]interface{}) error {
k.name = name
if config_path, ok := settings["Kubeconfig"]; ok && !reflect.ValueOf(config_path).IsNil() {
k.kubeconfig_path = *config_path.(*string)
}
return nil
}
|
package main
import "fmt"
type Meter float64
type Foot float64
const lFactor float64 = 3.2808
func (m Meter) String() string { return fmt.Sprintf("%gM", m) }
func (f Foot) String() string { return fmt.Sprintf("%gft", f) }
// FToM converts Meter to Foot
func FToM(f Foot) Meter { return Meter(f / Foot(lFactor)) }
// MToF converts Foot to Meter
func MToF(m Meter) Foot { return Foot(m * Meter(lFactor)) }
|
package colors
import "fmt"
// RGBColor represents a custom 24-bit RGB color.
type RGBColor struct {
R, G, B uint8
}
// Compress ...
func (r RGBColor) Compress() string {
return fmt.Sprintf(";2;%v;%v;%v", r.R, r.G, r.B)
}
|
// Copyright 2020 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Package externaldata contains helpers to provide a http server for policies
// that download their contents from an external source.
package externaldata
|
package main
import (
"fmt"
"sort"
)
type ddArr [][]int32
func (a ddArr) Len() int { return len(a) }
func (a ddArr) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ddArr) Less(i, j int) bool {
if a[i][1] != a[j][1] {
return a[i][1] < a[j][1]
}
if a[i][1] == a[j][1] {
return a[i][0] > a[j][0]
}
return false
}
// Complete the luckBalance function below.
func luckBalance(k int32, contests [][]int32) int32 {
var max int32
toLose := int32(0)
sort.Sort(ddArr(contests))
fmt.Println("Input: ", contests, k)
for i := 0; i < len(contests); i++ {
if contests[i][1] == 0 {
max += contests[i][0]
}
if contests[i][1] == 1 && toLose >= k {
max -= contests[i][0]
}
if contests[i][1] == 1 && toLose < k {
max += contests[i][0]
toLose++
}
}
return max
}
func main() {
var contests [][]int32
var output int32
var k int32
contests = [][]int32{
{5, 1},
{2, 1},
{1, 1},
{8, 1},
{10, 0},
{5, 0},
}
k = 3
fmt.Println("Input: ", contests, k)
output = luckBalance(k, contests)
fmt.Println("Output", output)
}
|
package altrudos
import (
"errors"
"github.com/jmoiron/sqlx"
"github.com/monstercat/pgnull"
)
var (
ErrNilDonation = errors.New("submitted donation is nil")
)
type SubmittedDonation struct {
Amount string
CharityId string
Currency string
DonorName string
}
func CreateDonation(ext sqlx.Ext, driveId string, dono *SubmittedDonation) (*Donation, error) {
if dono == nil {
return nil, ErrNilDonation
}
amt, err := AmountFromString(dono.Amount)
if err != nil {
return nil, err
}
if driveId == "" {
return nil, ErrDriveNotCreated
}
donation := &Donation{
DonorAmount: amt,
DonorCurrency: dono.Currency,
DonorName: pgnull.NewNullString(dono.DonorName),
CharityId: dono.CharityId,
DriveId: driveId,
Message: pgnull.NullString{"", false},
}
if err := donation.Create(ext); err != nil {
return nil, err
}
return donation, nil
}
|
package main
import "github.com/yuriizinets/go-ssc"
type ComponentSampleChild struct {
Value string
}
func (c *ComponentSampleChild) Init(p ssc.Page) {
c.Value = "Child's component value"
}
|
package main
// Leetcode 323. (medium)
func countComponents(n int, edges [][]int) int {
root, size := make([]int, n), make([]int, n)
for i := range root {
root[i] = i
size[i] = 1
}
for _, edge := range edges {
n = unionOf323(edge[0], edge[1], root, size, n)
}
return n
}
func findOf323(x int, root []int) int {
for x != root[x] {
x = root[x]
}
return x
}
func unionOf323(x, y int, root, size []int, cnt int) int {
x, y = findOf323(x, root), findOf323(y, root)
if x == y {
return cnt
}
if size[x] > size[y] {
root[y] = x
size[x] += size[y]
} else {
root[x] = y
size[y] += size[x]
}
cnt--
return cnt
}
|
package poller
import (
"context"
"fmt"
"time"
"github.com/gbolo/vsummary/common"
"github.com/vmware/govmomi/view"
"github.com/vmware/govmomi/vim25/mo"
"github.com/vmware/govmomi/vim25/types"
)
func (p *Poller) GetDVSPortgroups() (list []common.Portgroup, err error) {
// log time on debug
defer common.ExecutionTime(time.Now(), "pollDatastores")
// Create view for objects
moType := "DistributedVirtualPortgroup"
m := view.NewManager(p.VmwareClient.Client)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
v, err := m.CreateContainerView(ctx, p.VmwareClient.Client.ServiceContent.RootFolder, []string{moType}, true)
if err != nil {
return
}
defer v.Destroy(ctx)
// Retrieve summary property for all matching objects
var molist []mo.DistributedVirtualPortgroup
err = v.Retrieve(
ctx,
[]string{moType},
[]string{"name", "config", "config.defaultPortConfig"},
&molist,
)
if err != nil {
return
}
// construct the list
for _, mo := range molist {
// TODO: this needs to be cleaned up
object := common.Portgroup{
Name: mo.Name,
Moref: mo.Self.Value,
Type: "DVS",
VswitchMoref: mo.Config.DistributedVirtualSwitch.Value,
VcenterId: v.Client().ServiceContent.About.InstanceUuid,
}
if common.CheckIfKeyExists(mo.Config.DefaultPortConfig, "Vlan") {
pconfig := mo.Config.DefaultPortConfig
switch vl := pconfig.(type) {
case *types.VMwareDVSPortSetting:
vlan := vl.Vlan
switch vlanspec := vlan.(type) {
case *types.VmwareDistributedVirtualSwitchVlanIdSpec:
object.VlanType = "VmwareDistributedVirtualSwitchVlanIdSpec"
object.Vlan = fmt.Sprint(common.GetInt(mo.Config.DefaultPortConfig, "Vlan", "VlanId"))
case *types.VmwareDistributedVirtualSwitchTrunkVlanSpec:
object.VlanType = "VmwareDistributedVirtualSwitchTrunkVlanSpec"
for i, v := range vlanspec.VlanId {
if v.Start == v.End {
object.Vlan += fmt.Sprint(v.Start)
} else {
object.Vlan += fmt.Sprintf("%v - %v", v.Start, v.End)
}
// add a comma, if needed
if i != len(vlanspec.VlanId)-1 && object.Vlan != "" {
object.Vlan += ", "
}
}
default:
// TODO: support for spec: *types.VmwareDistributedVirtualSwitchPvlanSpec
object.VlanType = "TypeNotImplemented"
object.Vlan = "unknown"
}
}
}
list = append(list, object)
}
log.Infof("poller fetched %d summaries of %s", len(list), moType)
return
}
|
package libMonitor
import (
"github.com/pkg/errors"
"time"
)
var ScanInterval = time.Duration(30 * time.Second)
var ScaningInterval = time.Duration(5 * time.Second)
var AgainReportBaseInterval = time.Duration(60 * time.Second)
var AgainReportMaxInterval = time.Duration(60 * 60 * time.Second) //1hour
var ReportType = "email" //dingtalk or email
var DingtalkUrl = "https://oapi.dingtalk.com/robot/send?access_token=32e0699c542e314680b05a9c947577395b86389bd4fe2853181b14b055c4a5ed"
var DingtalkAtAll = false
var DingtalTels []string
var SmtpHost = ""
var SmtpUserName = ""
var SmtpSender = ""
var SmtpPwd = ""
var SmtpRecever []string //aa@gmail.com,bb@yahoo.com
var SmtpPort = 25
var KeepRunning = true
var MonitorName = "My Monitor"
func GetScanInterval() time.Duration { return ScaningInterval }
func GetScaningInterval() time.Duration { return ScaningInterval }
func GetAgainReportBaseInterval() time.Duration { return AgainReportBaseInterval }
func GetAgainReportMaxInterval() time.Duration { return AgainReportMaxInterval }
func GetReportType() string { return ReportType }
func GetDingtalkUrl() string { return DingtalkUrl }
func GetDingtalkAtAll() bool { return DingtalkAtAll }
func GetDingtalTels() []string { return DingtalTels }
func GetSmtpHost() string { return SmtpHost }
func GetSmtpUserName() string { return SmtpUserName }
func GetSmtpSender() string { return SmtpSender }
func GetSmtpPwd() string { return SmtpPwd }
func GetSmtpRecever() []string { return SmtpRecever }
func GetSmtpPort() int { return SmtpPort }
func GetKeepRunning() bool { return KeepRunning }
func GetMonitorName() string { return MonitorName }
func SetScanInterval(val time.Duration) { ScaningInterval = val }
func SetScaningInterval(val time.Duration) { ScaningInterval = val }
func SetAgainReportBaseInterval(val time.Duration) { AgainReportBaseInterval = val }
func SetAgainReportMaxInterval(val time.Duration) { AgainReportMaxInterval = val }
func SetScanIntervalFromStr(val string) error {
duration, err := time.ParseDuration(val)
if err != nil {
return errors.New("SetScanIntervalFromStr parse duration error:" + val)
}
ScanInterval = duration
return nil
}
func SetScaningIntervalFromStr(val string) error {
duration, err := time.ParseDuration(val)
if err != nil {
return errors.New("SetScaningIntervalFromStr parse duration error:" + val)
}
ScaningInterval = duration
return nil
}
func SetAgainReportBaseIntervalFromStr(val string) error {
duration, err := time.ParseDuration(val)
if err != nil {
return errors.New("SetReportBaseIntervalFromStr parse duration error:" + val)
}
AgainReportBaseInterval = duration
return nil
}
func SetAgainReportMaxIntervalFromStr(val string) error {
duration, err := time.ParseDuration(val)
if err != nil {
return errors.New("SetReportMaxIntervalFromStr parse duration error:" + val)
}
AgainReportMaxInterval = duration
return nil
}
func SetReportType(val string) { ReportType = val }
func SetDingtalkUrl(val string) { DingtalkUrl = val }
func SetDingtalkAtAll(val bool) { DingtalkAtAll = val }
func SetDingtalTels(val []string) { DingtalTels = val }
func SetSmtpHost(val string) { SmtpHost = val }
func SetSmtpUserName(val string) { SmtpUserName = val }
func SetSmtpSender(val string) { SmtpSender = val }
func SetSmtpPwd(val string) { SmtpPwd = val }
func SetSmtpRecever(val []string) { SmtpRecever = val }
func SetSmtpPort(val int) { SmtpPort = val }
func SetKeepRunning(val bool) { KeepRunning = val }
func SetMonitorName(val string) { MonitorName = val }
|
package config
import (
"fmt"
"golang.org/x/sys/unix"
"os"
"path/filepath"
"strings"
)
func validateProcessSpec(spec *Process) error {
if spec.Cwd == "" {
return fmt.Errorf("Cwd property must not be empty")
}
if !filepath.IsAbs(spec.Cwd) {
return fmt.Errorf("Cwd must be an absolute path")
}
if len(spec.Args) == 0 {
return fmt.Errorf("args must not be empty")
}
return nil
}
func parseMountOptions(options []string) (int, []int, string, int) {
var (
flag int
pgflag []int
data []string
extFlags int
)
flags := map[string]struct {
clear bool
flag int
}{
"acl": {false, unix.MS_POSIXACL},
"async": {true, unix.MS_SYNCHRONOUS},
"atime": {true, unix.MS_NOATIME},
"bind": {false, unix.MS_BIND},
"defaults": {false, 0},
"dev": {true, unix.MS_NODEV},
"diratime": {true, unix.MS_NODIRATIME},
"dirsync": {false, unix.MS_DIRSYNC},
"exec": {true, unix.MS_NOEXEC},
"iversion": {false, unix.MS_I_VERSION},
"lazytime": {false, unix.MS_LAZYTIME},
"loud": {true, unix.MS_SILENT},
"mand": {false, unix.MS_MANDLOCK},
"noacl": {true, unix.MS_POSIXACL},
"noatime": {false, unix.MS_NOATIME},
"nodev": {false, unix.MS_NODEV},
"nodiratime": {false, unix.MS_NODIRATIME},
"noexec": {false, unix.MS_NOEXEC},
"noiversion": {true, unix.MS_I_VERSION},
"nolazytime": {true, unix.MS_LAZYTIME},
"nomand": {true, unix.MS_MANDLOCK},
"norelatime": {true, unix.MS_RELATIME},
"nostrictatime": {true, unix.MS_STRICTATIME},
"nosuid": {false, unix.MS_NOSUID},
"rbind": {false, unix.MS_BIND | unix.MS_REC},
"relatime": {false, unix.MS_RELATIME},
"remount": {false, unix.MS_REMOUNT},
"ro": {false, unix.MS_RDONLY},
"rw": {true, unix.MS_RDONLY},
"silent": {false, unix.MS_SILENT},
"strictatime": {false, unix.MS_STRICTATIME},
"suid": {true, unix.MS_NOSUID},
"sync": {false, unix.MS_SYNCHRONOUS},
}
propagationFlags := map[string]int{
"private": unix.MS_PRIVATE,
"shared": unix.MS_SHARED,
"slave": unix.MS_SLAVE,
"unbindable": unix.MS_UNBINDABLE,
"rprivate": unix.MS_PRIVATE | unix.MS_REC,
"rshared": unix.MS_SHARED | unix.MS_REC,
"rslave": unix.MS_SLAVE | unix.MS_REC,
"runbindable": unix.MS_UNBINDABLE | unix.MS_REC,
}
extensionFlags := map[string]struct {
clear bool
flag int
}{
"tmpcopyup": {false, EXT_COPYUP},
}
for _, o := range options {
// If the option does not exist in the flags table or the flag
// is not supported on the platform,
// then it is a data value for a specific fs type
if f, exists := flags[o]; exists && f.flag != 0 {
if f.clear {
flag &= ^f.flag
} else {
flag |= f.flag
}
} else if f, exists := propagationFlags[o]; exists && f != 0 {
pgflag = append(pgflag, f)
} else if f, exists := extensionFlags[o]; exists && f.flag != 0 {
if f.clear {
extFlags &= ^f.flag
} else {
extFlags |= f.flag
}
} else {
data = append(data, o)
}
}
return flag, pgflag, strings.Join(data, ","), extFlags
}
func CleanPath(path string) string {
// Deal with empty strings nicely.
if path == "" {
return ""
}
// Ensure that all paths are cleaned (especially problematic ones like
// "/../../../../../" which can cause lots of issues).
path = filepath.Clean(path)
// If the path isn't absolute, we need to do more processing to fix paths
// such as "../../../../<etc>/some/path". We also shouldn't convert absolute
// paths to relative ones.
if !filepath.IsAbs(path) {
path = filepath.Clean(string(os.PathSeparator) + path)
// This can't fail, as (by definition) all paths are relative to root.
path, _ = filepath.Rel(string(os.PathSeparator), path)
}
// Clean the path again for good measure.
return filepath.Clean(path)
}
|
package main
import (
"fmt"
"sort"
)
func main() {
nums := []int{1, 0, -1, 0, -2, 2}
target := 0
fmt.Println(fourSum(nums, target))
}
func fourSum(nums []int, target int) [][]int {
result := [][]int{}
// 升序
sort.Ints(nums)
// 固定第一个数
for first := 0; first < len(nums)-3; first++ {
// 去重
if first > 0 && nums[first] == nums[first-1] {
continue
}
// 固定第二个数
for second := first + 1; second < len(nums)-2; second++ {
// 去重，second只和上一个second比较
if second > first+1 && nums[second] == nums[second-1] {
continue
}
// 双指针指向两边的两个数
third, forth := second+1, len(nums)-1
for third < forth {
sum := nums[first] + nums[second] + nums[third] + nums[forth]
switch {
case sum < target:
// 小的数需要变大
third++
case sum > target:
// 大的数需要变小
forth--
default:
result = append(result, []int{nums[first], nums[second], nums[third], nums[forth]})
// 去重
for third < forth && nums[third] == nums[third+1] {
third++
}
for third < forth && nums[forth] == nums[forth-1] {
forth--
}
third++
forth--
}
}
}
}
return result
}
|
// Copyright 2020 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Package arcappcompat will have tast tests for android apps on Chromebooks.
package arcappcompat
import (
"context"
"strings"
"time"
"chromiumos/tast/common/android/ui"
"chromiumos/tast/errors"
"chromiumos/tast/local/arc"
"chromiumos/tast/local/bundles/cros/arcappcompat/pre"
"chromiumos/tast/local/bundles/cros/arcappcompat/testutil"
"chromiumos/tast/local/chrome"
"chromiumos/tast/testing"
"chromiumos/tast/testing/hwdep"
)
// clamshellLaunchForSkype launches Skype in clamshell mode.
var clamshellLaunchForSkype = []testutil.TestCase{
{Name: "Launch app in Clamshell", Fn: launchAppForSkype, Timeout: testutil.LaunchTestCaseTimeout},
}
// touchviewLaunchForSkype launches Skype in tablet mode.
var touchviewLaunchForSkype = []testutil.TestCase{
{Name: "Launch app in Touchview", Fn: launchAppForSkype, Timeout: testutil.LaunchTestCaseTimeout},
}
// clamshellAppSpecificTestsForSkype are placed here.
var clamshellAppSpecificTestsForSkype = []testutil.TestCase{
{Name: "Clamshell: Signout app", Fn: signOutOfSkype, Timeout: testutil.SignoutTestCaseTimeout},
}
// touchviewAppSpecificTestsForSkype are placed here.
var touchviewAppSpecificTestsForSkype = []testutil.TestCase{
{Name: "Touchview: Signout app", Fn: signOutOfSkype, Timeout: testutil.SignoutTestCaseTimeout},
}
func init() {
testing.AddTest(&testing.Test{
Func: Skype,
LacrosStatus: testing.LacrosVariantUnneeded,
Desc: "Functional test for Skype that installs the app also verifies it is logged in and that the main page is open, checks Skype correctly changes the window state in both clamshell and touchview mode",
Contacts: []string{"mthiyagarajan@chromium.org", "cros-appcompat-test-team@google.com"},
Attr: []string{"group:appcompat"},
SoftwareDeps: []string{"chrome"},
Params: []testing.Param{{
Name: "clamshell_mode_default",
Val: testutil.TestParams{
LaunchTests: clamshellLaunchForSkype,
CommonTests: testutil.ClamshellCommonTests,
AppSpecificTests: clamshellAppSpecificTestsForSkype,
},
ExtraAttr: []string{"appcompat_default"},
ExtraSoftwareDeps: []string{"android_p"},
// TODO(b/189704585): Remove hwdep.SkipOnModel once the solution is found.
// Skip on tablet only models.
ExtraHardwareDeps: hwdep.D(hwdep.SkipOnModel(testutil.TabletOnlyModels...)),
Pre: pre.AppCompatBootedUsingTestAccountPool,
}, {
Name: "tablet_mode_default",
Val: testutil.TestParams{
LaunchTests: touchviewLaunchForSkype,
CommonTests: testutil.TouchviewCommonTests,
AppSpecificTests: touchviewAppSpecificTestsForSkype,
},
ExtraAttr: []string{"appcompat_default"},
ExtraSoftwareDeps: []string{"android_p"},
// TODO(b/189704585): Remove hwdep.SkipOnModel once the solution is found.
// Skip on clamshell only models.
ExtraHardwareDeps: hwdep.D(hwdep.TouchScreen(), hwdep.SkipOnModel(testutil.ClamshellOnlyModels...)),
Pre: pre.AppCompatBootedInTabletModeUsingTestAccountPool,
}, {
Name: "vm_clamshell_mode_default",
Val: testutil.TestParams{
LaunchTests: clamshellLaunchForSkype,
CommonTests: testutil.ClamshellCommonTests,
AppSpecificTests: clamshellAppSpecificTestsForSkype,
},
ExtraAttr: []string{"appcompat_default"},
ExtraSoftwareDeps: []string{"android_vm"},
// TODO(b/189704585): Remove hwdep.SkipOnModel once the solution is found.
// Skip on tablet only models.
ExtraHardwareDeps: hwdep.D(hwdep.SkipOnModel(testutil.TabletOnlyModels...)),
Pre: pre.AppCompatBootedUsingTestAccountPool,
}, {
Name: "vm_tablet_mode_default",
Val: testutil.TestParams{
LaunchTests: touchviewLaunchForSkype,
CommonTests: testutil.TouchviewCommonTests,
AppSpecificTests: touchviewAppSpecificTestsForSkype,
},
ExtraAttr: []string{"appcompat_default"},
ExtraSoftwareDeps: []string{"android_vm"},
// TODO(b/189704585): Remove hwdep.SkipOnModel once the solution is found.
// Skip on clamshell only models.
ExtraHardwareDeps: hwdep.D(hwdep.TouchScreen(), hwdep.SkipOnModel(testutil.ClamshellOnlyModels...)),
Pre: pre.AppCompatBootedInTabletModeUsingTestAccountPool,
}, {
Name: "clamshell_mode_release",
Val: testutil.TestParams{
LaunchTests: clamshellLaunchForSkype,
ReleaseTests: testutil.ClamshellReleaseTests,
AppSpecificTests: clamshellAppSpecificTestsForSkype,
},
ExtraAttr: []string{"appcompat_release"},
ExtraSoftwareDeps: []string{"android_p"},
// TODO(b/189704585): Remove hwdep.SkipOnModel once the solution is found.
// Skip on tablet only models.
ExtraHardwareDeps: hwdep.D(hwdep.SkipOnModel(testutil.TabletOnlyModels...)),
Pre: pre.AppCompatBootedUsingTestAccountPool,
}, {
Name: "tablet_mode_release",
Val: testutil.TestParams{
LaunchTests: touchviewLaunchForSkype,
ReleaseTests: testutil.TouchviewReleaseTests,
AppSpecificTests: touchviewAppSpecificTestsForSkype,
},
ExtraAttr: []string{"appcompat_release"},
ExtraSoftwareDeps: []string{"android_p"},
// TODO(b/189704585): Remove hwdep.SkipOnModel once the solution is found.
// Skip on clamshell only models.
ExtraHardwareDeps: hwdep.D(hwdep.TouchScreen(), hwdep.SkipOnModel(testutil.ClamshellOnlyModels...)),
Pre: pre.AppCompatBootedInTabletModeUsingTestAccountPool,
}, {
Name: "vm_clamshell_mode_release",
Val: testutil.TestParams{
LaunchTests: clamshellLaunchForSkype,
ReleaseTests: testutil.ClamshellReleaseTests,
AppSpecificTests: clamshellAppSpecificTestsForSkype,
},
ExtraAttr: []string{"appcompat_release"},
ExtraSoftwareDeps: []string{"android_vm"},
// TODO(b/189704585): Remove hwdep.SkipOnModel once the solution is found.
// Skip on tablet only models.
ExtraHardwareDeps: hwdep.D(hwdep.SkipOnModel(testutil.TabletOnlyModels...)),
Pre: pre.AppCompatBootedUsingTestAccountPool,
}, {
Name: "vm_tablet_mode_release",
Val: testutil.TestParams{
LaunchTests: touchviewLaunchForSkype,
ReleaseTests: testutil.TouchviewReleaseTests,
AppSpecificTests: touchviewAppSpecificTestsForSkype,
},
ExtraAttr: []string{"appcompat_release"},
ExtraSoftwareDeps: []string{"android_vm"},
// TODO(b/189704585): Remove hwdep.SkipOnModel once the solution is found.
// Skip on clamshell only models.
ExtraHardwareDeps: hwdep.D(hwdep.TouchScreen(), hwdep.SkipOnModel(testutil.ClamshellOnlyModels...)),
Pre: pre.AppCompatBootedInTabletModeUsingTestAccountPool,
}},
Timeout: 30 * time.Minute,
Vars: []string{"arcappcompat.gaiaPoolDefault"},
VarDeps: []string{"arcappcompat.Skype.emailid", "arcappcompat.Skype.password"},
})
}
// Skype test uses library for opting into the playstore and installing app.
// Checks Skype correctly changes the window states in both clamshell and touchview mode.
func Skype(ctx context.Context, s *testing.State) {
const (
appPkgName = "com.skype.raider"
appActivity = ".Main"
)
testSet := s.Param().(testutil.TestParams)
testutil.RunTestCases(ctx, s, appPkgName, appActivity, testSet)
}
// launchAppForSkype verifies Skype is logged in and
// verify Skype reached main activity page of the app.
func launchAppForSkype(ctx context.Context, s *testing.State, tconn *chrome.TestConn, a *arc.ARC, d *ui.Device, appPkgName, appActivity string) {
const (
allowButtonText = "ALLOW"
continueButtonDes = "Continue"
letsGoDes = "Let's go"
enterEmailAddressID = "i0116"
finishButtonDes = "Finish"
nextButtonText = "Next"
notNowID = "android:id/autofill_save_no"
passwordID = "i0118"
signInClassName = "android.widget.Button"
signInText = "Sign in"
signInOrCreateDes = "Sign in or create"
syncContactsButtonDes = "Sync contacts"
whileUsingThisAppButtonText = "WHILE USING THE APP"
mediumUITimeout = 30 * time.Second
)
// Click on letsGo button.
letsGoButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.DescriptionMatches("(?i)"+letsGoDes))
if err := letsGoButton.WaitForExists(ctx, testutil.DefaultUITimeout); err != nil {
s.Log("letsGoButton doesn't exists: ", err)
} else if err := letsGoButton.Click(ctx); err != nil {
s.Fatal("Failed to click on letsGoButton: ", err)
}
// Click on sign in button.
signInButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.TextMatches("(?i)"+signInText))
appVer, err := testutil.GetAppVersion(ctx, s, a, d, appPkgName)
if err != nil {
s.Log("Failed to find app version and skipped login: ", err)
return
}
if strings.Compare(appVer, "8.80.0.137") >= 0 {
// Click on sign in button.
signInButton = d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.DescriptionMatches("(?i)"+signInOrCreateDes))
}
if err := signInButton.WaitForExists(ctx, testutil.DefaultUITimeout); err != nil {
s.Fatal("signInButton doesn't exists: ", err)
}
// Press KEYCODE_TAB until login button is focused.
if err := testing.Poll(ctx, func(ctx context.Context) error {
if loginBtnFocused, err := signInButton.IsFocused(ctx); err != nil {
return errors.New("login button not focused yet")
} else if !loginBtnFocused {
d.PressKeyCode(ctx, ui.KEYCODE_TAB, 0)
return errors.New("login button not focused yet")
}
return nil
}, &testing.PollOptions{Timeout: mediumUITimeout}); err != nil {
s.Log("Failed to focus login button: ", err)
}
// click on signin button until allow button exists.
allowButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.TextMatches("(?i)"+allowButtonText))
if err := testing.Poll(ctx, func(ctx context.Context) error {
if err := allowButton.Exists(ctx); err != nil {
signInButton.Click(ctx)
return err
}
return nil
}, &testing.PollOptions{Timeout: testutil.DefaultUITimeout}); err != nil {
s.Log("Allow button doesn't exists: ", err)
} else if err := allowButton.Click(ctx); err != nil {
s.Fatal("Failed to click on allowButton: ", err)
}
testutil.LoginToApp(ctx, s, tconn, a, d, appPkgName, appActivity)
// Click on continue button.
continueButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.DescriptionMatches("(?i)"+continueButtonDes))
if err := continueButton.WaitForExists(ctx, testutil.ShortUITimeout); err != nil {
s.Log("Continue Button doesn't exists: ", err)
} else if err := continueButton.Click(ctx); err != nil {
s.Fatal("Failed to click on continueButton: ", err)
}
testutil.HandleDialogBoxes(ctx, s, d, appPkgName)
// Click on Sync contacts button.
syncContactsButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.DescriptionMatches("(?i)"+syncContactsButtonDes))
if err := syncContactsButton.WaitForExists(ctx, testutil.ShortUITimeout); err != nil {
s.Log("syncContactsButton doesn't exist: ", err)
} else if err := syncContactsButton.Click(ctx); err != nil {
s.Fatal("Failed to click on syncContactsButton: ", err)
}
testutil.HandleDialogBoxes(ctx, s, d, appPkgName)
// Click on continue Button until allow button exist.
continueButton = d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.DescriptionMatches("(?i)"+continueButtonDes))
if err := testing.Poll(ctx, func(ctx context.Context) error {
if err := allowButton.Exists(ctx); err != nil {
continueButton.Click(ctx)
return err
}
return nil
}, &testing.PollOptions{Timeout: testutil.DefaultUITimeout}); err != nil {
s.Log("allowButton doesn't exist: ", err)
}
testutil.HandleDialogBoxes(ctx, s, d, appPkgName)
// Click on finish button.
finishButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.Description(finishButtonDes))
if err := finishButton.WaitForExists(ctx, testutil.ShortUITimeout); err != nil {
s.Log("finishButton doesn't exist: ", err)
} else if err := finishButton.Click(ctx); err != nil {
s.Fatal("Failed to click on finishButton: ", err)
}
testutil.HandleDialogBoxes(ctx, s, d, appPkgName)
// Check for launch verifier.
launchVerifier := d.Object(ui.PackageName(appPkgName))
if err := launchVerifier.WaitForExists(ctx, testutil.LongUITimeout); err != nil {
testutil.DetectAndHandleCloseCrashOrAppNotResponding(ctx, s, d)
s.Fatal("launchVerifier doesn't exists: ", err)
}
}
// signOutOfSkype verifies app is signed out.
func signOutOfSkype(ctx context.Context, s *testing.State, tconn *chrome.TestConn, a *arc.ARC, d *ui.Device, appPkgName, appActivity string) {
const (
continueButtonDes = "Continue"
finishButtonDes = "Finish"
imageButtonClassName = "android.widget.ImageButton"
closeIconDes = "Close main menus"
profileClassName = "android.widget.Button"
profileDes = "My info"
hamburgerIconDes = "Menu"
skipText = "Skip"
signOutID = "com.skype.raider:id/drawer_signout"
signOutDes = "Sign out"
yesText = "YES"
)
appVer, err := testutil.GetAppVersion(ctx, s, a, d, appPkgName)
if err != nil {
s.Log("Failed to find app version and skipped login: ", err)
return
}
// Click on continue Button until allow button exist.
continueButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.DescriptionMatches("(?i)"+continueButtonDes))
skipButton := d.Object(ui.TextMatches("(?i)" + skipText))
if err := testing.Poll(ctx, func(ctx context.Context) error {
if err := skipButton.Exists(ctx); err != nil {
continueButton.Click(ctx)
return err
}
return nil
}, &testing.PollOptions{Timeout: testutil.DefaultUITimeout}); err != nil {
s.Log("skipButton doesn't exist: ", err)
}
// Click on finish button.
finishButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.Description(finishButtonDes))
if err := finishButton.WaitForExists(ctx, testutil.ShortUITimeout); err != nil {
s.Log("finishButton doesn't exist: ", err)
} else if err := finishButton.Click(ctx); err != nil {
s.Fatal("Failed to click on finishButton: ", err)
}
testutil.HandleDialogBoxes(ctx, s, d, appPkgName)
// Check for profileIcon.
profileIcon := d.Object(ui.ClassName(profileClassName), ui.DescriptionMatches("(?i)"+profileDes), ui.Index(1))
if strings.Compare(appVer, "8.80.0.137") <= 0 {
s.Log("Current app version is less than 8.80.0.137")
profileIcon = d.Object(ui.ClassName(imageButtonClassName), ui.DescriptionMatches("(?i)"+hamburgerIconDes))
}
if err := profileIcon.WaitForExists(ctx, testutil.LongUITimeout); err != nil {
s.Log("profileIcon doesn't exists and skipped logout: ", err)
return
}
// Click on profile icon until sign out button exist.
signOutOfSkype := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.DescriptionMatches("(?i)"+signOutDes))
if strings.Compare(appVer, "8.80.0.137") > 0 {
testutil.ClickUntilButtonExists(ctx, s, tconn, a, d, profileIcon, signOutOfSkype)
} else if err := profileIcon.Click(ctx); err != nil {
s.Fatal("Failed to click on profileIcon: ", err)
}
// Click on sign out of Skype.
if strings.Compare(appVer, "8.80.0.137") <= 0 {
signOutOfSkype = d.Object(ui.ID(signOutID))
}
if err := signOutOfSkype.WaitForExists(ctx, testutil.DefaultUITimeout); err != nil {
s.Error("signOutOfSkype doesn't exist: ", err)
} else if err := signOutOfSkype.Click(ctx); err != nil {
s.Fatal("Failed to click on signOutOfSkype: ", err)
}
// Click on yes button.
yesButton := d.Object(ui.ClassName(testutil.AndroidButtonClassName), ui.TextMatches("(?i)"+yesText))
if err := yesButton.WaitForExists(ctx, testutil.DefaultUITimeout); err != nil {
s.Log("yesButton doesn't exists: ", err)
} else if err := yesButton.Click(ctx); err != nil {
s.Fatal("Failed to click on yesButton: ", err)
}
}
|
package memory
import (
"fmt"
"strconv"
"formation.engineering/oauth2-jwt/store"
"github.com/pkg/errors"
)
type MemoryStore struct {
identity int
db map[store.KeyID]*store.KeyInfo
}
func NewMemoryStore() *MemoryStore {
return &MemoryStore{
identity: 0,
db: make(map[store.KeyID]*store.KeyInfo),
}
}
func (x *MemoryStore) newIdentity() string {
x.identity++
return strconv.Itoa(x.identity)
}
func (x *MemoryStore) initialize() {
if x.db == nil {
x.db = make(map[store.KeyID]*store.KeyInfo)
}
}
func (x *MemoryStore) AddKey(keyid store.KeyID, in store.AddKey) (*store.IdentityID, error) {
x.initialize()
identity := x.newIdentity()
tmp, err := x.GetKey(keyid)
if err != nil {
return nil, errors.WithMessage(err, "add-key")
}
if tmp != nil {
return nil, fmt.Errorf("conflict - existing KeyID [%s]", keyid)
}
x.db[keyid] = &store.KeyInfo{
PublicKey: in.PublicKey,
IdentityID: identity,
TenantID: in.TenantID,
}
return &identity, nil
}
func (x *MemoryStore) GetKey(keyid store.KeyID) (*store.KeyInfo, error) {
x.initialize()
res, ok := x.db[keyid]
if !ok {
return nil, nil
}
return res, nil
}
func (x *MemoryStore) DeleteKey(keyid store.KeyID) error {
delete(x.db, keyid)
return nil
}
|
package events
import (
"encoding/json"
"errors"
"fmt"
"log"
"strings"
"sync"
)
//json hints helps while de-serialization from the struct
type Event struct {
Event string `json:"event"`
Time int `json:"time"`
}
//struct for the serialization of json for output
type AvgEvent struct {
Event string `json:"event"`
Avg int `json:"avg"`
}
type AvgEvents []AvgEvent
//Use a map with the RWMutex to optimize for the multiple read and writes
// This is in global scope like static in other languages
var eventMap = struct {
sync.RWMutex
data map[string][]int
}{data: make(map[string][]int)}
//PublishEvent taken a json serialized string. Keep track of the events with the map.
//This thread-safe map is used to calculate the average of the events
func (e Event) PublishEvent(input string) error {
incomingEvent := Event{}
err := json.Unmarshal([]byte(input), &incomingEvent)
if err != nil {
log.Printf("Invalid json. Failed to unmarshal! %s", err.Error())
return err
}
validationError := validateEvent(incomingEvent)
if validationError != nil {
return validationError
}
//Redundant call with overhead of another go-routine (processChannel)
//But this will be helpful to bulk process the event in single json. Over-head will be negligible for those cases.
//Use a boolean channel as a locking mechanism to avoid race condition on write data.
//This channel is used to wait till a signal is sent back from the go-routine when it completes.
//NOTE: Here the unbuffered boolean channel is uses as a synchronous block only to process the writes on the map.
// Concurrent reads are fine. This enables to process the event concurrent to the caller.
processChannel := make(chan bool)
go processEvent(incomingEvent, processChannel)
isComplete := <-processChannel
//If the channel is done close it
if isComplete {
close(processChannel)
}
//Processed successfully, return nil
return nil
}
//Helper function to process the events
func processEvent(event Event, channel chan bool) {
//Sanitize the incoming data to lowercase
eventKey := strings.ToLower(event.Event)
//Check if the incoming event exists, if so sum it up and add the counts
// else add the time value as new entry
//Takes a write lock
eventMap.Lock()
if val, ok := eventMap.data[eventKey]; ok {
eventMap.data[eventKey][0] = val[0] + event.Time
eventMap.data[eventKey][1] += 1
} else {
eventMap.data[eventKey] = []int{event.Time, 1}
}
eventMap.Unlock()
// Done processing the events to map, send signal via channel
channel <- true
}
func validateEvent(incomingEvent Event) error {
if incomingEvent.Event == "" {
log.Printf("Invaild event: %s", incomingEvent.Event)
return errors.New(fmt.Sprintf("Invaild event: %s", incomingEvent.Event))
}
if incomingEvent.Time < 0 {
log.Printf("Invaild time value: %d", incomingEvent.Time)
return errors.New(fmt.Sprintf("Invaild time value: %d", incomingEvent.Time))
}
//If no validation issue, return nil
return nil
}
func (e Event) GetStats() string {
//Collect the map data into array of AvgEvent
avgStructs := AvgEvents{}
//Takes a read Lock, multiple read locks can be used simultaneously
eventMap.RLock()
for key, val := range eventMap.data {
avgStructs = append(avgStructs, AvgEvent{key, val[0] / val[1]})
}
eventMap.RUnlock()
//Marshal the data to structured json format
avgJson, err := json.Marshal(avgStructs)
if err != nil {
log.Println("Marshalling error", err)
}
log.Printf("Stats: %s", avgJson)
//Send the string value from the marshalled data
return string(avgJson)
}
|
package core
import (
log "github.com/sirupsen/logrus"
r "gopkg.in/rethinkdb/rethinkdb-go.v5"
)
var (
DbName = "rma_subscribes"
TableName_SubscribeTunnelRealFund = "SubscribeTunnelRealFund"
TableName_SubscribeCorpHoldMon = "SubscribeCorpHoldMon"
TableName_SubscribeQuoteMon = "SubscribeQuoteMon"
TableName_SubscribeCustRisk = "SubscribeCustRisk"
TableName_SubscribeCustHold = "SubscribeCustHold"
TableName_SubscribeCustGroupHold = "SubscribeCustGroupHold"
TableName_SubscribeProuctGroupRisk = "SubscribeProuctGroupRisk"
TableName_SubscribeNearDediveHold = "SubscribeNearDediveHold"
)
type RethinkDB interface {
Init() (*r.Session, error)
}
type rethinkdb struct {
address string
}
func NewRethinkDB(address string) RethinkDB {
return &rethinkdb{
address,
}
}
func (i *rethinkdb) Init() (*r.Session, error) {
session, err := r.Connect(r.ConnectOpts{
Addresses: i.address, // endpoint without http
})
if err != nil {
return nil, err
}
err = createDbAndTable(session)
if err != nil {
return nil, err
}
session.Use(DbName)
return session, nil
}
func createDbAndTable(session *r.Session) error {
err := createDb(session, DbName)
if err != nil {
log.Error(err)
return err
}
session.Use(DbName)
primaryKey := "ActionKey"
err = createTable(session, TableName_SubscribeTunnelRealFund, primaryKey)
if err != nil {
log.Error(err)
return err
}
err = createTable(session, TableName_SubscribeCorpHoldMon, primaryKey)
if err != nil {
log.Error(err)
return err
}
err = createTable(session, TableName_SubscribeQuoteMon, primaryKey)
if err != nil {
log.Error(err)
return err
}
err = createTable(session, TableName_SubscribeCustRisk, primaryKey)
if err != nil {
log.Error(err)
return err
}
err = createTable(session, TableName_SubscribeCustHold, primaryKey)
if err != nil {
log.Error(err)
return err
}
err = createTable(session, TableName_SubscribeCustGroupHold, primaryKey)
if err != nil {
log.Error(err)
return err
}
err = createTable(session, TableName_SubscribeProuctGroupRisk, primaryKey)
if err != nil {
log.Error(err)
return err
}
err = createTable(session, TableName_SubscribeNearDediveHold, primaryKey)
if err != nil {
log.Error(err)
return err
}
return nil
}
func createDb(session *r.Session, dbName string) error {
res, err := r.DBList().Run(session)
if err != nil {
return err
}
defer res.Close()
var rows []string
err = res.All(&rows)
if err != nil {
return err
}
existed := false
for _, d := range rows {
if d == dbName {
existed = true
break
}
}
if !existed {
_, err = r.DBCreate(dbName).Run(session)
if err != nil {
return err
}
log.Infof("DB %s created.", dbName)
} else {
log.Infof("DB %s existed.", dbName)
}
return nil
}
func createTable(session *r.Session, tableName string, primaryKey string) error {
res, err := r.TableList().Run(session)
if err != nil {
return err
}
defer res.Close()
var rows []string
err = res.All(&rows)
if err != nil {
return err
}
existed := false
for _, t := range rows {
if t == tableName {
existed = true
break
}
}
if !existed {
_, err = r.TableCreate(tableName, r.TableCreateOpts{PrimaryKey: primaryKey}).Run(session)
if err != nil {
return err
}
log.Infof("Table %s created.", tableName)
} else {
log.Infof("Table %s existed.", tableName)
}
return nil
}
|
package house
import (
"bytes"
"encoding/gob"
"fmt"
)
func NewHouse(street, country string, houseNumber int) *house {
return &house{
Street: street,
Country: country,
HouseNumber: houseNumber,
Rooms: 4,
Bathrooms: 2,
Pool: false,
Garden: false,
}
}
type house struct {
Rooms, Bathrooms int
Pool, Garden bool
HouseNumber int
Street, Country string
}
func (h *house) Clone() *house {
b := bytes.Buffer{}
e := gob.NewEncoder(&b)
err := e.Encode(h)
if err != nil {
fmt.Println(err)
}
d := gob.NewDecoder(&b)
result := house{}
err = d.Decode(&result)
if err != nil {
fmt.Println(err)
}
return &result
}
|
package engine
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"gopkg.in/v1/yaml"
"io/ioutil"
"os"
"path/filepath"
)
var (
errNoManifestPathSpecified = errors.New("No manifest path provided. Please use [-m|--manifest] /path/to/manifest.")
)
type ManifestLoader struct {
data []byte
}
var defaultManifests = []string{"cloudia.json", "cloudia.yaml", "cloudia.yml"}
///////////////////////////////////////////////////////////////////////////////////////////////
// Thanks to https://github.com/markpeek/packer/commit/5bf33a0e91b2318a40c42e9bf855dcc8dd4cdec5
///////////////////////////////////////////////////////////////////////////////////////////////
func (m *ManifestLoader) formatSyntaxError(syntaxError error) (err error) {
syntax, ok := syntaxError.(*json.SyntaxError)
if !ok {
err = syntaxError
return
}
data := m.data
newline := []byte{'\x0a'}
space := []byte{' '}
start, end := bytes.LastIndex(data[:syntax.Offset], newline)+1, len(data)
if idx := bytes.Index(data[start:], newline); idx >= 0 {
end = start + idx
}
line, pos := bytes.Count(data[:start], newline)+1, int(syntax.Offset)-start-1
err = fmt.Errorf("\nError in line %d: %s \n%s\n%s^",
line, syntaxError, data[start:end], bytes.Repeat(space, pos))
return
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////
func (m *ManifestLoader) unmarshalJSON() (*Manifest, error) {
man := &Manifest{}
err := json.Unmarshal(m.data, man)
if err != nil {
err = m.formatSyntaxError(err)
return nil, err
}
return man, nil
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////
func (m *ManifestLoader) unmarshalYAML() (*Manifest, error) {
man := &Manifest{}
err := yaml.Unmarshal(m.data, man)
if err != nil {
err = m.formatSyntaxError(err)
return nil, err
}
return man, nil
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////
func (m *ManifestLoader) LoadFromFile(filename string) (*Manifest, error) {
if len(filename) == 0 {
return nil, errNoManifestPathSpecified
}
data, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
m.data = data
ext := filepath.Ext(filename)
if ext == ".json" {
return m.unmarshalJSON()
} else if ext == ".yml" || ext == ".yaml" {
return m.unmarshalYAML()
} else if ext == "" {
return m.unmarshalJSON()
} else {
return nil, errors.New("Unrecognized file extension")
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////
func (m *ManifestLoader) LoadRaw(rawManifest string) (*Manifest, error) {
if len(rawManifest) > 0 {
m.data = []byte(rawManifest)
return m.unmarshalJSON()
}
return nil, fmt.Errorf("LoadRaw::no manifest found")
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////
func (m *ManifestLoader) LoadDefault() (*Manifest, error) {
for _, f := range defaultManifests {
if _, err := os.Stat(f); err == nil {
return m.LoadFromFile(f)
}
}
return nil, fmt.Errorf("No manifest found %v", defaultManifests)
}
|
package ctx
import (
"github.com/gin-gonic/gin"
"go4eat-api/svc"
)
// ContextData func
func ContextData(container *svc.Container) gin.HandlerFunc {
return func(c *gin.Context) {
c.Set("data", &Data{container: container})
}
}
// GetData func
func GetData(c *gin.Context) *Data {
return c.MustGet("data").(*Data)
}
|
package main
import (
"fmt"
"io/ioutil"
"net/http"
"regexp"
)
func main() {
resp, err := http.Get("http://www.zhenai.com/zhenghun")
if err != nil {
panic(err)
}
fmt.Println(resp)
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK{
fmt.Println("err:",resp.StatusCode)
return
}
// resp.Body 如果 这个网页 事 GBK 的 要变成UTF8
// utf8Reader := transform.NewReader(resp.Body , simplifiedchinese.GBK.NewDecoder() )
utf8Reader := resp.Body
// 获取到 网页源码
all,err:=ioutil.ReadAll(utf8Reader)
if err!=nil{
panic(err)
}
// fmt.Printf("%s\n", all )
printCityAll(all)
}
// 解析 城市列表
func printCityAll(content []byte){
// res := regexp.MustCompile(`<a href="http://www.zhenai.com/zhenghun/[a-zA-Z0-9]+"[^>]*>[^<]+</a>`) //[^>]* 不是>符号的所有个; [^<]+不是< 的整个
res := regexp.MustCompile(`<a href="(http://www.zhenai.com/zhenghun/[a-zA-Z0-9]+)"[^>]*>([^<]+)</a>`) //[^>]* 不是>符号的所有个; [^<]+不是< 的整个
// matcher := res.FindAll(content, -1)
matcher := res.FindAllSubmatch(content, -1)
// fmt.Println(matcher)
for _,m := range matcher{
// fmt.Printf("%s \n",m)
fmt.Printf("URL:%s , AD:%s\n",m[1],m[2])
}
}
|
package debug
import (
"testing"
)
func TestNewTrace(t *testing.T) {
a := newTrace()
if a == nil {
t.Errorf("Error in newTrace()")
}
}
|
package recursion
import (
"AlgorizmiGo/recursion"
"github.com/stretchr/testify/assert"
"testing"
)
func TestSubsetSum(t *testing.T) {
tests := []struct {
input []int
targetSum int
expectedOutput bool
}{
{[]int{2, 3, 4}, 4, true},
{[]int{2, 1, 3, 4}, 4, true},
{[]int{2, 1, 3, 4}, 2, true},
{[]int{2, 1, 3, 4}, 7, true},
{[]int{2, 1, 3, 4}, 9, true},
{[]int{2, 1, 3, 4}, 10, true},
{[]int{2, 1, 3, 4}, 8, true},
{[]int{2, 1, 3, 4}, 100, false},
{[]int{2, 8, 4, 6, 15, 10, 5}, 20, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 12, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 50, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 51, false},
{[]int{2, 8, 4, 6, 15, 10, 5}, 49, false},
{[]int{2, 8, 4, 6, 15, 10, 5}, 48, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 26, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 27, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 29, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 31, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 33, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 33, true},
{[]int{2, 8, 4, 6, 15, 10, 5}, 47, false},
}
for _, test := range tests {
actualOutput := recursion.SubsetSum(test.input, test.targetSum)
assert.Equal(t, test.expectedOutput, actualOutput)
}
}
|
// Copyright 2020 The Cockroach Authors.
//
// Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt.
//
// As of the Change Date specified in that file, in accordance with
// the Business Source License, use of this software will be governed
// by the Apache License, Version 2.0, included in the file
// licenses/APL.txt.
package randgen
import (
"strings"
"testing"
"github.com/cockroachdb/cockroach/pkg/util/randutil"
)
func TestPostgresMutator(t *testing.T) {
q := `
CREATE TABLE t (s STRING FAMILY fam1, b BYTES, FAMILY fam2 (b), PRIMARY KEY (s ASC, b DESC), INDEX (s) STORING (b))
PARTITION BY LIST (s)
(
PARTITION europe_west VALUES IN ('a', 'b')
);
ALTER TABLE table1 INJECT STATISTICS 'blah';
SET CLUSTER SETTING "sql.stats.automatic_collection.enabled" = false;
`
rng, _ := randutil.NewPseudoRand()
{
mutated, changed := ApplyString(rng, q, PostgresMutator)
if !changed {
t.Fatal("expected changed")
}
mutated = strings.TrimSpace(mutated)
expect := `CREATE TABLE t (s TEXT, b BYTEA, PRIMARY KEY (s ASC, b DESC), INDEX (s) INCLUDE (b));`
if mutated != expect {
t.Fatalf("unexpected: %s", mutated)
}
}
{
mutated, changed := ApplyString(rng, q, PostgresCreateTableMutator, PostgresMutator)
if !changed {
t.Fatal("expected changed")
}
mutated = strings.TrimSpace(mutated)
expect := "CREATE TABLE t (s TEXT, b BYTEA, PRIMARY KEY (s, b));\nCREATE INDEX ON t (s) INCLUDE (b);"
if mutated != expect {
t.Fatalf("unexpected: %s", mutated)
}
}
}
|
package hotel
import (
"fmt"
"jkt/gateway/websocket"
)
const (
hotelDefaultCap = 256
)
type hotel struct {
value int32
uidset []map[int32]*websocket.Session
}
// newHotel 用于创建一个新的hotel
func newHotel() *hotel {
pHotel := &hotel{
value: 1,
uidset: make([]map[int32]*websocket.Session, 1),
}
for i := int32(0); i < pHotel.value; i++ {
pHotel.uidset[i] = map[int32]*websocket.Session{}
}
return pHotel
}
// addSession 用于向酒店中增加一个会话
func (h *hotel) addSession(uid int32, session *websocket.Session) {
slotMap := h.uidset[uid%h.value]
if oldSession, ok := slotMap[uid]; ok {
//此处需要向老会话发送重新掉线的东西
oldSession.SendMessage([]byte("被挤下线"))
fmt.Println("出现了重复的会话")
}
slotMap[uid] = session
h.uidset[uid%h.value] = slotMap
if len(slotMap) >= hotelDefaultCap {
h.value++
newUIDSet := make([]map[int32]*websocket.Session, h.value)
for i := int32(0); i < h.value; i++ {
newUIDSet[i] = map[int32]*websocket.Session{}
}
for _, slotMap = range h.uidset {
for keyUID, valueSession := range slotMap {
newUIDSet[keyUID%h.value][keyUID] = valueSession
}
}
h.uidset = newUIDSet
}
}
// deleteSession 用于删除会话
func (h *hotel) delteSession(uid int32) {
delete(h.uidset[uid%h.value], uid)
if len(h.uidset[uid%h.value]) == 0 && h.value > 1 {
h.value--
newUIDSet := make([]map[int32]*websocket.Session, h.value)
for i := int32(0); i < h.value; i++ {
newUIDSet[i] = map[int32]*websocket.Session{}
}
for _, slotMap := range h.uidset {
for keyUID, valueSession := range slotMap {
newUIDSet[keyUID%h.value][keyUID] = valueSession
}
}
h.uidset = newUIDSet
}
}
// castUID 用于向指定的UID发送消息
func (h *hotel) castUID(uid int32, data []byte) {
if session, ok := h.uidset[uid%h.value][uid]; ok {
session.CastMessage(data)
}
}
// sendUID 用于发送UID的消息
func (h *hotel) sendUID(uid int32, data []byte) {
if session, ok := h.uidset[uid%h.value][uid]; ok {
session.SendMessage(data)
}
}
// castAll 向该酒店下的所有人发送消息,
func (h *hotel) castAll(data []byte) {
for _, slotMap := range h.uidset {
for _, session := range slotMap {
session.CastMessage(data)
}
}
}
// sendAll向该酒店下的所有人发送消息
func (h *hotel) sendAll(data []byte) {
for _, slotMap := range h.uidset {
for _, session := range slotMap {
session.SendMessage(data)
}
}
}
// repeatedLogin 用于重复登录时要做的事情
func (h *hotel) repeatedLogin(uid int32) {
if session, ok := h.uidset[uid%h.value][uid]; ok {
session.Logout()
}
}
|
// Copyright 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package tcp_test
import (
"bytes"
"fmt"
"io/ioutil"
"math"
"os"
"strings"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"gvisor.dev/gvisor/pkg/buffer"
"gvisor.dev/gvisor/pkg/rand"
"gvisor.dev/gvisor/pkg/refs"
"gvisor.dev/gvisor/pkg/sync"
"gvisor.dev/gvisor/pkg/tcpip"
"gvisor.dev/gvisor/pkg/tcpip/checker"
"gvisor.dev/gvisor/pkg/tcpip/faketime"
"gvisor.dev/gvisor/pkg/tcpip/header"
"gvisor.dev/gvisor/pkg/tcpip/link/loopback"
"gvisor.dev/gvisor/pkg/tcpip/link/sniffer"
"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
"gvisor.dev/gvisor/pkg/tcpip/seqnum"
"gvisor.dev/gvisor/pkg/tcpip/stack"
tcpiptestutil "gvisor.dev/gvisor/pkg/tcpip/testutil"
"gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
"gvisor.dev/gvisor/pkg/tcpip/transport/tcp/test/e2e"
"gvisor.dev/gvisor/pkg/tcpip/transport/tcp/testing/context"
"gvisor.dev/gvisor/pkg/test/testutil"
"gvisor.dev/gvisor/pkg/waiter"
)
// endpointTester provides helper functions to test a tcpip.Endpoint.
type endpointTester struct {
ep tcpip.Endpoint
}
// CheckReadError issues a read to the endpoint and checking for an error.
func (e *endpointTester) CheckReadError(t *testing.T, want tcpip.Error) {
t.Helper()
res, got := e.ep.Read(ioutil.Discard, tcpip.ReadOptions{})
if got != want {
t.Fatalf("ep.Read = %s, want %s", got, want)
}
if diff := cmp.Diff(tcpip.ReadResult{}, res); diff != "" {
t.Errorf("ep.Read: unexpected non-zero result (-want +got):\n%s", diff)
}
}
// CheckRead issues a read to the endpoint and checking for a success, returning
// the data read.
func (e *endpointTester) CheckRead(t *testing.T) []byte {
t.Helper()
var buf bytes.Buffer
res, err := e.ep.Read(&buf, tcpip.ReadOptions{})
if err != nil {
t.Fatalf("ep.Read = _, %s; want _, nil", err)
}
if diff := cmp.Diff(tcpip.ReadResult{
Count: buf.Len(),
Total: buf.Len(),
}, res, checker.IgnoreCmpPath("ControlMessages")); diff != "" {
t.Errorf("ep.Read: unexpected result (-want +got):\n%s", diff)
}
return buf.Bytes()
}
// CheckReadFull reads from the endpoint for exactly count bytes.
func (e *endpointTester) CheckReadFull(t *testing.T, count int, notifyRead <-chan struct{}, timeout time.Duration) []byte {
t.Helper()
var buf bytes.Buffer
w := tcpip.LimitedWriter{
W: &buf,
N: int64(count),
}
for w.N != 0 {
_, err := e.ep.Read(&w, tcpip.ReadOptions{})
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for receive to be notified.
select {
case <-notifyRead:
case <-time.After(timeout):
t.Fatalf("Timed out waiting for data to arrive")
}
continue
} else if err != nil {
t.Fatalf("ep.Read = _, %s; want _, nil", err)
}
}
return buf.Bytes()
}
func TestGiveUpConnect(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
var wq waiter.Queue
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
// Register for notification, then start connection attempt.
waitEntry, notifyCh := waiter.NewChannelEntry(waiter.EventHUp)
wq.EventRegister(&waitEntry)
defer wq.EventUnregister(&waitEntry)
{
err := ep.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("ep.Connect(...) mismatch (-want +got):\n%s", d)
}
}
// Close the connection, wait for completion.
ep.Close()
// Wait for ep to become writable.
<-notifyCh
// Call Connect again to retreive the handshake failure status
// and stats updates.
{
err := ep.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrAborted{}, err); d != "" {
t.Fatalf("ep.Connect(...) mismatch (-want +got):\n%s", d)
}
}
if got := c.Stack().Stats().TCP.FailedConnectionAttempts.Value(); got != 1 {
t.Errorf("got stats.TCP.FailedConnectionAttempts.Value() = %d, want = 1", got)
}
if got := c.Stack().Stats().TCP.CurrentEstablished.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentEstablished.Value() = %d, want = 0", got)
}
}
// Test for ICMP error handling without completing handshake.
func TestConnectICMPError(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
var wq waiter.Queue
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
waitEntry, notifyCh := waiter.NewChannelEntry(waiter.EventHUp)
wq.EventRegister(&waitEntry)
defer wq.EventUnregister(&waitEntry)
{
err := ep.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("ep.Connect(...) mismatch (-want +got):\n%s", d)
}
}
syn := c.GetPacket()
defer syn.Release()
checker.IPv4(t, syn, checker.TCP(checker.TCPFlags(header.TCPFlagSyn)))
wep := ep.(interface {
LastErrorLocked() tcpip.Error
})
c.SendICMPPacket(header.ICMPv4DstUnreachable, header.ICMPv4HostUnreachable, nil, syn, e2e.DefaultMTU)
for {
if err := wep.LastErrorLocked(); err != nil {
if d := cmp.Diff(&tcpip.ErrHostUnreachable{}, err); d != "" {
t.Errorf("ep.LastErrorLocked() mismatch (-want +got):\n%s", d)
}
break
}
time.Sleep(time.Millisecond)
}
<-notifyCh
// The stack would have unregistered the endpoint because of the ICMP error.
// Expect a RST for any subsequent packets sent to the endpoint.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: seqnum.Value(context.TestInitialSequenceNumber) + 1,
AckNum: c.IRS + 1,
})
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(0),
checker.TCPFlags(header.TCPFlagRst)))
}
func TestConnectIncrementActiveConnection(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
want := stats.TCP.ActiveConnectionOpenings.Value() + 1
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
if got := stats.TCP.ActiveConnectionOpenings.Value(); got != want {
t.Errorf("got stats.TCP.ActtiveConnectionOpenings.Value() = %d, want = %d", got, want)
}
}
func TestConnectDoesNotIncrementFailedConnectionAttempts(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
want := stats.TCP.FailedConnectionAttempts.Value()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
if got := stats.TCP.FailedConnectionAttempts.Value(); got != want {
t.Errorf("got stats.TCP.FailedConnectionAttempts.Value() = %d, want = %d", got, want)
}
if got := c.EP.Stats().(*tcp.Stats).FailedConnectionAttempts.Value(); got != want {
t.Errorf("got EP stats.FailedConnectionAttempts = %d, want = %d", got, want)
}
}
func TestActiveFailedConnectionAttemptIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
c.EP = ep
want := stats.TCP.FailedConnectionAttempts.Value() + 1
{
err := c.EP.Connect(tcpip.FullAddress{NIC: 2, Addr: context.TestAddr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrHostUnreachable{}, err); d != "" {
t.Errorf("c.EP.Connect(...) mismatch (-want +got):\n%s", d)
}
}
if got := stats.TCP.FailedConnectionAttempts.Value(); got != want {
t.Errorf("got stats.TCP.FailedConnectionAttempts.Value() = %d, want = %d", got, want)
}
if got := c.EP.Stats().(*tcp.Stats).FailedConnectionAttempts.Value(); got != want {
t.Errorf("got EP stats FailedConnectionAttempts = %d, want = %d", got, want)
}
}
func TestCloseWithoutConnect(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create TCP endpoint.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
c.EP.Close()
c.EP = nil
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 0", got)
}
}
func TestHandshakeTimeoutConnectedCount(t *testing.T) {
clock := faketime.NewManualClock()
c := context.NewWithOpts(t, context.Options{
EnableV4: true,
EnableV6: true,
MTU: e2e.DefaultMTU,
Clock: clock,
})
defer c.Cleanup()
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
c.EP = ep
we, ch := waiter.NewChannelEntry(waiter.WritableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
switch err := c.EP.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort}).(type) {
case *tcpip.ErrConnectStarted:
default:
t.Fatalf("Connect did not start: %v", err)
}
clock.Advance(tcp.DefaultKeepaliveInterval)
clock.Advance(tcp.DefaultKeepaliveInterval)
<-ch
switch err := c.EP.LastError().(type) {
case *tcpip.ErrTimeout:
default:
t.Fatalf("Connect didn't timeout: %v", err)
}
if got, want := c.Stack().Stats().TCP.CurrentConnected.Value(), uint64(0); got != want {
t.Fatalf("got stats.TCP.CurrentConnected.Value() = %d, want = %d", got, want)
}
}
func TestTCPSegmentsSentIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
// SYN and ACK
want := stats.TCP.SegmentsSent.Value() + 2
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
if got := stats.TCP.SegmentsSent.Value(); got != want {
t.Errorf("got stats.TCP.SegmentsSent.Value() = %d, want = %d", got, want)
}
if got := c.EP.Stats().(*tcp.Stats).SegmentsSent.Value(); got != want {
t.Errorf("got EP stats SegmentsSent.Value() = %d, want = %d", got, want)
}
}
func TestTCPResetsSentIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
want := stats.TCP.SegmentsSent.Value() + 1
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send a SYN request.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
})
// Receive the SYN-ACK reply.
v := c.GetPacket()
defer v.Release()
tcpHdr := header.TCP(header.IPv4(v.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
ackHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
// If the AckNum is not the increment of the last sequence number, a RST
// segment is sent back in response.
AckNum: c.IRS + 2,
}
// Send ACK.
c.SendPacket(nil, ackHeaders)
v = c.GetPacket()
defer v.Release()
metricPollFn := func() error {
if got := stats.TCP.ResetsSent.Value(); got != want {
return fmt.Errorf("got stats.TCP.ResetsSent.Value() = %d, want = %d", got, want)
}
return nil
}
if err := testutil.Poll(metricPollFn, 1*time.Second); err != nil {
t.Error(err)
}
}
// TestTCPResetsSentNoICMP confirms that we don't get an ICMP DstUnreachable
// packet when we try send a packet which is not part of an active session.
func TestTCPResetsSentNoICMP(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
// Send a SYN request for a closed port. This should elicit an RST
// but NOT an ICMPv4 DstUnreachable packet.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
})
// Receive whatever comes back.
v := c.GetPacket()
defer v.Release()
ipHdr := header.IPv4(v.AsSlice())
if got, want := ipHdr.Protocol(), uint8(header.TCPProtocolNumber); got != want {
t.Errorf("unexpected protocol, got = %d, want = %d", got, want)
}
// Read outgoing ICMP stats and check no ICMP DstUnreachable was recorded.
sent := stats.ICMP.V4.PacketsSent
if got, want := sent.DstUnreachable.Value(), uint64(0); got != want {
t.Errorf("got ICMP DstUnreachable.Value() = %d, want = %d", got, want)
}
}
// TestTCPResetSentForACKWhenNotUsingSynCookies checks that the stack generates
// a RST if an ACK is received on the listening socket for which there is no
// active handshake in progress and we are not using SYN cookies.
func TestTCPResetSentForACKWhenNotUsingSynCookies(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set TCPLingerTimeout to 5 seconds so that sockets are marked closed
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send a SYN request.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
})
// Receive the SYN-ACK reply.
v := c.GetPacket()
defer v.Release()
tcpHdr := header.TCP(header.IPv4(v.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
ackHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 1,
}
// Send ACK.
c.SendPacket(nil, ackHeaders)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
// Lower stackwide TIME_WAIT timeout so that the reservations
// are released instantly on Close.
tcpTW := tcpip.TCPTimeWaitTimeoutOption(1 * time.Millisecond)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &tcpTW); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, tcpTW, tcpTW, err)
}
c.EP.Close()
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagFin|header.TCPFlagAck)))
finHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss + 1,
AckNum: c.IRS + 2,
}
c.SendPacket(nil, finHeaders)
// Get the ACK to the FIN we just sent.
b = c.GetPacket()
defer b.Release()
// Since an active close was done we need to wait for a little more than
// tcpLingerTimeout for the port reservations to be released and the
// socket to move to a CLOSED state.
time.Sleep(20 * time.Millisecond)
// Now resend the same ACK, this ACK should generate a RST as there
// should be no endpoint in SYN-RCVD state and we are not using
// syn-cookies yet. The reason we send the same ACK is we need a valid
// cookie(IRS) generated by the netstack without which the ACK will be
// rejected.
c.SendPacket(nil, ackHeaders)
b = c.GetPacket()
defer b.Release()
checker.IPv4(t, b, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(0),
checker.TCPFlags(header.TCPFlagRst)))
}
func TestTCPResetsReceivedIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
want := stats.TCP.ResetsReceived.Value() + 1
iss := seqnum.Value(context.TestInitialSequenceNumber)
rcvWnd := seqnum.Size(30000)
c.CreateConnected(iss, rcvWnd, -1 /* epRcvBuf */)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
SeqNum: iss.Add(1),
AckNum: c.IRS.Add(1),
RcvWnd: rcvWnd,
Flags: header.TCPFlagRst,
})
if got := stats.TCP.ResetsReceived.Value(); got != want {
t.Errorf("got stats.TCP.ResetsReceived.Value() = %d, want = %d", got, want)
}
}
func TestTCPResetsDoNotGenerateResets(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
want := stats.TCP.ResetsReceived.Value() + 1
iss := seqnum.Value(context.TestInitialSequenceNumber)
rcvWnd := seqnum.Size(30000)
c.CreateConnected(iss, rcvWnd, -1 /* epRcvBuf */)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
SeqNum: iss.Add(1),
AckNum: c.IRS.Add(1),
RcvWnd: rcvWnd,
Flags: header.TCPFlagRst,
})
if got := stats.TCP.ResetsReceived.Value(); got != want {
t.Errorf("got stats.TCP.ResetsReceived.Value() = %d, want = %d", got, want)
}
c.CheckNoPacketTimeout("got an unexpected packet", 100*time.Millisecond)
}
func TestActiveHandshake(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
}
func TestNonBlockingClose(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
ep := c.EP
c.EP = nil
// Close the endpoint and measure how long it takes.
t0 := time.Now()
ep.Close()
if diff := time.Now().Sub(t0); diff > 3*time.Second {
t.Fatalf("Took too long to close: %s", diff)
}
}
func TestConnectResetAfterClose(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set TCPLinger to 3 seconds so that sockets are marked closed
// after 3 second in FIN_WAIT2 state.
tcpLingerTimeout := 3 * time.Second
opt := tcpip.TCPLingerTimeoutOption(tcpLingerTimeout)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, opt, opt, err)
}
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
ep := c.EP
c.EP = nil
// Close the endpoint, make sure we get a FIN segment, then acknowledge
// to complete closure of sender, but don't send our own FIN.
ep.Close()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
// Wait for the ep to give up waiting for a FIN.
time.Sleep(tcpLingerTimeout + 1*time.Second)
// Now send an ACK and it should trigger a RST as the endpoint should
// not exist anymore.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
for {
v := c.GetPacket()
defer v.Release()
tcpHdr := header.TCP(header.IPv4(v.AsSlice()).Payload())
if tcpHdr.Flags() == header.TCPFlagAck|header.TCPFlagFin {
// This is a retransmit of the FIN, ignore it.
continue
}
checker.IPv4(t, v,
checker.TCP(
checker.DstPort(context.TestPort),
// RST is always generated with sndNxt which if the FIN
// has been sent will be 1 higher than the sequence number
// of the FIN itself.
checker.TCPSeqNum(uint32(c.IRS)+2),
checker.TCPAckNum(0),
checker.TCPFlags(header.TCPFlagRst),
),
)
break
}
}
// TestCurrentConnectedIncrement tests increment of the current
// established and connected counters.
func TestCurrentConnectedIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set TCPTimeWaitTimeout to 1 seconds so that sockets are marked closed
// after 1 second in TIME_WAIT state.
tcpTimeWaitTimeout := 1 * time.Second
opt := tcpip.TCPTimeWaitTimeoutOption(tcpTimeWaitTimeout)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, opt, opt, err)
}
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
ep := c.EP
c.EP = nil
if got := c.Stack().Stats().TCP.CurrentEstablished.Value(); got != 1 {
t.Errorf("got stats.TCP.CurrentEstablished.Value() = %d, want = 1", got)
}
gotConnected := c.Stack().Stats().TCP.CurrentConnected.Value()
if gotConnected != 1 {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 1", gotConnected)
}
ep.Close()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
if got := c.Stack().Stats().TCP.CurrentEstablished.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentEstablished.Value() = %d, want = 0", got)
}
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != gotConnected {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = %d", got, gotConnected)
}
// Ack and send FIN as well.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss,
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
// Check that the stack acks the FIN.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+2),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Wait for a little more than the TIME-WAIT duration for the socket to
// transition to CLOSED state.
time.Sleep(1200 * time.Millisecond)
if got := c.Stack().Stats().TCP.CurrentEstablished.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentEstablished.Value() = %d, want = 0", got)
}
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 0", got)
}
}
// TestClosingWithEnqueuedSegments tests handling of still enqueued segments
// when the endpoint transitions to StateClose. The in-flight segments would be
// re-enqueued to a any listening endpoint.
func TestClosingWithEnqueuedSegments(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
ep := c.EP
c.EP = nil
if got, want := tcp.EndpointState(ep.State()), tcp.StateEstablished; got != want {
t.Errorf("unexpected endpoint state: want %d, got %d", want, got)
}
// Send a FIN for ESTABLISHED --> CLOSED-WAIT
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagFin | header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Get the ACK for the FIN we sent.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Give the stack a few ms to transition the endpoint out of ESTABLISHED
// state.
time.Sleep(10 * time.Millisecond)
if got, want := tcp.EndpointState(ep.State()), tcp.StateCloseWait; got != want {
t.Errorf("unexpected endpoint state: want %d, got %d", want, got)
}
// Close the application endpoint for CLOSE_WAIT --> LAST_ACK
ep.Close()
// Get the FIN
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
if got, want := tcp.EndpointState(ep.State()), tcp.StateLastAck; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
// Pause the endpoint`s protocolMainLoop.
ep.(interface{ StopWork() }).StopWork()
// Enqueue last ACK followed by an ACK matching the endpoint
//
// Send Last ACK for LAST_ACK --> CLOSED
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(1),
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
// Send a packet with ACK set, this would generate RST when
// not using SYN cookies as in this test.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss.Add(2),
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
// Unpause endpoint`s protocolMainLoop.
ep.(interface{ ResumeWork() }).ResumeWork()
// Wait for the protocolMainLoop to resume and update state.
time.Sleep(10 * time.Millisecond)
// Expect the endpoint to be closed.
if got, want := tcp.EndpointState(ep.State()), tcp.StateClose; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
if got := c.Stack().Stats().TCP.EstablishedClosed.Value(); got != 1 {
t.Errorf("got c.Stack().Stats().TCP.EstablishedClosed = %d, want = 1", got)
}
if got := c.Stack().Stats().TCP.CurrentEstablished.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentEstablished.Value() = %d, want = 0", got)
}
// Check if the endpoint was moved to CLOSED and netstack sent a reset in
// response to the ACK packet that we sent after last-ACK.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+2),
checker.TCPAckNum(0),
checker.TCPFlags(header.TCPFlagRst),
),
)
}
func TestSimpleReceive(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
ept := endpointTester{c.EP}
data := []byte{1, 2, 3}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Wait for receive to be notified.
select {
case <-ch:
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for data to arrive")
}
// Receive data.
v := ept.CheckRead(t)
if !bytes.Equal(data, v) {
t.Fatalf("got data = %v, want = %v", v, data)
}
// Check that ACK is received.
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(len(data))),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
// TestUserSuppliedMSSOnConnect tests that the user supplied MSS is used when
// creating a new active TCP socket. It should be present in the sent TCP
// SYN segment.
func TestUserSuppliedMSSOnConnect(t *testing.T) {
const mtu = 5000
ips := []struct {
name string
createEP func(*context.Context)
connectAddr tcpip.Address
checker func(*testing.T, *context.Context, uint16, int)
maxMSS uint16
}{
{
name: "IPv4",
createEP: func(c *context.Context) {
c.Create(-1)
},
connectAddr: context.TestAddr,
checker: func(t *testing.T, c *context.Context, mss uint16, ws int) {
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagSyn),
checker.TCPSynOptions(header.TCPSynOptions{MSS: mss, WS: ws})))
},
maxMSS: mtu - header.IPv4MinimumSize - header.TCPMinimumSize,
},
{
name: "IPv6",
createEP: func(c *context.Context) {
c.CreateV6Endpoint(true)
},
connectAddr: context.TestV6Addr,
checker: func(t *testing.T, c *context.Context, mss uint16, ws int) {
v := c.GetV6Packet()
defer v.Release()
checker.IPv6(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagSyn),
checker.TCPSynOptions(header.TCPSynOptions{MSS: mss, WS: ws})))
},
maxMSS: mtu - header.IPv6MinimumSize - header.TCPMinimumSize,
},
}
for _, ip := range ips {
t.Run(ip.name, func(t *testing.T) {
tests := []struct {
name string
setMSS uint16
expMSS uint16
}{
{
name: "EqualToMaxMSS",
setMSS: ip.maxMSS,
expMSS: ip.maxMSS,
},
{
name: "LessThanMaxMSS",
setMSS: ip.maxMSS - 1,
expMSS: ip.maxMSS - 1,
},
{
name: "GreaterThanMaxMSS",
setMSS: ip.maxMSS + 1,
expMSS: ip.maxMSS,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, mtu)
defer c.Cleanup()
ip.createEP(c)
// Set the MSS socket option.
if err := c.EP.SetSockOptInt(tcpip.MaxSegOption, int(test.setMSS)); err != nil {
t.Fatalf("SetSockOptInt(MaxSegOption, %d): %s", test.setMSS, err)
}
// Get expected window size.
rcvBufSize := c.EP.SocketOptions().GetReceiveBufferSize()
ws := tcp.FindWndScale(seqnum.Size(rcvBufSize))
connectAddr := tcpip.FullAddress{Addr: ip.connectAddr, Port: context.TestPort}
{
err := c.EP.Connect(connectAddr)
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("Connect(%+v) mismatch (-want +got):\n%s", connectAddr, d)
}
}
// Receive SYN packet with our user supplied MSS.
ip.checker(t, c, test.expMSS, ws)
})
}
})
}
}
// TestUserSuppliedMSSOnListenAccept tests that the user supplied MSS is used
// when completing the handshake for a new TCP connection from a TCP
// listening socket. It should be present in the sent TCP SYN-ACK segment.
func TestUserSuppliedMSSOnListenAccept(t *testing.T) {
const mtu = 5000
ips := []struct {
name string
createEP func(*context.Context)
sendPkt func(*context.Context, *context.Headers)
checker func(*testing.T, *context.Context, uint16, uint16)
maxMSS uint16
}{
{
name: "IPv4",
createEP: func(c *context.Context) {
c.Create(-1)
},
sendPkt: func(c *context.Context, h *context.Headers) {
c.SendPacket(nil, h)
},
checker: func(t *testing.T, c *context.Context, srcPort, mss uint16) {
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(srcPort),
checker.TCPFlags(header.TCPFlagSyn|header.TCPFlagAck),
checker.TCPSynOptions(header.TCPSynOptions{MSS: mss, WS: -1})))
},
maxMSS: mtu - header.IPv4MinimumSize - header.TCPMinimumSize,
},
{
name: "IPv6",
createEP: func(c *context.Context) {
c.CreateV6Endpoint(false)
},
sendPkt: func(c *context.Context, h *context.Headers) {
c.SendV6Packet(nil, h)
},
checker: func(t *testing.T, c *context.Context, srcPort, mss uint16) {
v := c.GetV6Packet()
defer v.Release()
checker.IPv6(t, v, checker.TCP(
checker.DstPort(srcPort),
checker.TCPFlags(header.TCPFlagSyn|header.TCPFlagAck),
checker.TCPSynOptions(header.TCPSynOptions{MSS: mss, WS: -1})))
},
maxMSS: mtu - header.IPv6MinimumSize - header.TCPMinimumSize,
},
}
for _, ip := range ips {
t.Run(ip.name, func(t *testing.T) {
tests := []struct {
name string
setMSS uint16
expMSS uint16
}{
{
name: "EqualToMaxMSS",
setMSS: ip.maxMSS,
expMSS: ip.maxMSS,
},
{
name: "LessThanMaxMSS",
setMSS: ip.maxMSS - 1,
expMSS: ip.maxMSS - 1,
},
{
name: "GreaterThanMaxMSS",
setMSS: ip.maxMSS + 1,
expMSS: ip.maxMSS,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, mtu)
defer c.Cleanup()
ip.createEP(c)
if err := c.EP.SetSockOptInt(tcpip.MaxSegOption, int(test.setMSS)); err != nil {
t.Fatalf("SetSockOptInt(MaxSegOption, %d): %s", test.setMSS, err)
}
bindAddr := tcpip.FullAddress{Port: context.StackPort}
if err := c.EP.Bind(bindAddr); err != nil {
t.Fatalf("Bind(%+v): %s:", bindAddr, err)
}
backlog := 5
// Keep the number of client requests twice to the backlog
// such that half of the connections do not use syncookies
// and the other half does.
clientConnects := backlog * 2
if err := c.EP.Listen(backlog); err != nil {
t.Fatalf("Listen(%d): %s:", backlog, err)
}
for i := 0; i < clientConnects; i++ {
// Send a SYN requests.
iss := seqnum.Value(i)
srcPort := context.TestPort + uint16(i)
ip.sendPkt(c, &context.Headers{
SrcPort: srcPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
})
// Receive the SYN-ACK reply.
ip.checker(t, c, srcPort, test.expMSS)
}
})
}
})
}
}
func TestSendRstOnListenerRxSynAckV4(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(10); err != nil {
t.Fatal("Listen failed:", err)
}
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn | header.TCPFlagAck,
SeqNum: 100,
AckNum: 200,
})
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagRst),
checker.TCPSeqNum(200)))
}
func TestSendRstOnListenerRxSynAckV6(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateV6Endpoint(true)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(10); err != nil {
t.Fatal("Listen failed:", err)
}
c.SendV6Packet(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn | header.TCPFlagAck,
SeqNum: 100,
AckNum: 200,
})
v := c.GetV6Packet()
defer v.Release()
checker.IPv6(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagRst),
checker.TCPSeqNum(200)))
}
// TestNoSynCookieWithoutOverflow tests that SYN-COOKIEs are not issued when the
// queue is not overflowing. That is as long as newly completed connections are being
// accepted we do not see a SYN-COOKIE even > 2x listen backlog number of connections
// are accepted.
func TestNoSynCookieWithoutOverflow(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
const backlog = 10
if err := c.EP.Listen(backlog); err != nil {
t.Fatal("Listen failed:", err)
}
doOne := func(portIndex int) {
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
_, _ = executeHandshake(t, c, context.TestPort+uint16(portIndex), false /* synCookiesInUse */)
_, _, err := c.EP.Accept(nil)
if err == nil {
return
}
switch {
case cmp.Equal(&tcpip.ErrWouldBlock{}, err):
{
select {
case <-ch:
_, _, err = c.EP.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
default:
t.Fatalf("Accept failed: %s", err)
}
}
for i := 0; i < backlog*5; i++ {
doOne(i)
}
}
// TestNoSynCookieOnFailedHandshakes tests that failed handshakes clear
// endpoints from the pending queue. This is tested by verifying that the
// SYN-ACK from the stack carries a valid window scale despite > 2xbacklog
// handshakes failing.
//
// If a failed handshake was not resulting in removal from pending endpoints
// list for the accepting endpoint then it will eventually result in a
// SYN-COOKIE which we can identify with a SYN-ACK w/ a WS of -1.
func TestNoSynCookieOnFailedHandshakes(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
const backlog = 10
if err := c.EP.Listen(backlog); err != nil {
t.Fatal("Listen failed:", err)
}
doOne := func() {
// Send a SYN request.
options := []byte{header.TCPOptionWS, 3, 0, header.TCPOptionNOP}
irs := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
TCPOpts: options,
})
// Receive the SYN-ACK reply.
v := c.GetPacket()
defer v.Release()
tcpHdr := header.TCP(header.IPv4(v.AsSlice()).Payload())
iss := seqnum.Value(tcpHdr.SequenceNumber())
tcpCheckers := []checker.TransportChecker{
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck | header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs) + 1),
checker.TCPSynOptions(header.TCPSynOptions{
WS: tcp.FindWndScale(tcp.DefaultReceiveBufferSize),
MSS: c.MSSWithoutOptions(),
}),
}
checker.IPv4(t, v, checker.TCP(tcpCheckers...))
// Send a RST to abort the handshake.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagRst,
SeqNum: irs + 1,
AckNum: iss + 1,
RcvWnd: 0,
})
}
for i := 0; i < backlog*5; i++ {
doOne()
}
}
// TestTCPAckBeforeAcceptV4 tests that once the 3-way handshake is complete,
// peers can send data and expect a response within a reasonable ammount of time
// without calling Accept on the listening endpoint first.
//
// This test uses IPv4.
func TestTCPAckBeforeAcceptV4(t *testing.T) {
for _, cookieEnabled := range []tcpip.TCPAlwaysUseSynCookies{false, true} {
t.Run(fmt.Sprintf("syn-cookies enabled: %t", cookieEnabled), func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
if err := c.Stack().SetTransportProtocolOption(header.TCPProtocolNumber, &cookieEnabled); err != nil {
panic(fmt.Sprintf("SetTransportProtocolOption(%d, %T) = %s", header.TCPProtocolNumber, cookieEnabled, err))
}
c.Create(-1)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(10); err != nil {
t.Fatal("Listen failed:", err)
}
irs, iss := executeHandshake(t, c, context.TestPort, bool(cookieEnabled))
// Send data before accepting the connection.
c.SendPacket([]byte{1, 2, 3, 4}, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: irs + 1,
AckNum: iss + 1,
})
// Receive ACK for the data we sent.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPSeqNum(uint32(iss+1)),
checker.TCPAckNum(uint32(irs+5))))
})
}
}
// TestTCPAckBeforeAcceptV6 tests that once the 3-way handshake is complete,
// peers can send data and expect a response within a reasonable ammount of time
// without calling Accept on the listening endpoint first.
//
// This test uses IPv6.
func TestTCPAckBeforeAcceptV6(t *testing.T) {
for _, cookieEnabled := range []tcpip.TCPAlwaysUseSynCookies{false, true} {
t.Run(fmt.Sprintf("syn-cookies enabled: %t", cookieEnabled), func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
if err := c.Stack().SetTransportProtocolOption(header.TCPProtocolNumber, &cookieEnabled); err != nil {
panic(fmt.Sprintf("SetTransportProtocolOption(%d, %T) = %s", header.TCPProtocolNumber, cookieEnabled, err))
}
c.CreateV6Endpoint(true)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(10); err != nil {
t.Fatal("Listen failed:", err)
}
irs, iss := executeV6Handshake(t, c, context.TestPort, bool(cookieEnabled))
// Send data before accepting the connection.
c.SendV6Packet([]byte{1, 2, 3, 4}, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: irs + 1,
AckNum: iss + 1,
})
// Receive ACK for the data we sent.
v := c.GetV6Packet()
defer v.Release()
checker.IPv6(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPSeqNum(uint32(iss+1)),
checker.TCPAckNum(uint32(irs+5))))
})
}
}
func TestSendRstOnListenerRxAckV4(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1 /* epRcvBuf */)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(10 /* backlog */); err != nil {
t.Fatal("Listen failed:", err)
}
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagFin | header.TCPFlagAck,
SeqNum: 100,
AckNum: 200,
})
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagRst),
checker.TCPSeqNum(200)))
}
func TestSendRstOnListenerRxAckV6(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateV6Endpoint(true /* v6Only */)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(10 /* backlog */); err != nil {
t.Fatal("Listen failed:", err)
}
c.SendV6Packet(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagFin | header.TCPFlagAck,
SeqNum: 100,
AckNum: 200,
})
v := c.GetV6Packet()
defer v.Release()
checker.IPv6(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagRst),
checker.TCPSeqNum(200)))
}
// TestListenShutdown tests for the listening endpoint replying with RST
// on read shutdown.
func TestListenShutdown(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1 /* epRcvBuf */)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(1 /* backlog */); err != nil {
t.Fatal("Listen failed:", err)
}
if err := c.EP.Shutdown(tcpip.ShutdownRead); err != nil {
t.Fatal("Shutdown failed:", err)
}
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: 100,
AckNum: 200,
})
// Expect the listening endpoint to reset the connection.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagRst),
))
}
func TestListenerReadinessOnEvent(t *testing.T) {
s := stack.New(stack.Options{
TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol},
NetworkProtocols: []stack.NetworkProtocolFactory{ipv4.NewProtocol},
})
defer s.Destroy()
{
ep := loopback.New()
if testing.Verbose() {
ep = sniffer.New(ep)
}
const id = 1
if err := s.CreateNIC(id, ep); err != nil {
t.Fatalf("CreateNIC(%d, %T): %s", id, ep, err)
}
protocolAddr := tcpip.ProtocolAddress{
Protocol: ipv4.ProtocolNumber,
AddressWithPrefix: tcpip.Address(context.StackAddr).WithPrefix(),
}
if err := s.AddProtocolAddress(id, protocolAddr, stack.AddressProperties{}); err != nil {
t.Fatalf("AddProtocolAddress(%d, %+v, {}): %s", id, protocolAddr, err)
}
s.SetRouteTable([]tcpip.Route{
{Destination: header.IPv4EmptySubnet, NIC: id},
})
}
var wq waiter.Queue
ep, err := s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &wq)
if err != nil {
t.Fatalf("NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, _): %s", err)
}
defer ep.Close()
if err := ep.Bind(tcpip.FullAddress{Addr: context.StackAddr}); err != nil {
t.Fatalf("Bind(%s): %s", context.StackAddr, err)
}
const backlog = 1
if err := ep.Listen(backlog); err != nil {
t.Fatalf("Listen(%d): %s", backlog, err)
}
address, err := ep.GetLocalAddress()
if err != nil {
t.Fatalf("GetLocalAddress(): %s", err)
}
conn, err := s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &wq)
if err != nil {
t.Fatalf("NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, _): %s", err)
}
defer conn.Close()
events := make(chan waiter.EventMask)
// Scope `entry` to allow a binding of the same name below.
{
entry := waiter.NewFunctionEntry(waiter.EventIn, func(mask waiter.EventMask) {
events <- ep.Readiness(mask)
})
wq.EventRegister(&entry)
defer wq.EventUnregister(&entry)
}
entry, ch := waiter.NewChannelEntry(waiter.EventOut)
wq.EventRegister(&entry)
defer wq.EventUnregister(&entry)
switch err := conn.Connect(address).(type) {
case *tcpip.ErrConnectStarted:
default:
t.Fatalf("Connect(%#v): %v", address, err)
}
// Read at least one event.
got := <-events
for {
select {
case event := <-events:
got |= event
continue
case <-ch:
if want := waiter.ReadableEvents; got != want {
t.Errorf("observed events = %b, want %b", got, want)
}
}
break
}
}
// TestListenCloseWhileConnect tests for the listening endpoint to
// drain the accept-queue when closed. This should reset all of the
// pending connections that are waiting to be accepted.
func TestListenCloseWhileConnect(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1 /* epRcvBuf */)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(1 /* backlog */); err != nil {
t.Fatal("Listen failed:", err)
}
waitEntry, notifyCh := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&waitEntry)
defer c.WQ.EventUnregister(&waitEntry)
executeHandshake(t, c, context.TestPort, true /* synCookiesInUse */)
// Wait for the new endpoint created because of handshake to be delivered
// to the listening endpoint's accept queue.
<-notifyCh
// Close the listening endpoint.
c.EP.Close()
// Expect the listening endpoint to reset the connection.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagRst),
))
}
func TestTOSV4(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
c.EP = ep
const tos = 0xC0
if err := c.EP.SetSockOptInt(tcpip.IPv4TOSOption, tos); err != nil {
t.Errorf("SetSockOptInt(IPv4TOSOption, %d) failed: %s", tos, err)
}
v, err := c.EP.GetSockOptInt(tcpip.IPv4TOSOption)
if err != nil {
t.Errorf("GetSockoptInt(IPv4TOSOption) failed: %s", err)
}
if v != tos {
t.Errorf("got GetSockOptInt(IPv4TOSOption) = %d, want = %d", v, tos)
}
e2e.TestV4Connect(t, c, checker.TOS(tos, 0))
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that data is received.
p := c.GetPacket()
defer p.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv4(t, p,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)), // Acknum is initial sequence number + 1
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
checker.TOS(tos, 0),
)
if b := p.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:]; !bytes.Equal(data, b) {
t.Errorf("got data = %x, want = %x", p.AsSlice(), data)
}
}
func TestTrafficClassV6(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateV6Endpoint(false)
const tos = 0xC0
if err := c.EP.SetSockOptInt(tcpip.IPv6TrafficClassOption, tos); err != nil {
t.Errorf("SetSockOpInt(IPv6TrafficClassOption, %d) failed: %s", tos, err)
}
v, err := c.EP.GetSockOptInt(tcpip.IPv6TrafficClassOption)
if err != nil {
t.Fatalf("GetSockoptInt(IPv6TrafficClassOption) failed: %s", err)
}
if v != tos {
t.Errorf("got GetSockOptInt(IPv6TrafficClassOption) = %d, want = %d", v, tos)
}
// Test the connection request.
e2e.TestV6Connect(t, c, checker.TOS(tos, 0))
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that data is received.
b := c.GetV6Packet()
defer b.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv6(t, b,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
checker.TOS(tos, 0),
)
if p := b.AsSlice()[header.IPv6MinimumSize+header.TCPMinimumSize:]; !bytes.Equal(data, p) {
t.Errorf("got data = %x, want = %x", p, data)
}
}
func TestConnectBindToDevice(t *testing.T) {
for _, test := range []struct {
name string
device tcpip.NICID
want tcp.EndpointState
}{
{"RightDevice", 1, tcp.StateEstablished},
{"WrongDevice", 2, tcp.StateSynSent},
{"AnyDevice", 0, tcp.StateEstablished},
} {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1)
if err := c.EP.SocketOptions().SetBindToDevice(int32(test.device)); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%d)): %s", test.device, test.device, err)
}
// Start connection attempt.
waitEntry, _ := waiter.NewChannelEntry(waiter.WritableEvents)
c.WQ.EventRegister(&waitEntry)
defer c.WQ.EventUnregister(&waitEntry)
err := c.EP.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("c.EP.Connect(...) mismatch (-want +got):\n%s", d)
}
// Receive SYN packet.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagSyn),
),
)
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateSynSent; got != want {
t.Fatalf("unexpected endpoint state: want %s, got %s", want, got)
}
tcpHdr := header.TCP(header.IPv4(v.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
iss := seqnum.Value(context.TestInitialSequenceNumber)
rcvWnd := seqnum.Size(30000)
c.SendPacket(nil, &context.Headers{
SrcPort: tcpHdr.DestinationPort(),
DstPort: tcpHdr.SourcePort(),
Flags: header.TCPFlagSyn | header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: rcvWnd,
TCPOpts: nil,
})
v = c.GetPacket()
defer v.Release()
if got, want := tcp.EndpointState(c.EP.State()), test.want; got != want {
t.Fatalf("unexpected endpoint state: want %s, got %s", want, got)
}
})
}
}
func TestShutdownConnectingSocket(t *testing.T) {
for _, test := range []struct {
name string
shutdownMode tcpip.ShutdownFlags
}{
{"ShutdownRead", tcpip.ShutdownRead},
{"ShutdownWrite", tcpip.ShutdownWrite},
{"ShutdownReadWrite", tcpip.ShutdownRead | tcpip.ShutdownWrite},
} {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create an endpoint, don't handshake because we want to interfere with
// the handshake process.
c.Create(-1)
waitEntry, ch := waiter.NewChannelEntry(waiter.EventHUp)
c.WQ.EventRegister(&waitEntry)
defer c.WQ.EventUnregister(&waitEntry)
// Start connection attempt.
addr := tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort}
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, c.EP.Connect(addr)); d != "" {
t.Fatalf("Connect(...) mismatch (-want +got):\n%s", d)
}
// Check the SYN packet.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagSyn),
),
)
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateSynSent; got != want {
t.Fatalf("got State() = %s, want %s", got, want)
}
if err := c.EP.Shutdown(test.shutdownMode); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
// The endpoint internal state is updated immediately.
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateError; got != want {
t.Fatalf("got State() = %s, want %s", got, want)
}
select {
case <-ch:
default:
t.Fatal("endpoint was not notified")
}
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrConnectionReset{})
// If the endpoint is not properly shutdown, it'll re-attempt to connect
// by sending another ACK packet.
c.CheckNoPacketTimeout("got an unexpected packet", tcp.InitialRTO+(500*time.Millisecond))
})
}
}
func TestSynSent(t *testing.T) {
for _, test := range []struct {
name string
reset bool
}{
{"RstOnSynSent", true},
{"CloseOnSynSent", false},
} {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create an endpoint, don't handshake because we want to interfere with the
// handshake process.
c.Create(-1)
// Start connection attempt.
waitEntry, ch := waiter.NewChannelEntry(waiter.EventHUp)
c.WQ.EventRegister(&waitEntry)
defer c.WQ.EventUnregister(&waitEntry)
addr := tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort}
err := c.EP.Connect(addr)
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("Connect(...) mismatch (-want +got):\n%s", d)
}
// Receive SYN packet.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagSyn),
),
)
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateSynSent; got != want {
t.Fatalf("got State() = %s, want %s", got, want)
}
tcpHdr := header.TCP(header.IPv4(v.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
if test.reset {
// Send a packet with a proper ACK and a RST flag to cause the socket
// to error and close out.
iss := seqnum.Value(context.TestInitialSequenceNumber)
rcvWnd := seqnum.Size(30000)
c.SendPacket(nil, &context.Headers{
SrcPort: tcpHdr.DestinationPort(),
DstPort: tcpHdr.SourcePort(),
Flags: header.TCPFlagRst | header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: rcvWnd,
TCPOpts: nil,
})
} else {
c.EP.Close()
}
// Wait for receive to be notified.
select {
case <-ch:
case <-time.After(3 * time.Second):
t.Fatal("timed out waiting for packet to arrive")
}
ept := endpointTester{c.EP}
if test.reset {
ept.CheckReadError(t, &tcpip.ErrConnectionRefused{})
} else {
ept.CheckReadError(t, &tcpip.ErrAborted{})
}
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 0", got)
}
// Due to the RST the endpoint should be in an error state.
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateError; got != want {
t.Fatalf("got State() = %s, want %s", got, want)
}
})
}
}
func TestOutOfOrderReceive(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
// Send second half of data first, with seqnum 3 ahead of expected.
data := []byte{1, 2, 3, 4, 5, 6}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(data[3:], &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(3),
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Check that we get an ACK specifying which seqnum is expected.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Wait 200ms and check that no data has been received.
time.Sleep(200 * time.Millisecond)
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
// Send the first 3 bytes now.
c.SendPacket(data[:3], &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Receive data.
read := ept.CheckReadFull(t, 6, ch, 5*time.Second)
// Check that we received the data in proper order.
if !bytes.Equal(data, read) {
t.Fatalf("got data = %v, want = %v", read, data)
}
// Check that the whole data is acknowledged.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(len(data))),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestOutOfOrderFlood(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
rcvBufSz := math.MaxUint16
c.CreateConnected(context.TestInitialSequenceNumber, 30000, rcvBufSz)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
// Send 100 packets with seqnum iss + 6 before the actual one that is
// expected.
data := []byte{1, 2, 3, 4, 5, 6}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for i := 0; i < 100; i++ {
c.SendPacket(data[3:], &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(6),
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
// Send packet with seqnum as initial + 3. It won't be discarded
// because the receive window limits the sender to rcvBufSize/2 bytes,
// but we allow (3/4)*rcvBufSize to be used for out-of-order bytes. So
// the sender hasn't filled the buffer and we still have space to
// receive it.
c.SendPacket(data[3:], &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(3),
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Now send the expected packet with initial sequence number.
c.SendPacket(data[:3], &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Check that all packets are acknowledged.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+9),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestRstOnCloseWithUnreadData(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
data := []byte{1, 2, 3}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Wait for receive to be notified.
select {
case <-ch:
case <-time.After(3 * time.Second):
t.Fatalf("Timed out waiting for data to arrive")
}
// Check that ACK is received, this happens regardless of the read.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(len(data))),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Now that we know we have unread data, let's just close the connection
// and verify that netstack sends an RST rather than a FIN.
c.EP.Close()
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagRst),
// We shouldn't consume a sequence number on RST.
checker.TCPSeqNum(uint32(c.IRS)+1),
))
// The RST puts the endpoint into an error state.
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateError; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
// This final ACK should be ignored because an ACK on a reset doesn't mean
// anything.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(seqnum.Size(len(data))),
AckNum: c.IRS.Add(seqnum.Size(2)),
RcvWnd: 30000,
})
}
func TestRstOnCloseWithUnreadDataFinConvertRst(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
data := []byte{1, 2, 3}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Wait for receive to be notified.
select {
case <-ch:
case <-time.After(3 * time.Second):
t.Fatalf("Timed out waiting for data to arrive")
}
// Check that ACK is received, this happens regardless of the read.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(len(data))),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Cause a FIN to be generated.
if err := c.EP.Shutdown(tcpip.ShutdownWrite); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
// Make sure we get the FIN but DON't ACK IT.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
checker.TCPSeqNum(uint32(c.IRS)+1),
))
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateFinWait1; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
// Cause a RST to be generated by closing the read end now since we have
// unread data.
if err := c.EP.Shutdown(tcpip.ShutdownRead); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
// Make sure we get the RST
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagRst),
// RST is always generated with sndNxt which if the FIN
// has been sent will be 1 higher than the sequence
// number of the FIN itself.
checker.TCPSeqNum(uint32(c.IRS)+2),
))
// The RST puts the endpoint into an error state.
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateError; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
// The ACK to the FIN should now be rejected since the connection has been
// closed by a RST.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(seqnum.Size(len(data))),
AckNum: c.IRS.Add(seqnum.Size(2)),
RcvWnd: 30000,
})
}
func TestShutdownRead(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
if err := c.EP.Shutdown(tcpip.ShutdownRead); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
ept.CheckReadError(t, &tcpip.ErrClosedForReceive{})
var want uint64 = 1
if got := c.EP.Stats().(*tcp.Stats).ReadErrors.ReadClosed.Value(); got != want {
t.Fatalf("got EP stats Stats.ReadErrors.ReadClosed got %d want %d", got, want)
}
}
func TestFullWindowReceive(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
const rcvBufSz = 10
c.CreateConnected(context.TestInitialSequenceNumber, 30000, rcvBufSz)
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
// Fill up the window w/ tcp.SegOverheadFactor*rcvBufSz as netstack multiplies
// the provided buffer value by tcp.SegOverheadFactor to calculate the actual
// receive buffer size.
data := make([]byte, tcp.SegOverheadFactor*rcvBufSz)
for i := range data {
data[i] = byte(i % 255)
}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Wait for receive to be notified.
select {
case <-ch:
case <-time.After(5 * time.Second):
t.Fatalf("Timed out waiting for data to arrive")
}
// Check that data is acknowledged, and window goes to zero.
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(len(data))),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPWindow(0),
),
)
// Receive data and check it.
v := ept.CheckRead(t)
if !bytes.Equal(data, v) {
t.Fatalf("got data = %v, want = %v", v, data)
}
var want uint64 = 1
if got := c.EP.Stats().(*tcp.Stats).ReceiveErrors.ZeroRcvWindowState.Value(); got != want {
t.Fatalf("got EP stats ReceiveErrors.ZeroRcvWindowState got %d want %d", got, want)
}
// Check that we get an ACK for the newly non-zero window.
b = c.GetPacket()
defer b.Release()
checker.IPv4(t, b, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(len(data))),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPWindow(10),
),
)
}
func TestSmallReceiveBufferReadiness(t *testing.T) {
s := stack.New(stack.Options{
NetworkProtocols: []stack.NetworkProtocolFactory{ipv4.NewProtocol},
TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol},
})
defer s.Destroy()
ep := loopback.New()
if testing.Verbose() {
ep = sniffer.New(ep)
}
const nicID = 1
nicOpts := stack.NICOptions{Name: "nic1"}
if err := s.CreateNICWithOptions(nicID, ep, nicOpts); err != nil {
t.Fatalf("CreateNICWithOptions(_, _, %+v) failed: %s", nicOpts, err)
}
protocolAddr := tcpip.ProtocolAddress{
Protocol: ipv4.ProtocolNumber,
AddressWithPrefix: tcpip.AddressWithPrefix{
Address: tcpip.AddrFromSlice([]byte("\x7f\x00\x00\x01")),
PrefixLen: 32,
},
}
if err := s.AddProtocolAddress(nicID, protocolAddr, stack.AddressProperties{}); err != nil {
t.Fatalf("AddProtocolAddress(%d, %+v, {}) failed: %s", nicID, protocolAddr, err)
}
{
subnet, err := tcpip.NewSubnet(tcpip.AddrFromSlice([]byte("\x7f\x00\x00\x00")), tcpip.MaskFrom("\xff\x00\x00\x00"))
if err != nil {
t.Fatalf("tcpip.NewSubnet failed: %s", err)
}
s.SetRouteTable([]tcpip.Route{
{
Destination: subnet,
NIC: nicID,
},
})
}
listenerEntry, listenerCh := waiter.NewChannelEntry(waiter.ReadableEvents)
var listenerWQ waiter.Queue
listener, err := s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &listenerWQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer listener.Close()
listenerWQ.EventRegister(&listenerEntry)
defer listenerWQ.EventUnregister(&listenerEntry)
if err := listener.Bind(tcpip.FullAddress{}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := listener.Listen(1); err != nil {
t.Fatalf("Bind failed: %s", err)
}
localAddress, err := listener.GetLocalAddress()
if err != nil {
t.Fatalf("GetLocalAddress failed: %s", err)
}
for i := 8; i > 0; i /= 2 {
size := int64(i << 12)
t.Run(fmt.Sprintf("size=%d", size), func(t *testing.T) {
var clientWQ waiter.Queue
client, err := s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &clientWQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer client.Close()
switch err := client.Connect(localAddress).(type) {
case nil:
t.Fatal("Connect returned nil error")
case *tcpip.ErrConnectStarted:
default:
t.Fatalf("Connect failed: %s", err)
}
<-listenerCh
server, serverWQ, err := listener.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
defer server.Close()
client.SocketOptions().SetReceiveBufferSize(size, true)
// Send buffer size doesn't seem to affect this test.
// server.SocketOptions().SetSendBufferSize(size, true)
clientEntry, clientCh := waiter.NewChannelEntry(waiter.ReadableEvents)
clientWQ.EventRegister(&clientEntry)
defer clientWQ.EventUnregister(&clientEntry)
serverEntry, serverCh := waiter.NewChannelEntry(waiter.WritableEvents)
serverWQ.EventRegister(&serverEntry)
defer serverWQ.EventUnregister(&serverEntry)
var total int64
for {
var b [64 << 10]byte
var r bytes.Reader
r.Reset(b[:])
switch n, err := server.Write(&r, tcpip.WriteOptions{}); err.(type) {
case nil:
t.Logf("wrote %d bytes", n)
total += n
continue
case *tcpip.ErrWouldBlock:
select {
case <-serverCh:
continue
case <-time.After(100 * time.Millisecond):
// Well and truly full.
t.Logf("send and receive queues are full")
}
default:
t.Fatalf("Write failed: %s", err)
}
break
}
t.Logf("wrote %d bytes in total", total)
var wg sync.WaitGroup
defer wg.Wait()
wg.Add(2)
go func() {
defer wg.Done()
var b [64 << 10]byte
var r bytes.Reader
r.Reset(b[:])
if err := func() error {
var total int64
defer t.Logf("wrote %d bytes in total", total)
for r.Len() != 0 {
switch n, err := server.Write(&r, tcpip.WriteOptions{}); err.(type) {
case nil:
t.Logf("wrote %d bytes", n)
total += n
case *tcpip.ErrWouldBlock:
for {
t.Logf("waiting on server")
select {
case <-serverCh:
case <-time.After(time.Second):
if readiness := server.Readiness(waiter.WritableEvents); readiness != 0 {
t.Logf("server.Readiness(%b) = %b but channel not signaled", waiter.WritableEvents, readiness)
}
continue
}
break
}
default:
return fmt.Errorf("server.Write failed: %s", err)
}
}
if err := server.Shutdown(tcpip.ShutdownWrite); err != nil {
return fmt.Errorf("server.Shutdown failed: %s", err)
}
t.Logf("server end shutdown done")
return nil
}(); err != nil {
t.Error(err)
}
}()
go func() {
defer wg.Done()
if err := func() error {
total := 0
defer t.Logf("read %d bytes in total", total)
for {
switch res, err := client.Read(ioutil.Discard, tcpip.ReadOptions{}); err.(type) {
case nil:
t.Logf("read %d bytes", res.Count)
total += res.Count
t.Logf("read total %d bytes till now", total)
case *tcpip.ErrClosedForReceive:
return nil
case *tcpip.ErrWouldBlock:
for {
t.Logf("waiting on client")
select {
case <-clientCh:
case <-time.After(time.Second):
if readiness := client.Readiness(waiter.ReadableEvents); readiness != 0 {
return fmt.Errorf("client.Readiness(%b) = %b but channel not signaled", waiter.ReadableEvents, readiness)
}
continue
}
break
}
default:
return fmt.Errorf("client.Write failed: %s", err)
}
}
}(); err != nil {
t.Error(err)
}
}()
})
}
}
// Test the stack receive window advertisement on receiving segments smaller than
// segment overhead. It tests for the right edge of the window to not grow when
// the endpoint is not being read from.
func TestSmallSegReceiveWindowAdvertisement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
opt := tcpip.TCPReceiveBufferSizeRangeOption{
Min: 1,
Default: tcp.DefaultReceiveBufferSize,
Max: tcp.DefaultReceiveBufferSize << tcp.FindWndScale(seqnum.Size(tcp.DefaultReceiveBufferSize)),
}
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%#v): %s", tcp.ProtocolNumber, opt, err)
}
c.AcceptWithOptionsNoDelay(tcp.FindWndScale(seqnum.Size(opt.Default)), header.TCPSynOptions{MSS: e2e.DefaultIPv4MSS})
// Bump up the receive buffer size such that, when the receive window grows,
// the scaled window exceeds maxUint16.
c.EP.SocketOptions().SetReceiveBufferSize(int64(opt.Max)*2, true /* notify */)
// Keep the payload size < segment overhead and such that it is a multiple
// of the window scaled value. This enables the test to perform equality
// checks on the incoming receive window.
payloadSize := 1 << c.RcvdWindowScale
if payloadSize >= tcp.SegOverheadSize {
t.Fatalf("payload size of %d is not less than the segment overhead of %d", payloadSize, tcp.SegOverheadSize)
}
payload := generateRandomPayload(t, payloadSize)
payloadLen := seqnum.Size(len(payload))
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
// Send payload to the endpoint and return the advertised receive window
// from the endpoint.
getIncomingRcvWnd := func() uint32 {
c.SendPacket(payload, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
SeqNum: iss,
AckNum: c.IRS.Add(1),
Flags: header.TCPFlagAck,
RcvWnd: 30000,
})
iss = iss.Add(payloadLen)
pkt := c.GetPacket()
defer pkt.Release()
return uint32(header.TCP(header.IPv4(pkt.AsSlice()).Payload()).WindowSize()) << c.RcvdWindowScale
}
// Read the advertised receive window with the ACK for payload.
rcvWnd := getIncomingRcvWnd()
// Check if the subsequent ACK to our send has not grown the right edge of
// the window.
if got, want := getIncomingRcvWnd(), rcvWnd-uint32(len(payload)); got != want {
t.Fatalf("got incomingRcvwnd %d want %d", got, want)
}
// Read the data so that the subsequent ACK from the endpoint
// grows the right edge of the window.
var buf bytes.Buffer
if _, err := c.EP.Read(&buf, tcpip.ReadOptions{}); err != nil {
t.Fatalf("c.EP.Read: %s", err)
}
// Check if we have received max uint16 as our advertised
// scaled window now after a read above.
maxRcv := uint32(math.MaxUint16 << c.RcvdWindowScale)
if got, want := getIncomingRcvWnd(), maxRcv; got != want {
t.Fatalf("got incomingRcvwnd %d want %d", got, want)
}
// Check if the subsequent ACK to our send has not grown the right edge of
// the window.
if got, want := getIncomingRcvWnd(), maxRcv-uint32(len(payload)); got != want {
t.Fatalf("got incomingRcvwnd %d want %d", got, want)
}
}
func TestNoWindowShrinking(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Start off with a certain receive buffer then cut it in half and verify that
// the right edge of the window does not shrink.
// NOTE: Netstack doubles the value specified here.
rcvBufSize := 65536
// Enable window scaling with a scale of zero from our end.
c.CreateConnectedWithRawOptions(context.TestInitialSequenceNumber, 30000, rcvBufSize, []byte{
header.TCPOptionWS, 3, 0, header.TCPOptionNOP,
})
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
// Send a 1 byte payload so that we can record the current receive window.
// Send a payload of half the size of rcvBufSize.
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
payload := []byte{1}
c.SendPacket(payload, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Wait for receive to be notified.
select {
case <-ch:
case <-time.After(5 * time.Second):
t.Fatalf("Timed out waiting for data to arrive")
}
// Read the 1 byte payload we just sent.
if got, want := payload, ept.CheckRead(t); !bytes.Equal(got, want) {
t.Fatalf("got data: %v, want: %v", got, want)
}
// Verify that the ACK does not shrink the window.
pkt := c.GetPacket()
defer pkt.Release()
iss = iss.Add(1)
checker.IPv4(t, pkt,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Stash the initial window.
initialWnd := header.TCP(header.IPv4(pkt.AsSlice()).Payload()).WindowSize() << c.RcvdWindowScale
initialLastAcceptableSeq := iss.Add(seqnum.Size(initialWnd))
// Now shrink the receive buffer to half its original size.
c.EP.SocketOptions().SetReceiveBufferSize(int64(rcvBufSize), true /* notify */)
data := generateRandomPayload(t, rcvBufSize)
// Send a payload of half the size of rcvBufSize.
c.SendPacket(data[:rcvBufSize/2], &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
iss = iss.Add(seqnum.Size(rcvBufSize / 2))
// Verify that the ACK does not shrink the window.
pkt = c.GetPacket()
defer pkt.Release()
checker.IPv4(t, pkt,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
),
)
newWnd := header.TCP(header.IPv4(pkt.AsSlice()).Payload()).WindowSize() << c.RcvdWindowScale
newLastAcceptableSeq := iss.Add(seqnum.Size(newWnd))
if newLastAcceptableSeq.LessThan(initialLastAcceptableSeq) {
t.Fatalf("receive window shrunk unexpectedly got: %d, want >= %d", newLastAcceptableSeq, initialLastAcceptableSeq)
}
// Send another payload of half the size of rcvBufSize. This should fill up the
// socket receive buffer and we should see a zero window.
c.SendPacket(data[rcvBufSize/2:], &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
iss = iss.Add(seqnum.Size(rcvBufSize / 2))
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPWindow(0),
),
)
// Receive data and check it.
read := ept.CheckReadFull(t, len(data), ch, 5*time.Second)
if !bytes.Equal(data, read) {
t.Fatalf("got data = %v, want = %v", read, data)
}
// Check that we get an ACK for the newly non-zero window, which is the new
// receive buffer size we set after the connection was established.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPWindow(uint16(rcvBufSize/2)>>c.RcvdWindowScale),
),
)
}
func TestSimpleSend(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that data is received.
b := c.GetPacket()
defer b.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv4(t, b,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
if p := b.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:]; !bytes.Equal(data, p) {
t.Fatalf("got data = %v, want = %v", p, data)
}
// Acknowledge the data.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1 + seqnum.Size(len(data))),
RcvWnd: 30000,
})
}
func TestZeroWindowSend(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 0 /* rcvWnd */, -1 /* epRcvBuf */)
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check if we got a zero-window probe.
b := c.GetPacket()
defer b.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv4(t, b,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
// Open up the window. Data should be received now.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Check that data is received.
b = c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
if p := b.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:]; !bytes.Equal(data, p) {
t.Fatalf("got data = %v, want = %v", p, data)
}
// Acknowledge the data.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1 + seqnum.Size(len(data))),
RcvWnd: 30000,
})
}
func TestScaledWindowConnect(t *testing.T) {
// This test ensures that window scaling is used when the peer
// does advertise it and connection is established with Connect().
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set the window size greater than the maximum non-scaled window.
c.CreateConnectedWithRawOptions(context.TestInitialSequenceNumber, 30000, 65535*3, []byte{
header.TCPOptionWS, 3, 0, header.TCPOptionNOP,
})
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that data is received, and that advertised window is 0x5fff,
// that is, that it is scaled.
b := c.GetPacket()
defer b.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv4(t, b,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPWindow(0x5fff),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
}
func TestNonScaledWindowConnect(t *testing.T) {
// This test ensures that window scaling is not used when the peer
// doesn't advertise it and connection is established with Connect().
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set the window size greater than the maximum non-scaled window.
c.CreateConnected(context.TestInitialSequenceNumber, 30000, 65535*3)
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that data is received, and that advertised window is 0xffff,
// that is, that it's not scaled.
b := c.GetPacket()
defer b.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv4(t, b,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPWindow(0xffff),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
}
func TestScaledWindowAccept(t *testing.T) {
// This test ensures that window scaling is used when the peer
// does advertise it and connection is established with Accept().
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create EP and start listening.
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer ep.Close()
// Set the window size greater than the maximum non-scaled window.
ep.SocketOptions().SetReceiveBufferSize(65535*6, true /* notify */)
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Do 3-way handshake.
// wndScale expected is 3 as 65535 * 3 * 2 < 65535 * 2^3 but > 65535 *2 *2
c.PassiveConnectWithOptions(100, 3 /* wndScale */, header.TCPSynOptions{MSS: e2e.DefaultIPv4MSS}, 0 /* delay */)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that data is received, and that advertised window is 0x5fff,
// that is, that it is scaled.
b := c.GetPacket()
defer b.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv4(t, b,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPWindow(0x5fff),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
}
func TestNonScaledWindowAccept(t *testing.T) {
// This test ensures that window scaling is not used when the peer
// doesn't advertise it and connection is established with Accept().
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create EP and start listening.
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer ep.Close()
// Set the window size greater than the maximum non-scaled window.
ep.SocketOptions().SetReceiveBufferSize(65535*6, true /* notify */)
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Do 3-way handshake w/ window scaling disabled. The SYN-ACK to the SYN
// should not carry the window scaling option.
c.PassiveConnect(100, -1, header.TCPSynOptions{MSS: e2e.DefaultIPv4MSS})
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that data is received, and that advertised window is 0xffff,
// that is, that it's not scaled.
b := c.GetPacket()
defer b.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv4(t, b,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPWindow(0xffff),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
}
func TestZeroScaledWindowReceive(t *testing.T) {
// This test ensures that the endpoint sends a non-zero window size
// advertisement when the scaled window transitions from 0 to non-zero,
// but the actual window (not scaled) hasn't gotten to zero.
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set the buffer size such that a window scale of 5 will be used.
const bufSz = 65535 * 10
const ws = uint32(5)
c.CreateConnectedWithRawOptions(context.TestInitialSequenceNumber, 30000, bufSz, []byte{
header.TCPOptionWS, 3, 0, header.TCPOptionNOP,
})
// Write chunks of 50000 bytes.
remain := 0
sent := 0
data := make([]byte, 50000)
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
// Keep writing till the window drops below len(data).
for {
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(seqnum.Size(sent)),
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
sent += len(data)
pkt := c.GetPacket()
defer pkt.Release()
checker.IPv4(t, pkt,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(sent)),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Don't reduce window to zero here.
if wnd := int(header.TCP(header.IPv4(pkt.AsSlice()).Payload()).WindowSize()); wnd<<ws < len(data) {
remain = wnd << ws
break
}
}
// Make the window non-zero, but the scaled window zero.
for remain >= 16 {
data = data[:remain-15]
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(seqnum.Size(sent)),
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
sent += len(data)
pkt := c.GetPacket()
defer pkt.Release()
checker.IPv4(t, pkt,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(sent)),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Since the receive buffer is split between window advertisement and
// application data buffer the window does not always reflect the space
// available and actual space available can be a bit more than what is
// advertised in the window.
wnd := int(header.TCP(header.IPv4(pkt.AsSlice()).Payload()).WindowSize())
if wnd == 0 {
break
}
remain = wnd << ws
}
// Read at least 2MSS of data. An ack should be sent in response to that.
// Since buffer space is now split in half between window and application
// data we need to read more than 1 MSS(65536) of data for a non-zero window
// update to be sent. For 1MSS worth of window to be available we need to
// read at least 128KB. Since our segments above were 50KB each it means
// we need to read at 3 packets.
w := tcpip.LimitedWriter{
W: ioutil.Discard,
N: e2e.DefaultMTU * 2,
}
for w.N != 0 {
res, err := c.EP.Read(&w, tcpip.ReadOptions{})
t.Logf("err=%v res=%#v", err, res)
if err != nil {
t.Fatalf("Read failed: %s", err)
}
}
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(sent)),
checker.TCPWindowGreaterThanEq(uint16(e2e.DefaultMTU>>ws)),
checker.TCPFlags(header.TCPFlagAck),
))
}
func TestSegmentMerging(t *testing.T) {
tests := []struct {
name string
stop func(tcpip.Endpoint)
resume func(tcpip.Endpoint)
}{
{
"stop work",
func(ep tcpip.Endpoint) {
ep.(interface{ StopWork() }).StopWork()
},
func(ep tcpip.Endpoint) {
ep.(interface{ ResumeWork() }).ResumeWork()
},
},
{
"cork",
func(ep tcpip.Endpoint) {
ep.SocketOptions().SetCorkOption(true)
},
func(ep tcpip.Endpoint) {
ep.SocketOptions().SetCorkOption(false)
},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Send tcp.InitialCwnd number of segments to fill up
// InitialWindow but don't ACK. That should prevent
// anymore packets from going out.
var r bytes.Reader
for i := 0; i < tcp.InitialCwnd; i++ {
r.Reset([]byte{0})
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write #%d failed: %s", i+1, err)
}
}
// Now send the segments that should get merged as the congestion
// window is full and we won't be able to send any more packets.
var allData []byte
for i, data := range [][]byte{{1, 2, 3, 4}, {5, 6, 7}, {8, 9}, {10}, {11}} {
allData = append(allData, data...)
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write #%d failed: %s", i+1, err)
}
}
// Check that we get tcp.InitialCwnd packets.
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for i := 0; i < tcp.InitialCwnd; i++ {
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(header.TCPMinimumSize+1),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+uint32(i)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
}
// Acknowledge the data.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1 + 10), // 10 for the 10 bytes of payload.
RcvWnd: 30000,
})
// Check that data is received.
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(len(allData)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+11),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
if got := b.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:]; !bytes.Equal(got, allData) {
t.Fatalf("got data = %v, want = %v", got, allData)
}
// Acknowledge the data.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(11 + seqnum.Size(len(allData))),
RcvWnd: 30000,
})
})
}
}
func TestDelay(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
c.EP.SocketOptions().SetDelayOption(true)
var allData []byte
for i, data := range [][]byte{{0}, {1, 2, 3, 4}, {5, 6, 7}, {8, 9}, {10}, {11}} {
allData = append(allData, data...)
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write #%d failed: %s", i+1, err)
}
}
seq := c.IRS.Add(1)
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for _, want := range [][]byte{allData[:1], allData[1:]} {
// Check that data is received.
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(len(want)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(seq)),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
if got := b.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:]; !bytes.Equal(got, want) {
t.Fatalf("got data = %v, want = %v", got, want)
}
seq = seq.Add(seqnum.Size(len(want)))
// Acknowledge the data.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seq,
RcvWnd: 30000,
})
}
}
func TestUndelay(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
c.EP.SocketOptions().SetDelayOption(true)
allData := [][]byte{{0}, {1, 2, 3}}
for i, data := range allData {
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write #%d failed: %s", i+1, err)
}
}
seq := c.IRS.Add(1)
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
// Check that data is received.
first := c.GetPacket()
defer first.Release()
checker.IPv4(t, first,
checker.PayloadLen(len(allData[0])+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(seq)),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
if got, want := first.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:], allData[0]; !bytes.Equal(got, want) {
t.Fatalf("got first packet's data = %v, want = %v", got, want)
}
seq = seq.Add(seqnum.Size(len(allData[0])))
// Check that we don't get the second packet yet.
c.CheckNoPacketTimeout("delayed second packet transmitted", 100*time.Millisecond)
c.EP.SocketOptions().SetDelayOption(false)
// Check that data is received.
second := c.GetPacket()
defer second.Release()
checker.IPv4(t, second,
checker.PayloadLen(len(allData[1])+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(seq)),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
if got, want := second.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:], allData[1]; !bytes.Equal(got, want) {
t.Fatalf("got second packet's data = %v, want = %v", got, want)
}
seq = seq.Add(seqnum.Size(len(allData[1])))
// Acknowledge the data.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seq,
RcvWnd: 30000,
})
}
func TestMSSNotDelayed(t *testing.T) {
tests := []struct {
name string
fn func(tcpip.Endpoint)
}{
{"no-op", func(tcpip.Endpoint) {}},
{"delay", func(ep tcpip.Endpoint) { ep.SocketOptions().SetDelayOption(true) }},
{"cork", func(ep tcpip.Endpoint) { ep.SocketOptions().SetCorkOption(true) }},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
const maxPayload = 100
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnectedWithRawOptions(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */, []byte{
header.TCPOptionMSS, 4, byte(maxPayload / 256), byte(maxPayload % 256),
})
test.fn(c.EP)
allData := [][]byte{{0}, make([]byte, maxPayload), make([]byte, maxPayload)}
for i, data := range allData {
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write #%d failed: %s", i+1, err)
}
}
seq := c.IRS.Add(1)
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for i, data := range allData {
// Check that data is received.
packet := c.GetPacket()
defer packet.Release()
checker.IPv4(t, packet,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(seq)),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
if got, want := packet.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:], data; !bytes.Equal(got, want) {
t.Fatalf("got packet #%d's data = %v, want = %v", i+1, got, want)
}
seq = seq.Add(seqnum.Size(len(data)))
}
// Acknowledge the data.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seq,
RcvWnd: 30000,
})
})
}
}
func TestSendGreaterThanMTU(t *testing.T) {
const maxPayload = 100
c := context.New(t, uint32(header.TCPMinimumSize+header.IPv4MinimumSize+maxPayload))
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
e2e.CheckBrokenUpWrite(t, c, maxPayload)
}
func TestDefaultTTL(t *testing.T) {
for _, test := range []struct {
name string
protoNum tcpip.NetworkProtocolNumber
addr tcpip.Address
}{
{"ipv4", ipv4.ProtocolNumber, context.TestAddr},
{"ipv6", ipv6.ProtocolNumber, context.TestV6Addr},
} {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, 65535)
defer c.Cleanup()
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, test.protoNum, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
proto := c.Stack().NetworkProtocolInstance(test.protoNum)
if proto == nil {
t.Fatalf("c.s.NetworkProtocolInstance(flow.netProto()) did not return a protocol")
}
var initialDefaultTTL tcpip.DefaultTTLOption
if err := proto.Option(&initialDefaultTTL); err != nil {
t.Fatalf("proto.Option(&initialDefaultTTL) (%T) failed: %s", initialDefaultTTL, err)
}
{
err := c.EP.Connect(tcpip.FullAddress{Addr: test.addr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("c.EP.Connect(...) mismatch (-want +got):\n%s", d)
}
}
checkTTL := func(ttl uint8) {
if test.protoNum == ipv4.ProtocolNumber {
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TTL(ttl))
} else {
v := c.GetV6Packet()
defer v.Release()
checker.IPv6(t, v, checker.TTL(ttl))
}
}
// Receive SYN packet.
checkTTL(uint8(initialDefaultTTL))
newDefaultTTL := tcpip.DefaultTTLOption(initialDefaultTTL + 1)
if err := proto.SetOption(&newDefaultTTL); err != nil {
t.Fatalf("proto.SetOption(&%T(%d))) failed: %s", newDefaultTTL, newDefaultTTL, err)
}
// Receive retransmitted SYN packet.
checkTTL(uint8(newDefaultTTL))
})
}
}
func TestSetTTL(t *testing.T) {
for _, test := range []struct {
name string
protoNum tcpip.NetworkProtocolNumber
addr tcpip.Address
relevantOpt tcpip.SockOptInt
irrelevantOpt tcpip.SockOptInt
}{
{"ipv4", ipv4.ProtocolNumber, context.TestAddr, tcpip.IPv4TTLOption, tcpip.IPv6HopLimitOption},
{"ipv6", ipv6.ProtocolNumber, context.TestV6Addr, tcpip.IPv6HopLimitOption, tcpip.IPv4TTLOption},
} {
t.Run(test.name, func(t *testing.T) {
for _, wantTTL := range []uint8{1, 2, 50, 64, 128, 254, 255} {
t.Run(fmt.Sprintf("TTL:%d", wantTTL), func(t *testing.T) {
c := context.New(t, 65535)
defer c.Cleanup()
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, test.protoNum, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := c.EP.SetSockOptInt(test.relevantOpt, int(wantTTL)); err != nil {
t.Fatalf("SetSockOptInt(%d, %d) failed: %s", test.relevantOpt, wantTTL, err)
}
// Set a different ttl/hoplimit for the unused protocol, showing that
// it does not affect the other protocol.
if err := c.EP.SetSockOptInt(test.irrelevantOpt, int(wantTTL+1)); err != nil {
t.Fatalf("SetSockOptInt(%d, %d) failed: %s", test.irrelevantOpt, wantTTL, err)
}
{
err := c.EP.Connect(tcpip.FullAddress{Addr: test.addr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("c.EP.Connect(...) mismatch (-want +got):\n%s", d)
}
}
// Receive SYN packet.
if test.protoNum == ipv4.ProtocolNumber {
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TTL(wantTTL))
} else {
v := c.GetV6Packet()
defer v.Release()
checker.IPv6(t, v, checker.TTL(wantTTL))
}
})
}
})
}
}
func TestSendMSSLessThanOptionsSize(t *testing.T) {
const mss = 10
const writeSize = 300
c := context.New(t, 65535)
defer c.Cleanup()
// The sizes of these options add up to 12.
c.CreateConnectedWithRawOptions(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */, []byte{
header.TCPOptionMSS, 4, byte(mss / 256), byte(mss % 256),
header.TCPOptionTS, header.TCPOptionTSLength, 1, 2, 3, 4, 5, 6, 7, 8,
header.TCPOptionSACKPermitted, header.TCPOptionSackPermittedLength,
})
e2e.CheckBrokenUpWrite(t, c, writeSize)
var r bytes.Reader
r.Reset(make([]byte, writeSize))
_, err := c.EP.Write(&r, tcpip.WriteOptions{})
if err != nil {
t.Fatalf("Write failed: %s", err)
}
}
func TestActiveSendMSSLessThanMTU(t *testing.T) {
const maxPayload = 100
c := context.New(t, 65535)
defer c.Cleanup()
c.CreateConnectedWithRawOptions(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */, []byte{
header.TCPOptionMSS, 4, byte(maxPayload / 256), byte(maxPayload % 256),
})
e2e.CheckBrokenUpWrite(t, c, maxPayload)
}
func TestPassiveSendMSSLessThanMTU(t *testing.T) {
const maxPayload = 100
const mtu = 1200
c := context.New(t, mtu)
defer c.Cleanup()
// Create EP and start listening.
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer ep.Close()
// Set the buffer size to a deterministic size so that we can check the
// window scaling option.
const rcvBufferSize = 0x20000
ep.SocketOptions().SetReceiveBufferSize(rcvBufferSize*2, true /* notify */)
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Do 3-way handshake.
c.PassiveConnect(maxPayload, -1, header.TCPSynOptions{MSS: mtu - header.IPv4MinimumSize - header.TCPMinimumSize})
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
// Check that data gets properly segmented.
e2e.CheckBrokenUpWrite(t, c, maxPayload)
}
func TestSynCookiePassiveSendMSSLessThanMTU(t *testing.T) {
const maxPayload = 536
const mtu = 2000
c := context.New(t, mtu)
defer c.Cleanup()
opt := tcpip.TCPAlwaysUseSynCookies(true)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %s", tcp.ProtocolNumber, opt, opt, err)
}
// Create EP and start listening.
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer ep.Close()
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Do 3-way handshake.
c.PassiveConnect(maxPayload, -1, header.TCPSynOptions{MSS: mtu - header.IPv4MinimumSize - header.TCPMinimumSize})
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
// Check that data gets properly segmented.
e2e.CheckBrokenUpWrite(t, c, maxPayload)
}
func TestSynOptionsOnActiveConnect(t *testing.T) {
const mtu = 1400
c := context.New(t, mtu)
defer c.Cleanup()
// Create TCP endpoint.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
// Set the buffer size to a deterministic size so that we can check the
// window scaling option.
const rcvBufferSize = 0x20000
const wndScale = 3
c.EP.SocketOptions().SetReceiveBufferSize(rcvBufferSize*2, true /* notify */)
// Start connection attempt.
we, ch := waiter.NewChannelEntry(waiter.WritableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
{
err := c.EP.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("c.EP.Connect(...) mismatch (-want +got):\n%s", d)
}
}
// Receive SYN packet.
b := c.GetPacket()
defer b.Release()
mss := uint16(mtu - header.IPv4MinimumSize - header.TCPMinimumSize)
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagSyn),
checker.TCPSynOptions(header.TCPSynOptions{MSS: mss, WS: wndScale}),
),
)
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
// Wait for retransmit.
time.Sleep(1 * time.Second)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagSyn),
checker.SrcPort(tcpHdr.SourcePort()),
checker.TCPSeqNum(tcpHdr.SequenceNumber()),
checker.TCPSynOptions(header.TCPSynOptions{MSS: mss, WS: wndScale}),
),
)
// Send SYN-ACK.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: tcpHdr.DestinationPort(),
DstPort: tcpHdr.SourcePort(),
Flags: header.TCPFlagSyn | header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
// Receive ACK packet.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+1),
),
)
// Wait for connection to be established.
select {
case <-ch:
if err := c.EP.LastError(); err != nil {
t.Fatalf("Connect failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for connection")
}
}
func TestCloseListener(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create listener.
var wq waiter.Queue
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Close the listener and measure how long it takes.
t0 := time.Now()
ep.Close()
if diff := time.Now().Sub(t0); diff > 3*time.Second {
t.Fatalf("Took too long to close: %s", diff)
}
}
func TestReceiveOnResetConnection(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
// Send RST segment.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagRst,
SeqNum: iss,
RcvWnd: 30000,
})
// Try to read.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
loop:
for {
switch _, err := c.EP.Read(ioutil.Discard, tcpip.ReadOptions{}); err.(type) {
case *tcpip.ErrWouldBlock:
<-ch
// Expect the state to be StateError and subsequent Reads to fail with HardError.
_, err := c.EP.Read(ioutil.Discard, tcpip.ReadOptions{})
if d := cmp.Diff(&tcpip.ErrConnectionReset{}, err); d != "" {
t.Fatalf("c.EP.Read() mismatch (-want +got):\n%s", d)
}
break loop
case *tcpip.ErrConnectionReset:
break loop
default:
t.Fatalf("got c.EP.Read(nil) = %v, want = %s", err, &tcpip.ErrConnectionReset{})
}
}
if tcp.EndpointState(c.EP.State()) != tcp.StateError {
t.Fatalf("got EP state is not StateError")
}
checkValid := func() []error {
var errors []error
if got := c.Stack().Stats().TCP.EstablishedResets.Value(); got != 1 {
errors = append(errors, fmt.Errorf("got stats.TCP.EstablishedResets.Value() = %d, want = 1", got))
}
if got := c.Stack().Stats().TCP.CurrentEstablished.Value(); got != 0 {
errors = append(errors, fmt.Errorf("got stats.TCP.CurrentEstablished.Value() = %d, want = 0", got))
}
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != 0 {
errors = append(errors, fmt.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 0", got))
}
return errors
}
start := time.Now()
for time.Since(start) < time.Minute && len(checkValid()) > 0 {
time.Sleep(50 * time.Millisecond)
}
for _, err := range checkValid() {
t.Error(err)
}
}
func TestSendOnResetConnection(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Send RST segment.
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagRst,
SeqNum: iss,
RcvWnd: 30000,
})
// Wait for the RST to be received.
time.Sleep(1 * time.Second)
// Try to write.
var r bytes.Reader
r.Reset(make([]byte, 10))
_, err := c.EP.Write(&r, tcpip.WriteOptions{})
if d := cmp.Diff(&tcpip.ErrConnectionReset{}, err); d != "" {
t.Fatalf("c.EP.Write(...) mismatch (-want +got):\n%s", d)
}
}
// TestMaxRetransmitsTimeout tests if the connection is timed out after
// a segment has been retransmitted MaxRetries times.
func TestMaxRetransmitsTimeout(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
const numRetries = 2
opt := tcpip.TCPMaxRetriesOption(numRetries)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, opt, opt, err)
}
// Wait for the connection to timeout after MaxRetries retransmits.
initRTO := time.Second
minRTOOpt := tcpip.TCPMinRTOOption(initRTO)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &minRTOOpt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, minRTOOpt, minRTOOpt, err)
}
c.CreateConnected(context.TestInitialSequenceNumber, 30000 /* rcvWnd */, -1 /* epRcvBuf */)
waitEntry, notifyCh := waiter.NewChannelEntry(waiter.EventHUp)
c.WQ.EventRegister(&waitEntry)
defer c.WQ.EventUnregister(&waitEntry)
var r bytes.Reader
r.Reset(make([]byte, 1))
_, err := c.EP.Write(&r, tcpip.WriteOptions{})
if err != nil {
t.Fatalf("Write failed: %s", err)
}
// Expect first transmit and MaxRetries retransmits.
for i := 0; i < numRetries+1; i++ {
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagPsh),
))
}
select {
case <-notifyCh:
case <-time.After((2 << numRetries) * initRTO):
t.Fatalf("connection still alive after maximum retransmits.\n")
}
// Send an ACK and expect a RST as the connection would have been closed.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
})
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagRst),
))
if got := c.Stack().Stats().TCP.EstablishedTimedout.Value(); got != 1 {
t.Errorf("got c.Stack().Stats().TCP.EstablishedTimedout.Value() = %d, want = 1", got)
}
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 0", got)
}
}
// TestMaxRTO tests if the retransmit interval caps to MaxRTO.
func TestMaxRTO(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
rto := 1 * time.Second
minRTOOpt := tcpip.TCPMinRTOOption(rto / 2)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &minRTOOpt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, minRTOOpt, minRTOOpt, err)
}
maxRTOOpt := tcpip.TCPMaxRTOOption(rto)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &maxRTOOpt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, maxRTOOpt, maxRTOOpt, err)
}
c.CreateConnected(context.TestInitialSequenceNumber, 30000 /* rcvWnd */, -1 /* epRcvBuf */)
var r bytes.Reader
r.Reset(make([]byte, 1))
_, err := c.EP.Write(&r, tcpip.WriteOptions{})
if err != nil {
t.Fatalf("Write failed: %s", err)
}
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
))
const numRetransmits = 2
for i := 0; i < numRetransmits; i++ {
start := time.Now()
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
))
if elapsed := time.Since(start); elapsed.Round(time.Second).Seconds() != rto.Seconds() {
newRto := float64(rto / time.Millisecond)
if i == 0 {
newRto /= 2
}
curRto := float64(elapsed.Round(time.Millisecond).Milliseconds())
if math.Abs(newRto-curRto) > 10 {
t.Errorf("Retransmit interval not capped to RTO(%v). %v", newRto, curRto)
}
}
}
}
// TestZeroSizedWriteRetransmit tests that a zero sized write should not
// result in a panic on an RTO as no segment should have been queued for
// a zero sized write.
func TestZeroSizedWriteRetransmit(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000 /* rcvWnd */, -1 /* epRcvBuf */)
var r bytes.Reader
_, err := c.EP.Write(&r, tcpip.WriteOptions{})
if err != nil {
t.Fatalf("Write failed: %s", err)
}
// Now do a non-zero sized write to trigger actual sending of data.
r.Reset(make([]byte, 1))
_, err = c.EP.Write(&r, tcpip.WriteOptions{})
if err != nil {
t.Fatalf("Write failed: %s", err)
}
// Do not ACK the packet and expect an original transmit and a
// retransmit. This should not cause a panic.
for i := 0; i < 2; i++ {
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
))
}
}
// TestRetransmitIPv4IDUniqueness tests that the IPv4 Identification field is
// unique on retransmits.
func TestRetransmitIPv4IDUniqueness(t *testing.T) {
for _, tc := range []struct {
name string
size int
}{
{"1Byte", 1},
{"512Bytes", 512},
} {
t.Run(tc.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
minRTOOpt := tcpip.TCPMinRTOOption(time.Second)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &minRTOOpt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, minRTOOpt, minRTOOpt, err)
}
c.CreateConnected(context.TestInitialSequenceNumber, 30000 /* rcvWnd */, -1 /* epRcvBuf */)
// Disabling PMTU discovery causes all packets sent from this socket to
// have DF=0. This needs to be done because the IPv4 ID uniqueness
// applies only to non-atomic IPv4 datagrams as defined in RFC 6864
// Section 4, and datagrams with DF=0 are non-atomic.
if err := c.EP.SetSockOptInt(tcpip.MTUDiscoverOption, tcpip.PMTUDiscoveryDont); err != nil {
t.Fatalf("disabling PMTU discovery via sockopt to force DF=0 failed: %s", err)
}
var r bytes.Reader
r.Reset(make([]byte, tc.size))
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
pkt := c.GetPacket()
defer pkt.Release()
checker.IPv4(t, pkt,
checker.FragmentFlags(0),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
idSet := map[uint16]struct{}{header.IPv4(pkt.AsSlice()).ID(): {}}
// Expect two retransmitted packets, and that all packets received have
// unique IPv4 ID values.
for i := 0; i <= 2; i++ {
pkt := c.GetPacket()
defer pkt.Release()
checker.IPv4(t, pkt,
checker.FragmentFlags(0),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
id := header.IPv4(pkt.AsSlice()).ID()
if _, exists := idSet[id]; exists {
t.Fatalf("duplicate IPv4 ID=%d found in retransmitted packet", id)
}
idSet[id] = struct{}{}
}
})
}
}
func TestFinImmediately(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Shutdown immediately, check that we get a FIN.
if err := c.EP.Shutdown(tcpip.ShutdownWrite); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
// Ack and send FIN as well.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss,
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
// Check that the stack acks the FIN.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+2),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestFinRetransmit(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Shutdown immediately, check that we get a FIN.
if err := c.EP.Shutdown(tcpip.ShutdownWrite); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
// Don't acknowledge yet. We should get a retransmit of the FIN.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
// Ack and send FIN as well.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss,
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
// Check that the stack acks the FIN.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+2),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestFinWithNoPendingData(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Write something out, and have it acknowledged.
view := make([]byte, 10)
var r bytes.Reader
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
next := uint32(c.IRS) + 1
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
next += uint32(len(view))
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
// Shutdown, check that we get a FIN.
if err := c.EP.Shutdown(tcpip.ShutdownWrite); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
next++
// Ack and send FIN as well.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
// Check that the stack acks the FIN.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestFinWithPendingDataCwndFull(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Write enough segments to fill the congestion window before ACK'ing
// any of them.
view := make([]byte, 10)
var r bytes.Reader
for i := tcp.InitialCwnd; i > 0; i-- {
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
}
next := uint32(c.IRS) + 1
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for i := tcp.InitialCwnd; i > 0; i-- {
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
next += uint32(len(view))
}
// Shutdown the connection, check that the FIN segment isn't sent
// because the congestion window doesn't allow it. Wait until a
// retransmit is received.
if err := c.EP.Shutdown(tcpip.ShutdownWrite); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
// Send the ACK that will allow the FIN to be sent as well.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
next++
// Send a FIN that acknowledges everything. Get an ACK back.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestFinWithPendingData(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Write something out, and acknowledge it to get cwnd to 2.
view := make([]byte, 10)
var r bytes.Reader
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
next := uint32(c.IRS) + 1
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
next += uint32(len(view))
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
// Write new data, but don't acknowledge it.
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
next += uint32(len(view))
// Shutdown the connection, check that we do get a FIN.
if err := c.EP.Shutdown(tcpip.ShutdownWrite); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
next++
// Send a FIN that acknowledges everything. Get an ACK back.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestFinWithPartialAck(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Write something out, and acknowledge it to get cwnd to 2. Also send
// FIN from the test side.
view := make([]byte, 10)
var r bytes.Reader
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
next := uint32(c.IRS) + 1
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
next += uint32(len(view))
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
// Check that we get an ACK for the fin.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
// Write new data, but don't acknowledge it.
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
next += uint32(len(view))
// Shutdown the connection, check that we do get a FIN.
if err := c.EP.Shutdown(tcpip.ShutdownWrite); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
next++
// Send an ACK for the data, but not for the FIN yet.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(1),
AckNum: seqnum.Value(next - 1),
RcvWnd: 30000,
})
// Check that we don't get a retransmit of the FIN.
c.CheckNoPacketTimeout("FIN retransmitted when data was ack'd", 100*time.Millisecond)
// Ack the FIN.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss.Add(1),
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
}
func TestUpdateListenBacklog(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create listener.
var wq waiter.Queue
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Update the backlog with another Listen() on the same endpoint.
if err := ep.Listen(20); err != nil {
t.Fatalf("Listen failed to update backlog: %s", err)
}
ep.Close()
}
func scaledSendWindow(t *testing.T, scale uint8) {
// This test ensures that the endpoint is using the right scaling by
// sending a buffer that is larger than the window size, and ensuring
// that the endpoint doesn't send more than allowed.
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
maxPayload := e2e.DefaultMTU - header.IPv4MinimumSize - header.TCPMinimumSize
c.CreateConnectedWithRawOptions(context.TestInitialSequenceNumber, 0, -1 /* epRcvBuf */, []byte{
header.TCPOptionMSS, 4, byte(maxPayload / 256), byte(maxPayload % 256),
header.TCPOptionWS, 3, scale, header.TCPOptionNOP,
})
// Open up the window with a scaled value.
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 1,
})
// Send some data. Check that it's capped by the window size.
view := make([]byte, 65535)
var r bytes.Reader
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that only data that fits in the scaled window is sent.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen((1<<scale)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
// Reset the connection to free resources.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagRst,
SeqNum: iss,
})
}
func TestScaledSendWindow(t *testing.T) {
for scale := uint8(0); scale <= 14; scale++ {
scaledSendWindow(t, scale)
}
}
func TestReceivedValidSegmentCountIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
stats := c.Stack().Stats()
want := stats.TCP.ValidSegmentsReceived.Value() + 1
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
if got := stats.TCP.ValidSegmentsReceived.Value(); got != want {
t.Errorf("got stats.TCP.ValidSegmentsReceived.Value() = %d, want = %d", got, want)
}
if got := c.EP.Stats().(*tcp.Stats).SegmentsReceived.Value(); got != want {
t.Errorf("got EP stats Stats.SegmentsReceived = %d, want = %d", got, want)
}
// Ensure there were no errors during handshake. If these stats have
// incremented, then the connection should not have been established.
if got := c.EP.Stats().(*tcp.Stats).SendErrors.NoRoute.Value(); got != 0 {
t.Errorf("got EP stats Stats.SendErrors.NoRoute = %d, want = %d", got, 0)
}
}
func TestReceivedInvalidSegmentCountIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
stats := c.Stack().Stats()
want := stats.TCP.InvalidSegmentsReceived.Value() + 1
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
buf := c.BuildSegment(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
defer buf.Release()
tcpbuf := buf.Flatten()
tcpbuf[header.IPv4MinimumSize+header.TCPDataOffset] = ((header.TCPMinimumSize - 1) / 4) << 4
segbuf := buffer.MakeWithData(tcpbuf)
c.SendSegment(segbuf)
if got := stats.TCP.InvalidSegmentsReceived.Value(); got != want {
t.Errorf("got stats.TCP.InvalidSegmentsReceived.Value() = %d, want = %d", got, want)
}
if got := c.EP.Stats().(*tcp.Stats).ReceiveErrors.MalformedPacketsReceived.Value(); got != want {
t.Errorf("got EP Stats.ReceiveErrors.MalformedPacketsReceived stats = %d, want = %d", got, want)
}
}
func TestReceivedIncorrectChecksumIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
stats := c.Stack().Stats()
want := stats.TCP.ChecksumErrors.Value() + 1
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
buf := c.BuildSegment([]byte{0x1, 0x2, 0x3}, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
defer buf.Release()
tcpbuf := buf.Flatten()
// Overwrite a byte in the payload which should cause checksum
// verification to fail.
tcpbuf[header.IPv4MinimumSize+((tcpbuf[header.IPv4MinimumSize+header.TCPDataOffset]>>4)*4)] = 0x4
segbuf := buffer.MakeWithData(tcpbuf)
defer segbuf.Release()
c.SendSegment(buffer.MakeWithData(tcpbuf))
if got := stats.TCP.ChecksumErrors.Value(); got != want {
t.Errorf("got stats.TCP.ChecksumErrors.Value() = %d, want = %d", got, want)
}
if got := c.EP.Stats().(*tcp.Stats).ReceiveErrors.ChecksumErrors.Value(); got != want {
t.Errorf("got EP stats Stats.ReceiveErrors.ChecksumErrors = %d, want = %d", got, want)
}
}
func TestReceivedSegmentQueuing(t *testing.T) {
// This test sends 200 segments containing a few bytes each to an
// endpoint and checks that they're all received and acknowledged by
// the endpoint, that is, that none of the segments are dropped by
// internal queues.
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
// Send 200 segments.
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
data := []byte{1, 2, 3}
for i := 0; i < 200; i++ {
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(seqnum.Size(i * len(data))),
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
}
// Receive ACKs for all segments.
last := iss.Add(seqnum.Size(200 * len(data)))
for {
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
ack := seqnum.Value(tcpHdr.AckNumber())
if ack == last {
break
}
if last.LessThan(ack) {
t.Fatalf("Acknowledge (%v) beyond the expected (%v)", ack, last)
}
}
}
func TestReadAfterClosedState(t *testing.T) {
// This test ensures that calling Read() or Peek() after the endpoint
// has transitioned to closedState still works if there is pending
// data. To transition to stateClosed without calling Close(), we must
// shutdown the send path and the peer must send its own FIN.
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set TCPTimeWaitTimeout to 1 seconds so that sockets are marked closed
// after 1 second in TIME_WAIT state.
tcpTimeWaitTimeout := 1 * time.Second
opt := tcpip.TCPTimeWaitTimeoutOption(tcpTimeWaitTimeout)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, opt, opt, err)
}
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
// Shutdown immediately for write, check that we get a FIN.
if err := c.EP.Shutdown(tcpip.ShutdownWrite); err != nil {
t.Fatalf("Shutdown failed: %s", err)
}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
),
)
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateFinWait1; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
// Send some data and acknowledge the FIN.
data := []byte{1, 2, 3}
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss,
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
// Check that ACK is received.
b = c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+2),
checker.TCPAckNum(uint32(iss)+uint32(len(data))+1),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Give the stack the chance to transition to closed state from
// TIME_WAIT.
time.Sleep(tcpTimeWaitTimeout * 2)
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateClose; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
// Wait for receive to be notified.
select {
case <-ch:
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for data to arrive")
}
// Check that peek works.
var peekBuf bytes.Buffer
res, err := c.EP.Read(&peekBuf, tcpip.ReadOptions{Peek: true})
if err != nil {
t.Fatalf("Peek failed: %s", err)
}
if got, want := res.Count, len(data); got != want {
t.Fatalf("res.Count = %d, want %d", got, want)
}
if !bytes.Equal(data, peekBuf.Bytes()) {
t.Fatalf("got data = %v, want = %v", peekBuf.Bytes(), data)
}
// Receive data.
v := ept.CheckRead(t)
if !bytes.Equal(data, v) {
t.Fatalf("got data = %v, want = %v", v, data)
}
// Now that we drained the queue, check that functions fail with the
// right error code.
ept.CheckReadError(t, &tcpip.ErrClosedForReceive{})
var buf bytes.Buffer
{
_, err := c.EP.Read(&buf, tcpip.ReadOptions{Peek: true})
if d := cmp.Diff(&tcpip.ErrClosedForReceive{}, err); d != "" {
t.Fatalf("c.EP.Read(_, {Peek: true}) mismatch (-want +got):\n%s", d)
}
}
}
func TestReusePort(t *testing.T) {
// This test ensures that ports are immediately available for reuse
// after Close on the endpoints using them returns.
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// First case, just an endpoint that was bound.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
c.EP.SocketOptions().SetReuseAddress(true)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
c.EP.Close()
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
c.EP.SocketOptions().SetReuseAddress(true)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
c.EP.Close()
// Second case, an endpoint that was bound and is connecting..
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
c.EP.SocketOptions().SetReuseAddress(true)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
{
err := c.EP.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("c.EP.Connect(...) mismatch (-want +got):\n%s", d)
}
}
c.EP.Close()
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
c.EP.SocketOptions().SetReuseAddress(true)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
c.EP.Close()
// Third case, an endpoint that was bound and is listening.
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
c.EP.SocketOptions().SetReuseAddress(true)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := c.EP.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
c.EP.Close()
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
c.EP.SocketOptions().SetReuseAddress(true)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := c.EP.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
}
func TestTimeWaitAssassination(t *testing.T) {
var wg sync.WaitGroup
defer wg.Wait()
// We need to run this test lots of times because it triggers a very rare race
// condition in segment processing.
initalTestPort := 1024
testRuns := 25
for port := initalTestPort; port < initalTestPort+testRuns; port++ {
wg.Add(1)
go func(port uint16) {
defer wg.Done()
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
twReuse := tcpip.TCPTimeWaitReuseOption(tcpip.TCPTimeWaitReuseGlobal)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &twReuse); err != nil {
t.Errorf("s.TransportProtocolOption(%v, %v) = %v", tcp.ProtocolNumber, &twReuse, err)
}
if err := c.Stack().SetPortRange(port, port); err != nil {
t.Errorf("got s.SetPortRange(%d, %d) = %s, want = nil", port, port, err)
}
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1)
c.EP.Close()
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(port),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagFin|header.TCPFlagAck)))
finHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: port,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss + 1,
AckNum: c.IRS + 2,
}
c.SendPacket(nil, finHeaders)
// c.EP is in TIME_WAIT. We must allow for a second to pass before the
// new endpoint is allowed to take over the old endpoint's binding.
time.Sleep(time.Second)
seq := iss + 1
ack := c.IRS + 2
var wg sync.WaitGroup
defer wg.Wait()
wg.Add(1)
go func() {
defer wg.Done()
// The new endpoint will take over the binding.
c.Create(-1)
timeout := time.After(5 * time.Second)
connect:
for {
select {
case <-timeout:
break connect
default:
err := c.EP.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort})
// It can take some extra time for the port to be available.
if _, ok := err.(*tcpip.ErrNoPortAvailable); ok {
continue connect
}
if _, ok := err.(*tcpip.ErrConnectStarted); !ok {
t.Errorf("Unexpected return value from Connect: %v", err)
}
break connect
}
}
}()
// If the new endpoint does not properly transition to connecting before
// taking over the port reservation, sending acks will cause the processor
// to panic 1-5% of the time.
for i := 0; i < 5; i++ {
wg.Add(1)
go func() {
defer wg.Done()
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: port,
Flags: header.TCPFlagAck,
SeqNum: seq,
AckNum: ack,
})
}()
}
}(uint16(port))
}
}
func checkRecvBufferSize(t *testing.T, ep tcpip.Endpoint, v int) {
t.Helper()
s := ep.SocketOptions().GetReceiveBufferSize()
if int(s) != v {
t.Fatalf("got receive buffer size = %d, want = %d", s, v)
}
}
func checkSendBufferSize(t *testing.T, ep tcpip.Endpoint, v int) {
t.Helper()
if s := ep.SocketOptions().GetSendBufferSize(); int(s) != v {
t.Fatalf("got send buffer size = %d, want = %d", s, v)
}
}
func TestDefaultBufferSizes(t *testing.T) {
s := stack.New(stack.Options{
NetworkProtocols: []stack.NetworkProtocolFactory{ipv4.NewProtocol},
TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol},
})
defer s.Destroy()
// Check the default values.
ep, err := s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
defer func() {
if ep != nil {
ep.Close()
}
}()
checkSendBufferSize(t, ep, tcp.DefaultSendBufferSize)
checkRecvBufferSize(t, ep, tcp.DefaultReceiveBufferSize)
// Change the default send buffer size.
{
opt := tcpip.TCPSendBufferSizeRangeOption{
Min: 1,
Default: tcp.DefaultSendBufferSize * 2,
Max: tcp.DefaultSendBufferSize * 20,
}
if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%#v): %s", tcp.ProtocolNumber, opt, err)
}
}
ep.Close()
ep, err = s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
checkSendBufferSize(t, ep, tcp.DefaultSendBufferSize*2)
checkRecvBufferSize(t, ep, tcp.DefaultReceiveBufferSize)
// Change the default receive buffer size.
{
opt := tcpip.TCPReceiveBufferSizeRangeOption{
Min: 1,
Default: tcp.DefaultReceiveBufferSize * 3,
Max: tcp.DefaultReceiveBufferSize * 30,
}
if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%#v): %s", tcp.ProtocolNumber, opt, err)
}
}
ep.Close()
ep, err = s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
checkSendBufferSize(t, ep, tcp.DefaultSendBufferSize*2)
checkRecvBufferSize(t, ep, tcp.DefaultReceiveBufferSize*3)
}
func TestBindToDeviceOption(t *testing.T) {
s := stack.New(stack.Options{
NetworkProtocols: []stack.NetworkProtocolFactory{ipv4.NewProtocol},
TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol}})
defer s.Destroy()
ep, err := s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &waiter.Queue{})
if err != nil {
t.Fatalf("NewEndpoint failed; %s", err)
}
defer ep.Close()
if err := s.CreateNIC(321, loopback.New()); err != nil {
t.Errorf("CreateNIC failed: %s", err)
}
// nicIDPtr is used instead of taking the address of NICID literals, which is
// a compiler error.
nicIDPtr := func(s tcpip.NICID) *tcpip.NICID {
return &s
}
testActions := []struct {
name string
setBindToDevice *tcpip.NICID
setBindToDeviceError tcpip.Error
getBindToDevice int32
}{
{"GetDefaultValue", nil, nil, 0},
{"BindToNonExistent", nicIDPtr(999), &tcpip.ErrUnknownDevice{}, 0},
{"BindToExistent", nicIDPtr(321), nil, 321},
{"UnbindToDevice", nicIDPtr(0), nil, 0},
}
for _, testAction := range testActions {
t.Run(testAction.name, func(t *testing.T) {
if testAction.setBindToDevice != nil {
bindToDevice := int32(*testAction.setBindToDevice)
if gotErr, wantErr := ep.SocketOptions().SetBindToDevice(bindToDevice), testAction.setBindToDeviceError; gotErr != wantErr {
t.Errorf("got SetSockOpt(&%T(%d)) = %s, want = %s", bindToDevice, bindToDevice, gotErr, wantErr)
}
}
bindToDevice := ep.SocketOptions().GetBindToDevice()
if bindToDevice != testAction.getBindToDevice {
t.Errorf("got bindToDevice = %d, want %d", bindToDevice, testAction.getBindToDevice)
}
})
}
}
func makeStack() (*stack.Stack, tcpip.Error) {
s := stack.New(stack.Options{
NetworkProtocols: []stack.NetworkProtocolFactory{
ipv4.NewProtocol,
ipv6.NewProtocol,
},
TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol},
})
id := loopback.New()
if testing.Verbose() {
id = sniffer.New(id)
}
if err := s.CreateNIC(1, id); err != nil {
return nil, err
}
for _, ct := range []struct {
number tcpip.NetworkProtocolNumber
addrWithPrefix tcpip.AddressWithPrefix
}{
{ipv4.ProtocolNumber, context.StackAddrWithPrefix},
{ipv6.ProtocolNumber, context.StackV6AddrWithPrefix},
} {
protocolAddr := tcpip.ProtocolAddress{
Protocol: ct.number,
AddressWithPrefix: ct.addrWithPrefix,
}
if err := s.AddProtocolAddress(1, protocolAddr, stack.AddressProperties{}); err != nil {
return nil, err
}
}
s.SetRouteTable([]tcpip.Route{
{
Destination: header.IPv4EmptySubnet,
NIC: 1,
},
{
Destination: header.IPv6EmptySubnet,
NIC: 1,
},
})
return s, nil
}
func TestSelfConnect(t *testing.T) {
// This test ensures that intentional self-connects work. In particular,
// it checks that if an endpoint binds to say 127.0.0.1:1000 then
// connects to 127.0.0.1:1000, then it will be connected to itself, and
// is able to send and receive data through the same endpoint.
s, err := makeStack()
if err != nil {
t.Fatal(err)
}
defer s.Destroy()
var wq waiter.Queue
ep, err := s.NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer ep.Close()
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
// Register for notification, then start connection attempt.
waitEntry, notifyCh := waiter.NewChannelEntry(waiter.WritableEvents)
wq.EventRegister(&waitEntry)
defer wq.EventUnregister(&waitEntry)
{
err := ep.Connect(tcpip.FullAddress{Addr: context.StackAddr, Port: context.StackPort})
if d := cmp.Diff(&tcpip.ErrConnectStarted{}, err); d != "" {
t.Fatalf("ep.Connect(...) mismatch (-want +got):\n%s", d)
}
}
<-notifyCh
if err := ep.LastError(); err != nil {
t.Fatalf("Connect failed: %s", err)
}
// Write something.
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := ep.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Read back what was written.
wq.EventUnregister(&waitEntry)
waitEntry, notifyCh = waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&waitEntry)
ept := endpointTester{ep}
rd := ept.CheckReadFull(t, len(data), notifyCh, 5*time.Second)
if !bytes.Equal(data, rd) {
t.Fatalf("got data = %v, want = %v", rd, data)
}
}
func TestConnectAvoidsBoundPorts(t *testing.T) {
addressTypes := func(t *testing.T, network string) []string {
switch network {
case "ipv4":
return []string{"v4"}
case "ipv6":
return []string{"v6"}
case "dual":
return []string{"v6", "mapped"}
default:
t.Fatalf("unknown network: '%s'", network)
}
panic("unreachable")
}
address := func(t *testing.T, addressType string, isAny bool) tcpip.Address {
switch addressType {
case "v4":
if isAny {
return tcpip.Address{}
}
return context.StackAddr
case "v6":
if isAny {
return tcpip.Address{}
}
return context.StackV6Addr
case "mapped":
if isAny {
return context.V4MappedWildcardAddr
}
return context.StackV4MappedAddr
default:
t.Fatalf("unknown address type: '%s'", addressType)
}
panic("unreachable")
}
// This test ensures that Endpoint.Connect doesn't select already-bound ports.
networks := []string{"ipv4", "ipv6", "dual"}
for _, exhaustedNetwork := range networks {
t.Run(fmt.Sprintf("exhaustedNetwork=%s", exhaustedNetwork), func(t *testing.T) {
for _, exhaustedAddressType := range addressTypes(t, exhaustedNetwork) {
t.Run(fmt.Sprintf("exhaustedAddressType=%s", exhaustedAddressType), func(t *testing.T) {
for _, isAny := range []bool{false, true} {
t.Run(fmt.Sprintf("isAny=%t", isAny), func(t *testing.T) {
for _, candidateNetwork := range networks {
t.Run(fmt.Sprintf("candidateNetwork=%s", candidateNetwork), func(t *testing.T) {
for _, candidateAddressType := range addressTypes(t, candidateNetwork) {
t.Run(fmt.Sprintf("candidateAddressType=%s", candidateAddressType), func(t *testing.T) {
s, err := makeStack()
if err != nil {
t.Fatal(err)
}
defer s.Destroy()
var wq waiter.Queue
var eps []tcpip.Endpoint
defer func() {
for _, ep := range eps {
ep.Close()
}
}()
makeEP := func(network string) tcpip.Endpoint {
var networkProtocolNumber tcpip.NetworkProtocolNumber
switch network {
case "ipv4":
networkProtocolNumber = ipv4.ProtocolNumber
case "ipv6", "dual":
networkProtocolNumber = ipv6.ProtocolNumber
default:
t.Fatalf("unknown network: '%s'", network)
}
ep, err := s.NewEndpoint(tcp.ProtocolNumber, networkProtocolNumber, &wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
eps = append(eps, ep)
switch network {
case "ipv4":
case "ipv6":
ep.SocketOptions().SetV6Only(true)
case "dual":
ep.SocketOptions().SetV6Only(false)
default:
t.Fatalf("unknown network: '%s'", network)
}
return ep
}
var v4reserved, v6reserved bool
switch exhaustedAddressType {
case "v4", "mapped":
v4reserved = true
case "v6":
v6reserved = true
// Dual stack sockets bound to v6 any reserve on v4 as
// well.
if isAny {
switch exhaustedNetwork {
case "ipv6":
case "dual":
v4reserved = true
default:
t.Fatalf("unknown address type: '%s'", exhaustedNetwork)
}
}
default:
t.Fatalf("unknown address type: '%s'", exhaustedAddressType)
}
var collides bool
switch candidateAddressType {
case "v4", "mapped":
collides = v4reserved
case "v6":
collides = v6reserved
default:
t.Fatalf("unknown address type: '%s'", candidateAddressType)
}
const (
start = 16000
end = 16050
)
if err := s.SetPortRange(start, end); err != nil {
t.Fatalf("got s.SetPortRange(%d, %d) = %s, want = nil", start, end, err)
}
for i := start; i <= end; i++ {
if err := makeEP(exhaustedNetwork).Bind(tcpip.FullAddress{Addr: address(t, exhaustedAddressType, isAny), Port: uint16(i)}); err != nil {
t.Fatalf("Bind(%d) failed: %s", i, err)
}
}
var want tcpip.Error = &tcpip.ErrConnectStarted{}
if collides {
want = &tcpip.ErrNoPortAvailable{}
}
if err := makeEP(candidateNetwork).Connect(tcpip.FullAddress{Addr: address(t, candidateAddressType, false), Port: 31337}); err != want {
t.Fatalf("got ep.Connect(..) = %s, want = %s", err, want)
}
})
}
})
}
})
}
})
}
})
}
}
func TestPathMTUDiscovery(t *testing.T) {
// This test verifies the stack retransmits packets after it receives an
// ICMP packet indicating that the path MTU has been exceeded.
c := context.New(t, 1500)
defer c.Cleanup()
// Create new connection with MSS of 1460.
const maxPayload = 1500 - header.TCPMinimumSize - header.IPv4MinimumSize
c.CreateConnectedWithRawOptions(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */, []byte{
header.TCPOptionMSS, 4, byte(maxPayload / 256), byte(maxPayload % 256),
})
// Send 3200 bytes of data.
const writeSize = 3200
data := make([]byte, writeSize)
for i := range data {
data[i] = byte(i)
}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
receivePackets := func(c *context.Context, sizes []int, which int, seqNum uint32) *buffer.View {
var ret *buffer.View
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for i, size := range sizes {
p := c.GetPacket()
if i == which {
ret = p
} else {
defer p.Release()
}
checker.IPv4(t, p,
checker.PayloadLen(size+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(seqNum),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
seqNum += uint32(size)
}
return ret
}
// Receive three packets.
sizes := []int{maxPayload, maxPayload, writeSize - 2*maxPayload}
first := receivePackets(c, sizes, 0, uint32(c.IRS)+1)
defer first.Release()
// Send "packet too big" messages back to netstack.
const newMTU = 1200
const newMaxPayload = newMTU - header.IPv4MinimumSize - header.TCPMinimumSize
mtu := buffer.NewViewWithData([]byte{0, 0, newMTU / 256, newMTU % 256})
defer mtu.Release()
c.SendICMPPacket(header.ICMPv4DstUnreachable, header.ICMPv4FragmentationNeeded, mtu, first, newMTU)
// See retransmitted packets. None exceeding the new max.
sizes = []int{newMaxPayload, maxPayload - newMaxPayload, newMaxPayload, maxPayload - newMaxPayload, writeSize - 2*maxPayload}
receivePackets(c, sizes, -1, uint32(c.IRS)+1)
}
func TestTCPEndpointProbe(t *testing.T) {
c := context.New(t, 1500)
defer c.Cleanup()
invoked := make(chan struct{})
c.Stack().AddTCPProbe(func(state *stack.TCPEndpointState) {
// Validate that the endpoint ID is what we expect.
//
// We don't do an extensive validation of every field but a
// basic sanity test.
if got, want := state.ID.LocalAddress, tcpip.Address(context.StackAddr); got != want {
t.Fatalf("got LocalAddress: %q, want: %q", got, want)
}
if got, want := state.ID.LocalPort, c.Port; got != want {
t.Fatalf("got LocalPort: %d, want: %d", got, want)
}
if got, want := state.ID.RemoteAddress, tcpip.Address(context.TestAddr); got != want {
t.Fatalf("got RemoteAddress: %q, want: %q", got, want)
}
if got, want := state.ID.RemotePort, uint16(context.TestPort); got != want {
t.Fatalf("got RemotePort: %d, want: %d", got, want)
}
invoked <- struct{}{}
})
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
data := []byte{1, 2, 3}
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
select {
case <-invoked:
case <-time.After(100 * time.Millisecond):
t.Fatalf("TCP Probe function was not called")
}
}
func TestStackSetCongestionControl(t *testing.T) {
testCases := []struct {
cc tcpip.CongestionControlOption
err tcpip.Error
}{
{"reno", nil},
{"cubic", nil},
{"blahblah", &tcpip.ErrNoSuchFile{}},
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("SetTransportProtocolOption(.., %v)", tc.cc), func(t *testing.T) {
c := context.New(t, 1500)
defer c.Cleanup()
s := c.Stack()
var oldCC tcpip.CongestionControlOption
if err := s.TransportProtocolOption(tcp.ProtocolNumber, &oldCC); err != nil {
t.Fatalf("s.TransportProtocolOption(%v, %v) = %s", tcp.ProtocolNumber, &oldCC, err)
}
if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &tc.cc); err != tc.err {
t.Fatalf("s.SetTransportProtocolOption(%d, &%T(%s)) = %s, want = %s", tcp.ProtocolNumber, tc.cc, tc.cc, err, tc.err)
}
var cc tcpip.CongestionControlOption
if err := s.TransportProtocolOption(tcp.ProtocolNumber, &cc); err != nil {
t.Fatalf("s.TransportProtocolOption(%v, %v) = %v", tcp.ProtocolNumber, &cc, err)
}
got, want := cc, oldCC
// If SetTransportProtocolOption is expected to succeed
// then the returned value for congestion control should
// match the one specified in the
// SetTransportProtocolOption call above, else it should
// be what it was before the call to
// SetTransportProtocolOption.
if tc.err == nil {
want = tc.cc
}
if got != want {
t.Fatalf("got congestion control: %v, want: %v", got, want)
}
})
}
}
func TestStackAvailableCongestionControl(t *testing.T) {
c := context.New(t, 1500)
defer c.Cleanup()
s := c.Stack()
// Query permitted congestion control algorithms.
var aCC tcpip.TCPAvailableCongestionControlOption
if err := s.TransportProtocolOption(tcp.ProtocolNumber, &aCC); err != nil {
t.Fatalf("s.TransportProtocolOption(%v, %v) = %v", tcp.ProtocolNumber, &aCC, err)
}
if got, want := aCC, tcpip.TCPAvailableCongestionControlOption("reno cubic"); got != want {
t.Fatalf("got tcpip.TCPAvailableCongestionControlOption: %v, want: %v", got, want)
}
}
func TestStackSetAvailableCongestionControl(t *testing.T) {
c := context.New(t, 1500)
defer c.Cleanup()
s := c.Stack()
// Setting AvailableCongestionControlOption should fail.
aCC := tcpip.TCPAvailableCongestionControlOption("xyz")
if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &aCC); err == nil {
t.Fatalf("s.SetTransportProtocolOption(%d, &%T(%s)) = nil, want non-nil", tcp.ProtocolNumber, aCC, aCC)
}
// Verify that we still get the expected list of congestion control options.
var cc tcpip.TCPAvailableCongestionControlOption
if err := s.TransportProtocolOption(tcp.ProtocolNumber, &cc); err != nil {
t.Fatalf("s.TransportProtocolOptio(%d, &%T(%s)): %s", tcp.ProtocolNumber, cc, cc, err)
}
if got, want := cc, tcpip.TCPAvailableCongestionControlOption("reno cubic"); got != want {
t.Fatalf("got tcpip.TCPAvailableCongestionControlOption = %s, want = %s", got, want)
}
}
func TestEndpointSetCongestionControl(t *testing.T) {
testCases := []struct {
cc tcpip.CongestionControlOption
err tcpip.Error
}{
{"reno", nil},
{"cubic", nil},
{"blahblah", &tcpip.ErrNoSuchFile{}},
}
for _, connected := range []bool{false, true} {
for _, tc := range testCases {
t.Run(fmt.Sprintf("SetSockOpt(.., %v) w/ connected = %v", tc.cc, connected), func(t *testing.T) {
c := context.New(t, 1500)
defer c.Cleanup()
// Create TCP endpoint.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
var oldCC tcpip.CongestionControlOption
if err := c.EP.GetSockOpt(&oldCC); err != nil {
t.Fatalf("c.EP.GetSockOpt(&%T) = %s", oldCC, err)
}
if connected {
c.Connect(context.TestInitialSequenceNumber, 32768 /* rcvWnd */, nil)
}
if err := c.EP.SetSockOpt(&tc.cc); err != tc.err {
t.Fatalf("got c.EP.SetSockOpt(&%#v) = %s, want %s", tc.cc, err, tc.err)
}
var cc tcpip.CongestionControlOption
if err := c.EP.GetSockOpt(&cc); err != nil {
t.Fatalf("c.EP.GetSockOpt(&%T): %s", cc, err)
}
got, want := cc, oldCC
// If SetSockOpt is expected to succeed then the
// returned value for congestion control should match
// the one specified in the SetSockOpt above, else it
// should be what it was before the call to SetSockOpt.
if tc.err == nil {
want = tc.cc
}
if got != want {
t.Fatalf("got congestion control = %+v, want = %+v", got, want)
}
})
}
}
}
func TestKeepalive(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
const keepAliveIdle = 100 * time.Millisecond
const keepAliveInterval = 3 * time.Second
keepAliveIdleOpt := tcpip.KeepaliveIdleOption(keepAliveIdle)
if err := c.EP.SetSockOpt(&keepAliveIdleOpt); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%s)): %s", keepAliveIdleOpt, keepAliveIdle, err)
}
keepAliveIntervalOpt := tcpip.KeepaliveIntervalOption(keepAliveInterval)
if err := c.EP.SetSockOpt(&keepAliveIntervalOpt); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%s)): %s", keepAliveIntervalOpt, keepAliveInterval, err)
}
c.EP.SetSockOptInt(tcpip.KeepaliveCountOption, 5)
if err := c.EP.SetSockOptInt(tcpip.KeepaliveCountOption, 5); err != nil {
t.Fatalf("c.EP.SetSockOptInt(tcpip.KeepaliveCountOption, 5): %s", err)
}
c.EP.SocketOptions().SetKeepAlive(true)
// 5 unacked keepalives are sent. ACK each one, and check that the
// connection stays alive after 5.
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for i := 0; i < 10; i++ {
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Acknowledge the keepalive.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS,
RcvWnd: 30000,
})
}
// Check that the connection is still alive.
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
// Send some data and wait before ACKing it. Keepalives should be disabled
// during this period.
view := make([]byte, 3)
var r bytes.Reader
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
next := uint32(c.IRS) + 1
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
// Wait for the packet to be retransmitted. Verify that no keepalives
// were sent.
b = c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagPsh),
),
)
c.CheckNoPacket("Keepalive packet received while unACKed data is pending")
next += uint32(len(view))
// Send ACK. Keepalives should start sending again.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
// Now receive 5 keepalives, but don't ACK them. The connection
// should be reset after 5.
for i := 0; i < 5; i++ {
b = c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next-1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
// Sleep for a litte over the KeepAlive interval to make sure
// the timer has time to fire after the last ACK and close the
// close the socket.
time.Sleep(keepAliveInterval + keepAliveInterval/2)
// The connection should be terminated after 5 unacked keepalives.
// Send an ACK to trigger a RST from the stack as the endpoint should
// be dead.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.TCP(checker.DstPort(context.TestPort), checker.TCPSeqNum(next), checker.TCPAckNum(uint32(0)), checker.TCPFlags(header.TCPFlagRst)),
)
if got := c.Stack().Stats().TCP.EstablishedTimedout.Value(); got != 1 {
t.Errorf("got c.Stack().Stats().TCP.EstablishedTimedout.Value() = %d, want = 1", got)
}
ept.CheckReadError(t, &tcpip.ErrTimeout{})
if got := c.Stack().Stats().TCP.CurrentEstablished.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentEstablished.Value() = %d, want = 0", got)
}
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 0", got)
}
}
func executeHandshake(t *testing.T, c *context.Context, srcPort uint16, synCookieInUse bool) (irs, iss seqnum.Value) {
t.Helper()
// Send a SYN request.
options := []byte{header.TCPOptionWS, 3, 0, header.TCPOptionNOP}
irs = seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: srcPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
TCPOpts: options,
})
// Receive the SYN-ACK reply.
b := c.GetPacket()
defer b.Release()
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
iss = seqnum.Value(tcpHdr.SequenceNumber())
tcpCheckers := []checker.TransportChecker{
checker.SrcPort(context.StackPort),
checker.DstPort(srcPort),
checker.TCPFlags(header.TCPFlagAck | header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs) + 1),
}
if synCookieInUse {
// When cookies are in use window scaling is disabled.
tcpCheckers = append(tcpCheckers, checker.TCPSynOptions(header.TCPSynOptions{
WS: -1,
MSS: c.MSSWithoutOptions(),
}))
} else {
tcpCheckers = append(tcpCheckers, checker.TCPSynOptions(header.TCPSynOptions{
WS: tcp.FindWndScale(tcp.DefaultReceiveBufferSize),
MSS: c.MSSWithoutOptions(),
}))
}
checker.IPv4(t, b, checker.TCP(tcpCheckers...))
// Send ACK.
c.SendPacket(nil, &context.Headers{
SrcPort: srcPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: irs + 1,
AckNum: iss + 1,
RcvWnd: 30000,
})
return irs, iss
}
func executeV6Handshake(t *testing.T, c *context.Context, srcPort uint16, synCookieInUse bool) (irs, iss seqnum.Value) {
t.Helper()
// Send a SYN request.
options := []byte{header.TCPOptionWS, 3, 0, header.TCPOptionNOP}
irs = seqnum.Value(context.TestInitialSequenceNumber)
c.SendV6Packet(nil, &context.Headers{
SrcPort: srcPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
TCPOpts: options,
})
// Receive the SYN-ACK reply.
b := c.GetV6Packet()
defer b.Release()
tcpHdr := header.TCP(header.IPv6(b.AsSlice()).Payload())
iss = seqnum.Value(tcpHdr.SequenceNumber())
tcpCheckers := []checker.TransportChecker{
checker.SrcPort(context.StackPort),
checker.DstPort(srcPort),
checker.TCPFlags(header.TCPFlagAck | header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs) + 1),
}
if synCookieInUse {
// When cookies are in use window scaling is disabled.
tcpCheckers = append(tcpCheckers, checker.TCPSynOptions(header.TCPSynOptions{
WS: -1,
MSS: c.MSSWithoutOptionsV6(),
}))
} else {
tcpCheckers = append(tcpCheckers, checker.TCPSynOptions(header.TCPSynOptions{
WS: tcp.FindWndScale(tcp.DefaultReceiveBufferSize),
MSS: c.MSSWithoutOptionsV6(),
}))
}
checker.IPv6(t, b, checker.TCP(tcpCheckers...))
// Send ACK.
c.SendV6Packet(nil, &context.Headers{
SrcPort: srcPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: irs + 1,
AckNum: iss + 1,
RcvWnd: 30000,
})
return irs, iss
}
// TestListenBacklogFull tests that netstack does not complete handshakes if the
// listen backlog for the endpoint is full.
func TestListenBacklogFull(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create TCP endpoint.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
// Bind to wildcard.
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
// Test acceptance.
// Start listening.
listenBacklog := 10
if err := c.EP.Listen(listenBacklog); err != nil {
t.Fatalf("Listen failed: %s", err)
}
lastPortOffset := uint16(0)
for ; int(lastPortOffset) < listenBacklog; lastPortOffset++ {
executeHandshake(t, c, context.TestPort+lastPortOffset, false /*synCookieInUse */)
}
time.Sleep(50 * time.Millisecond)
// Now execute send one more SYN. The stack should not respond as the backlog
// is full at this point.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort + lastPortOffset,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: seqnum.Value(context.TestInitialSequenceNumber),
RcvWnd: 30000,
})
c.CheckNoPacketTimeout("unexpected packet received", 50*time.Millisecond)
// Try to accept the connections in the backlog.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
for i := 0; i < listenBacklog; i++ {
_, _, err = c.EP.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
_, _, err = c.EP.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
}
// Now verify that there are no more connections that can be accepted.
_, _, err = c.EP.Accept(nil)
if !cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
select {
case <-ch:
t.Fatalf("unexpected endpoint delivered on Accept: %+v", c.EP)
case <-time.After(1 * time.Second):
}
}
// Now a new handshake must succeed.
executeHandshake(t, c, context.TestPort+lastPortOffset, false /*synCookieInUse */)
newEP, _, err := c.EP.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
newEP, _, err = c.EP.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
// Now verify that the TCP socket is usable and in a connected state.
data := "Don't panic"
var r strings.Reader
r.Reset(data)
newEP.Write(&r, tcpip.WriteOptions{})
b := c.GetPacket()
defer b.Release()
tcp := header.TCP(header.IPv4(b.AsSlice()).Payload())
if string(tcp.Payload()) != data {
t.Fatalf("unexpected data: got %s, want %s", string(tcp.Payload()), data)
}
}
// TestListenNoAcceptMulticastBroadcastV4 makes sure that TCP segments with a
// non unicast IPv4 address are not accepted.
func TestListenNoAcceptNonUnicastV4(t *testing.T) {
multicastAddr := tcpiptestutil.MustParse4("224.0.1.2")
otherMulticastAddr := tcpiptestutil.MustParse4("224.0.1.3")
subnet := context.StackAddrWithPrefix.Subnet()
subnetBroadcastAddr := subnet.Broadcast()
tests := []struct {
name string
srcAddr tcpip.Address
dstAddr tcpip.Address
}{
{
name: "SourceUnspecified",
srcAddr: header.IPv4Any,
dstAddr: context.StackAddr,
},
{
name: "SourceBroadcast",
srcAddr: header.IPv4Broadcast,
dstAddr: context.StackAddr,
},
{
name: "SourceOurMulticast",
srcAddr: multicastAddr,
dstAddr: context.StackAddr,
},
{
name: "SourceOtherMulticast",
srcAddr: otherMulticastAddr,
dstAddr: context.StackAddr,
},
{
name: "DestUnspecified",
srcAddr: context.TestAddr,
dstAddr: header.IPv4Any,
},
{
name: "DestBroadcast",
srcAddr: context.TestAddr,
dstAddr: header.IPv4Broadcast,
},
{
name: "DestOurMulticast",
srcAddr: context.TestAddr,
dstAddr: multicastAddr,
},
{
name: "DestOtherMulticast",
srcAddr: context.TestAddr,
dstAddr: otherMulticastAddr,
},
{
name: "SrcSubnetBroadcast",
srcAddr: subnetBroadcastAddr,
dstAddr: context.StackAddr,
},
{
name: "DestSubnetBroadcast",
srcAddr: context.TestAddr,
dstAddr: subnetBroadcastAddr,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1)
if err := c.Stack().JoinGroup(header.IPv4ProtocolNumber, 1, multicastAddr); err != nil {
t.Fatalf("JoinGroup failed: %s", err)
}
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := c.EP.Listen(1); err != nil {
t.Fatalf("Listen failed: %s", err)
}
irs := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacketWithAddrs(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
}, test.srcAddr, test.dstAddr)
c.CheckNoPacket("Should not have received a response")
// Handle normal packet.
c.SendPacketWithAddrs(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
}, context.TestAddr, context.StackAddr)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs)+1)))
})
}
}
// TestListenNoAcceptMulticastBroadcastV6 makes sure that TCP segments with a
// non unicast IPv6 address are not accepted.
func TestListenNoAcceptNonUnicastV6(t *testing.T) {
multicastAddr := tcpiptestutil.MustParse6("ff0e::101")
otherMulticastAddr := tcpiptestutil.MustParse6("ff0e::102")
tests := []struct {
name string
srcAddr tcpip.Address
dstAddr tcpip.Address
}{
{
"SourceUnspecified",
header.IPv6Any,
context.StackV6Addr,
},
{
"SourceAllNodes",
header.IPv6AllNodesMulticastAddress,
context.StackV6Addr,
},
{
"SourceOurMulticast",
multicastAddr,
context.StackV6Addr,
},
{
"SourceOtherMulticast",
otherMulticastAddr,
context.StackV6Addr,
},
{
"DestUnspecified",
context.TestV6Addr,
header.IPv6Any,
},
{
"DestAllNodes",
context.TestV6Addr,
header.IPv6AllNodesMulticastAddress,
},
{
"DestOurMulticast",
context.TestV6Addr,
multicastAddr,
},
{
"DestOtherMulticast",
context.TestV6Addr,
otherMulticastAddr,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateV6Endpoint(true)
if err := c.Stack().JoinGroup(header.IPv6ProtocolNumber, 1, multicastAddr); err != nil {
t.Fatalf("JoinGroup failed: %s", err)
}
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := c.EP.Listen(1); err != nil {
t.Fatalf("Listen failed: %s", err)
}
irs := seqnum.Value(context.TestInitialSequenceNumber)
c.SendV6PacketWithAddrs(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
}, test.srcAddr, test.dstAddr)
c.CheckNoPacket("Should not have received a response")
// Handle normal packet.
c.SendV6PacketWithAddrs(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
}, context.TestV6Addr, context.StackV6Addr)
v := c.GetV6Packet()
defer v.Release()
checker.IPv6(t, v,
checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs)+1)))
})
}
}
func TestListenSynRcvdQueueFull(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create TCP endpoint.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
// Bind to wildcard.
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
// Test acceptance.
if err := c.EP.Listen(1); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send two SYN's the first one should get a SYN-ACK, the
// second one should not get any response and is dropped as
// the accept queue is full.
irs := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
})
// Receive the SYN-ACK reply.
b := c.GetPacket()
defer b.Release()
tcp := header.TCP(header.IPv4(b.AsSlice()).Payload())
iss := seqnum.Value(tcp.SequenceNumber())
tcpCheckers := []checker.TransportChecker{
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck | header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs) + 1),
}
checker.IPv4(t, b, checker.TCP(tcpCheckers...))
// Now complete the previous connection.
// Send ACK.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: irs + 1,
AckNum: iss + 1,
RcvWnd: 30000,
})
// Verify if that is delivered to the accept queue.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
<-ch
// Now execute send one more SYN. The stack should not respond as the backlog
// is full at this point.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort + 1,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: seqnum.Value(889),
RcvWnd: 30000,
})
c.CheckNoPacketTimeout("unexpected packet received", 50*time.Millisecond)
// Try to accept the connections in the backlog.
newEP, _, err := c.EP.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
newEP, _, err = c.EP.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
// Now verify that the TCP socket is usable and in a connected state.
data := "Don't panic"
var r strings.Reader
r.Reset(data)
newEP.Write(&r, tcpip.WriteOptions{})
pkt := c.GetPacket()
defer pkt.Release()
tcp = header.IPv4(pkt.AsSlice()).Payload()
if string(tcp.Payload()) != data {
t.Fatalf("unexpected data: got %s, want %s", string(tcp.Payload()), data)
}
}
func TestListenBacklogFullSynCookieInUse(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create TCP endpoint.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
// Bind to wildcard.
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
// Test for SynCookies usage after filling up the backlog.
if err := c.EP.Listen(1); err != nil {
t.Fatalf("Listen failed: %s", err)
}
executeHandshake(t, c, context.TestPort, true)
// Wait for this to be delivered to the accept queue.
time.Sleep(50 * time.Millisecond)
// Send a SYN request.
irs := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
// pick a different src port for new SYN.
SrcPort: context.TestPort + 1,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
})
// The Syn should be dropped as the endpoint's backlog is full.
c.CheckNoPacketTimeout("unexpected packet received", 50*time.Millisecond)
// Verify that there is only one acceptable connection at this point.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
_, _, err = c.EP.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
_, _, err = c.EP.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
// Now verify that there are no more connections that can be accepted.
_, _, err = c.EP.Accept(nil)
if !cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
select {
case <-ch:
t.Fatalf("unexpected endpoint delivered on Accept: %+v", c.EP)
case <-time.After(1 * time.Second):
}
}
}
func TestSYNRetransmit(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create TCP endpoint.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
// Bind to wildcard.
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
// Start listening.
if err := c.EP.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send the same SYN packet multiple times. We should still get a valid SYN-ACK
// reply.
irs := seqnum.Value(context.TestInitialSequenceNumber)
for i := 0; i < 5; i++ {
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
})
}
// Receive the SYN-ACK reply.
tcpCheckers := []checker.TransportChecker{
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck | header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs) + 1),
}
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(tcpCheckers...))
}
func TestSynRcvdBadSeqNumber(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create TCP endpoint.
var err tcpip.Error
c.EP, err = c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
// Bind to wildcard.
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
// Start listening.
if err := c.EP.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send a SYN to get a SYN-ACK. This should put the ep into SYN-RCVD state
irs := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
RcvWnd: 30000,
})
// Receive the SYN-ACK reply.
b := c.GetPacket()
defer b.Release()
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
iss := seqnum.Value(tcpHdr.SequenceNumber())
tcpCheckers := []checker.TransportChecker{
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck | header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs) + 1),
}
checker.IPv4(t, b, checker.TCP(tcpCheckers...))
// Now send a packet with an out-of-window sequence number
largeSeqnum := irs + seqnum.Value(tcpHdr.WindowSize()) + 1
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: largeSeqnum,
AckNum: iss + 1,
RcvWnd: 30000,
})
// Should receive an ACK with the expected SEQ number
b = c.GetPacket()
defer b.Release()
tcpCheckers = []checker.TransportChecker{
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPAckNum(uint32(irs) + 1),
checker.TCPSeqNum(uint32(iss + 1)),
}
checker.IPv4(t, b, checker.TCP(tcpCheckers...))
// Now that the socket replied appropriately with the ACK,
// complete the connection to test that the large SEQ num
// did not change the state from SYN-RCVD.
// Get setup to be notified about connection establishment.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
// Send ACK to move to ESTABLISHED state.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: irs + 1,
AckNum: iss + 1,
RcvWnd: 30000,
})
<-ch
newEP, _, err := c.EP.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
// Now verify that the TCP socket is usable and in a connected state.
data := "Don't panic"
var r strings.Reader
r.Reset(data)
if _, err := newEP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
pkt := c.GetPacket()
defer pkt.Release()
tcpHdr = header.IPv4(pkt.AsSlice()).Payload()
if string(tcpHdr.Payload()) != data {
t.Fatalf("unexpected data: got %s, want %s", string(tcpHdr.Payload()), data)
}
}
func TestPassiveConnectionAttemptIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
c.EP = ep
if err := ep.Bind(tcpip.FullAddress{Addr: context.StackAddr, Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if got, want := tcp.EndpointState(ep.State()), tcp.StateBound; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
if err := c.EP.Listen(1); err != nil {
t.Fatalf("Listen failed: %s", err)
}
if got, want := tcp.EndpointState(c.EP.State()), tcp.StateListen; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
stats := c.Stack().Stats()
want := stats.TCP.PassiveConnectionOpenings.Value() + 1
srcPort := uint16(context.TestPort)
executeHandshake(t, c, srcPort+1, true /* synCookiesInUse */)
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
// Verify that there is only one acceptable connection at this point.
_, _, err = c.EP.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
_, _, err = c.EP.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
if got := stats.TCP.PassiveConnectionOpenings.Value(); got != want {
t.Errorf("got stats.TCP.PassiveConnectionOpenings.Value() = %d, want = %d", got, want)
}
}
func TestPassiveFailedConnectionAttemptIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, &c.WQ)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
c.EP = ep
if err := c.EP.Bind(tcpip.FullAddress{Addr: context.StackAddr, Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := c.EP.Listen(1); err != nil {
t.Fatalf("Listen failed: %s", err)
}
srcPort := uint16(context.TestPort)
// Now attempt a handshakes it will fill up the accept backlog.
executeHandshake(t, c, srcPort, true /* synCookesInUse */)
// Give time for the final ACK to be processed as otherwise the next handshake could
// get accepted before the previous one based on goroutine scheduling.
time.Sleep(50 * time.Millisecond)
want := stats.TCP.ListenOverflowSynDrop.Value() + 1
// Now we will send one more SYN and this one should get dropped
// Send a SYN request.
c.SendPacket(nil, &context.Headers{
SrcPort: srcPort + 2,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: seqnum.Value(context.TestInitialSequenceNumber),
RcvWnd: 30000,
})
checkValid := func() []error {
var errors []error
if got := stats.TCP.ListenOverflowSynDrop.Value(); got != want {
errors = append(errors, fmt.Errorf("got stats.TCP.ListenOverflowSynDrop.Value() = %d, want = %d", got, want))
}
if got := c.EP.Stats().(*tcp.Stats).ReceiveErrors.ListenOverflowSynDrop.Value(); got != want {
errors = append(errors, fmt.Errorf("got EP stats Stats.ReceiveErrors.ListenOverflowSynDrop = %d, want = %d", got, want))
}
return errors
}
start := time.Now()
for time.Since(start) < time.Minute && len(checkValid()) > 0 {
time.Sleep(50 * time.Millisecond)
}
for _, err := range checkValid() {
t.Error(err)
}
if t.Failed() {
t.FailNow()
}
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
c.WQ.EventRegister(&we)
defer c.WQ.EventUnregister(&we)
// Now check that there is one acceptable connections.
_, _, err = c.EP.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
<-ch
_, _, err = c.EP.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
}
}
func TestListenDropIncrement(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
stats := c.Stack().Stats()
c.Create(-1 /*epRcvBuf*/)
if err := c.EP.Bind(tcpip.FullAddress{Addr: context.StackAddr, Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := c.EP.Listen(1 /*backlog*/); err != nil {
t.Fatalf("Listen failed: %s", err)
}
initialDropped := stats.DroppedPackets.Value()
// Send RST, FIN segments, that are expected to be dropped by the listener.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagRst,
})
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagFin,
})
// To ensure that the RST, FIN sent earlier are indeed received and ignored
// by the listener, send a SYN and wait for the SYN to be ACKd.
irs := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: irs,
})
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs)+1),
))
if got, want := stats.DroppedPackets.Value(), initialDropped+2; got != want {
t.Fatalf("got stats.DroppedPackets.Value() = %d, want = %d", got, want)
}
}
func TestEndpointBindListenAcceptState(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if got, want := tcp.EndpointState(ep.State()), tcp.StateBound; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
ept := endpointTester{ep}
ept.CheckReadError(t, &tcpip.ErrNotConnected{})
if got := ep.Stats().(*tcp.Stats).ReadErrors.NotConnected.Value(); got != 1 {
t.Errorf("got EP stats Stats.ReadErrors.NotConnected got %d want %d", got, 1)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
if got, want := tcp.EndpointState(ep.State()), tcp.StateListen; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
c.PassiveConnectWithOptions(100, 5, header.TCPSynOptions{MSS: e2e.DefaultIPv4MSS}, 0 /* delay */)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
aep, _, err := ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
aep, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
if got, want := tcp.EndpointState(aep.State()), tcp.StateEstablished; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
{
err := aep.Connect(tcpip.FullAddress{Addr: context.TestAddr, Port: context.TestPort})
if d := cmp.Diff(&tcpip.ErrAlreadyConnected{}, err); d != "" {
t.Errorf("Connect(...) mismatch (-want +got):\n%s", d)
}
}
// Listening endpoint remains in listen state.
if got, want := tcp.EndpointState(ep.State()), tcp.StateListen; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
ep.Close()
// Give worker goroutines time to receive the close notification.
time.Sleep(1 * time.Second)
if got, want := tcp.EndpointState(ep.State()), tcp.StateClose; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
// Accepted endpoint remains open when the listen endpoint is closed.
if got, want := tcp.EndpointState(aep.State()), tcp.StateEstablished; got != want {
t.Errorf("unexpected endpoint state: want %s, got %s", want, got)
}
}
// This test verifies that the auto tuning does not grow the receive buffer if
// the application is not reading the data actively.
func TestReceiveBufferAutoTuningApplicationLimited(t *testing.T) {
const mtu = 1500
const mss = mtu - header.IPv4MinimumSize - header.TCPMinimumSize
c := context.New(t, mtu)
defer c.Cleanup()
stk := c.Stack()
// Set lower limits for auto-tuning tests. This is required because the
// test stops the worker which can cause packets to be dropped because
// the segment queue holding unprocessed packets is limited to 500.
const receiveBufferSize = 80 << 10 // 80KB.
const maxReceiveBufferSize = receiveBufferSize * 10
{
opt := tcpip.TCPReceiveBufferSizeRangeOption{Min: 1, Default: receiveBufferSize, Max: maxReceiveBufferSize}
if err := stk.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%#v): %s", tcp.ProtocolNumber, opt, err)
}
}
// Enable auto-tuning.
{
opt := tcpip.TCPModerateReceiveBufferOption(true)
if err := stk.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %s", tcp.ProtocolNumber, opt, opt, err)
}
}
// Change the expected window scale to match the value needed for the
// maximum buffer size defined above.
c.WindowScale = uint8(tcp.FindWndScale(maxReceiveBufferSize))
rawEP := c.CreateConnectedWithOptionsNoDelay(header.TCPSynOptions{TS: true, WS: 4})
// NOTE: The timestamp values in the sent packets are meaningless to the
// peer so we just increment the timestamp value by 1 every batch as we
// are not really using them for anything. Send a single byte to verify
// the advertised window.
tsVal := rawEP.TSVal + 1
// Introduce a 25ms latency by delaying the first byte.
latency := 25 * time.Millisecond
time.Sleep(latency)
// Send an initial payload with atleast segment overhead size. The receive
// window would not grow for smaller segments.
rawEP.SendPacketWithTS(make([]byte, tcp.SegOverheadSize), tsVal)
pkt := rawEP.VerifyAndReturnACKWithTS(tsVal)
defer pkt.Release()
rcvWnd := header.TCP(header.IPv4(pkt.AsSlice()).Payload()).WindowSize()
time.Sleep(25 * time.Millisecond)
// Allocate a large enough payload for the test.
payloadSize := receiveBufferSize * 2
b := make([]byte, payloadSize)
worker := (c.EP).(interface {
StopWork()
ResumeWork()
})
tsVal++
// Stop the worker goroutine.
worker.StopWork()
start := 0
end := payloadSize / 2
packetsSent := 0
for ; start < end; start += mss {
packetEnd := start + mss
if start+mss > end {
packetEnd = end
}
rawEP.SendPacketWithTS(b[start:packetEnd], tsVal)
packetsSent++
}
// Resume the worker so that it only sees the packets once all of them
// are waiting to be read.
worker.ResumeWork()
// Since we sent almost the full receive buffer worth of data (some may have
// been dropped due to segment overheads), we should get a zero window back.
pkt = c.GetPacket()
defer pkt.Release()
tcpHdr := header.TCP(header.IPv4(pkt.AsSlice()).Payload())
gotRcvWnd := tcpHdr.WindowSize()
wantAckNum := tcpHdr.AckNumber()
if got, want := int(gotRcvWnd), 0; got != want {
t.Fatalf("got rcvWnd: %d, want: %d", got, want)
}
time.Sleep(25 * time.Millisecond)
// Verify that sending more data when receiveBuffer is exhausted.
rawEP.SendPacketWithTS(b[start:start+mss], tsVal)
// Now read all the data from the endpoint and verify that advertised
// window increases to the full available buffer size.
for {
_, err := c.EP.Read(ioutil.Discard, tcpip.ReadOptions{})
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
break
}
}
// Verify that we receive a non-zero window update ACK. When running
// under thread santizer this test can end up sending more than 1
// ack, 1 for the non-zero window
p := c.GetPacket()
defer p.Release()
checker.IPv4(t, p, checker.TCP(
checker.TCPAckNum(wantAckNum),
func(t *testing.T, h header.Transport) {
tcp, ok := h.(header.TCP)
if !ok {
return
}
// We use 10% here as the error margin upwards as the initial window we
// got was afer 1 segment was already in the receive buffer queue.
tolerance := 1.1
if w := tcp.WindowSize(); w == 0 || w > uint16(float64(rcvWnd)*tolerance) {
t.Errorf("expected a non-zero window: got %d, want <= %d", w, uint16(float64(rcvWnd)*tolerance))
}
},
))
}
// This test verifies that the advertised window is auto-tuned up as the
// application is reading the data that is being received.
func TestReceiveBufferAutoTuning(t *testing.T) {
const mtu = 1500
const mss = mtu - header.IPv4MinimumSize - header.TCPMinimumSize
c := context.New(t, mtu)
defer c.Cleanup()
// Enable Auto-tuning.
stk := c.Stack()
// Disable out of window rate limiting for this test by setting it to 0 as we
// use out of window ACKs to measure the advertised window.
var tcpInvalidRateLimit stack.TCPInvalidRateLimitOption
if err := stk.SetOption(tcpInvalidRateLimit); err != nil {
t.Fatalf("e.stack.SetOption(%#v) = %s", tcpInvalidRateLimit, err)
}
const receiveBufferSize = 80 << 10 // 80KB.
const maxReceiveBufferSize = receiveBufferSize * 10
{
opt := tcpip.TCPReceiveBufferSizeRangeOption{Min: 1, Default: receiveBufferSize, Max: maxReceiveBufferSize}
if err := stk.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%#v): %s", tcp.ProtocolNumber, opt, err)
}
}
// Enable auto-tuning.
{
opt := tcpip.TCPModerateReceiveBufferOption(true)
if err := stk.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %s", tcp.ProtocolNumber, opt, opt, err)
}
}
// Change the expected window scale to match the value needed for the
// maximum buffer size used by stack.
c.WindowScale = uint8(tcp.FindWndScale(maxReceiveBufferSize))
rawEP := c.CreateConnectedWithOptionsNoDelay(header.TCPSynOptions{TS: true, WS: 4})
tsVal := rawEP.TSVal
rawEP.NextSeqNum--
rawEP.SendPacketWithTS(nil, tsVal)
rawEP.NextSeqNum++
pkt := rawEP.VerifyAndReturnACKWithTS(tsVal)
defer pkt.Release()
curRcvWnd := int(header.TCP(header.IPv4(pkt.AsSlice()).Payload()).WindowSize()) << c.WindowScale
scaleRcvWnd := func(rcvWnd int) uint16 {
return uint16(rcvWnd >> c.WindowScale)
}
// Allocate a large array to send to the endpoint.
b := make([]byte, receiveBufferSize*48)
// In every iteration we will send double the number of bytes sent in
// the previous iteration and read the same from the app. The received
// window should grow by at least 2x of bytes read by the app in every
// RTT.
offset := 0
payloadSize := receiveBufferSize / 8
worker := (c.EP).(interface {
StopWork()
ResumeWork()
})
latency := 1 * time.Millisecond
for i := 0; i < 5; i++ {
tsVal++
// Stop the worker goroutine.
worker.StopWork()
start := offset
end := offset + payloadSize
totalSent := 0
packetsSent := 0
for ; start < end; start += mss {
rawEP.SendPacketWithTS(b[start:start+mss], tsVal)
totalSent += mss
packetsSent++
}
// Resume it so that it only sees the packets once all of them
// are waiting to be read.
worker.ResumeWork()
// Give 1ms for the worker to process the packets.
time.Sleep(1 * time.Millisecond)
lastACK := c.GetPacket()
defer lastACK.Release()
// Discard any intermediate ACKs and only check the last ACK we get in a
// short time period of few ms.
for {
time.Sleep(1 * time.Millisecond)
pkt := c.GetPacketNonBlocking()
if pkt == nil {
break
}
defer pkt.Release()
lastACK = pkt
}
if got, want := int(header.TCP(header.IPv4(lastACK.AsSlice()).Payload()).WindowSize()), int(scaleRcvWnd(curRcvWnd)); got > want {
t.Fatalf("advertised window got: %d, want <= %d", got, want)
}
// Now read all the data from the endpoint and invoke the
// moderation API to allow for receive buffer auto-tuning
// to happen before we measure the new window.
totalCopied := 0
for {
res, err := c.EP.Read(ioutil.Discard, tcpip.ReadOptions{})
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
break
}
totalCopied += res.Count
}
// Invoke the moderation API. This is required for auto-tuning
// to happen. This method is normally expected to be invoked
// from a higher layer than tcpip.Endpoint. So we simulate
// copying to userspace by invoking it explicitly here.
c.EP.ModerateRecvBuf(totalCopied)
// Now send a keep-alive packet to trigger an ACK so that we can
// measure the new window.
rawEP.NextSeqNum--
rawEP.SendPacketWithTS(nil, tsVal)
rawEP.NextSeqNum++
if i == 0 {
// In the first iteration the receiver based RTT is not
// yet known as a result the moderation code should not
// increase the advertised window.
rawEP.VerifyACKRcvWnd(scaleRcvWnd(curRcvWnd))
} else {
// Read loop above could generate an ACK if the window had dropped to
// zero and then read had opened it up.
lastACK := c.GetPacket()
defer lastACK.Release()
// Discard any intermediate ACKs and only check the last ACK we get in a
// short time period of few ms.
for {
time.Sleep(1 * time.Millisecond)
pkt := c.GetPacketNonBlocking()
if pkt == nil {
break
}
defer pkt.Release()
lastACK = pkt
}
curRcvWnd = int(header.TCP(header.IPv4(lastACK.AsSlice()).Payload()).WindowSize()) << c.WindowScale
// If thew new current window is close maxReceiveBufferSize then terminate
// the loop. This can happen before all iterations are done due to timing
// differences when running the test.
if int(float64(curRcvWnd)*1.1) > maxReceiveBufferSize/2 {
break
}
// Increase the latency after first two iterations to
// establish a low RTT value in the receiver since it
// only tracks the lowest value. This ensures that when
// ModerateRcvBuf is called the elapsed time is always >
// rtt. Without this the test is flaky due to delays due
// to scheduling/wakeup etc.
latency += 50 * time.Millisecond
}
time.Sleep(latency)
offset += payloadSize
payloadSize *= 2
}
// Check that at the end of our iterations the receive window grew close to the maximum
// permissible size of maxReceiveBufferSize/2
if got, want := int(float64(curRcvWnd)*1.1), maxReceiveBufferSize/2; got < want {
t.Fatalf("unexpected rcvWnd got: %d, want > %d", got, want)
}
}
func TestDelayEnabled(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
checkDelayOption(t, c, false, false) // Delay is disabled by default.
for _, delayEnabled := range []bool{false, true} {
t.Run(fmt.Sprintf("delayEnabled=%t", delayEnabled), func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
opt := tcpip.TCPDelayEnabled(delayEnabled)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %s", tcp.ProtocolNumber, opt, delayEnabled, err)
}
checkDelayOption(t, c, opt, delayEnabled)
})
}
}
func checkDelayOption(t *testing.T, c *context.Context, wantDelayEnabled tcpip.TCPDelayEnabled, wantDelayOption bool) {
t.Helper()
var gotDelayEnabled tcpip.TCPDelayEnabled
if err := c.Stack().TransportProtocolOption(tcp.ProtocolNumber, &gotDelayEnabled); err != nil {
t.Fatalf("TransportProtocolOption(tcp, &gotDelayEnabled) failed: %s", err)
}
if gotDelayEnabled != wantDelayEnabled {
t.Errorf("TransportProtocolOption(tcp, &gotDelayEnabled) got %t, want %t", gotDelayEnabled, wantDelayEnabled)
}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, new(waiter.Queue))
if err != nil {
t.Fatalf("NewEndPoint(tcp, ipv4, new(waiter.Queue)) failed: %s", err)
}
gotDelayOption := ep.SocketOptions().GetDelayOption()
if gotDelayOption != wantDelayOption {
t.Errorf("ep.GetSockOptBool(tcpip.DelayOption) got: %t, want: %t", gotDelayOption, wantDelayOption)
}
}
func TestTCPLingerTimeout(t *testing.T) {
c := context.New(t, 1500 /* mtu */)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
testCases := []struct {
name string
tcpLingerTimeout time.Duration
want time.Duration
}{
{"NegativeLingerTimeout", -123123, -1},
// Zero is treated same as the stack's default TCP_LINGER2 timeout.
{"ZeroLingerTimeout", 0, tcp.DefaultTCPLingerTimeout},
{"InRangeLingerTimeout", 10 * time.Second, 10 * time.Second},
// Values > stack's TCPLingerTimeout are capped to the stack's
// value. Defaults to tcp.DefaultTCPLingerTimeout(60 seconds)
{"AboveMaxLingerTimeout", tcp.MaxTCPLingerTimeout + 5*time.Second, tcp.MaxTCPLingerTimeout},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
v := tcpip.TCPLingerTimeoutOption(tc.tcpLingerTimeout)
if err := c.EP.SetSockOpt(&v); err != nil {
t.Fatalf("SetSockOpt(&%T(%s)) = %s", v, tc.tcpLingerTimeout, err)
}
v = 0
if err := c.EP.GetSockOpt(&v); err != nil {
t.Fatalf("GetSockOpt(&%T) = %s", v, err)
}
if got, want := time.Duration(v), tc.want; got != want {
t.Fatalf("got linger timeout = %s, want = %s", got, want)
}
})
}
}
func TestTCPTimeWaitRSTIgnored(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send a SYN request.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
RcvWnd: 30000,
})
// Receive the SYN-ACK reply.
b := c.GetPacket()
defer b.Release()
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
ackHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 1,
}
// Send ACK.
c.SendPacket(nil, ackHeaders)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
c.EP.Close()
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagFin|header.TCPFlagAck)))
finHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss + 1,
AckNum: c.IRS + 2,
}
c.SendPacket(nil, finHeaders)
// Get the ACK to the FIN we just sent.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+2)),
checker.TCPAckNum(uint32(iss)+2),
checker.TCPFlags(header.TCPFlagAck)))
// Now send a RST and this should be ignored and not
// generate an ACK.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagRst,
SeqNum: iss + 1,
AckNum: c.IRS + 2,
})
c.CheckNoPacketTimeout("unexpected packet received in TIME_WAIT state", 1*time.Second)
// Out of order ACK should generate an immediate ACK in
// TIME_WAIT.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 3,
})
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+2)),
checker.TCPAckNum(uint32(iss)+2),
checker.TCPFlags(header.TCPFlagAck)))
}
func TestTCPTimeWaitOutOfOrder(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send a SYN request.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
RcvWnd: 30000,
})
// Receive the SYN-ACK reply.
b := c.GetPacket()
defer b.Release()
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
ackHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 1,
}
// Send ACK.
c.SendPacket(nil, ackHeaders)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
c.EP.Close()
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagFin|header.TCPFlagAck)))
finHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss + 1,
AckNum: c.IRS + 2,
}
c.SendPacket(nil, finHeaders)
// Get the ACK to the FIN we just sent.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+2)),
checker.TCPAckNum(uint32(iss)+2),
checker.TCPFlags(header.TCPFlagAck)))
// Out of order ACK should generate an immediate ACK in
// TIME_WAIT.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 3,
})
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+2)),
checker.TCPAckNum(uint32(iss)+2),
checker.TCPFlags(header.TCPFlagAck)))
}
func TestTCPTimeWaitNewSyn(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send a SYN request.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
RcvWnd: 30000,
})
// Receive the SYN-ACK reply.
b := c.GetPacket()
defer b.Release()
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
ackHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 1,
}
// Send ACK.
c.SendPacket(nil, ackHeaders)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
c.EP.Close()
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagFin|header.TCPFlagAck)))
finHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss + 1,
AckNum: c.IRS + 2,
}
c.SendPacket(nil, finHeaders)
// Get the ACK to the FIN we just sent.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+2)),
checker.TCPAckNum(uint32(iss)+2),
checker.TCPFlags(header.TCPFlagAck)))
// Send a SYN request w/ sequence number lower than
// the highest sequence number sent. We just reuse
// the same number.
iss = seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
RcvWnd: 30000,
})
c.CheckNoPacketTimeout("unexpected packet received in response to SYN", 1*time.Second)
// drain any older notifications from the notification channel before attempting
// 2nd connection.
select {
case <-ch:
default:
}
// Send a SYN request w/ sequence number higher than
// the highest sequence number sent.
iss = iss.Add(3)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
RcvWnd: 30000,
})
// Receive the SYN-ACK reply.
b = c.GetPacket()
defer b.Release()
tcpHdr = header.IPv4(b.AsSlice()).Payload()
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
ackHeaders = &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 1,
}
// Send ACK.
c.SendPacket(nil, ackHeaders)
// Try to accept the connection.
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
}
func TestTCPTimeWaitDuplicateFINExtendsTimeWait(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set TCPTimeWaitTimeout to 5 seconds so that sockets are marked closed
// after 5 seconds in TIME_WAIT state.
tcpTimeWaitTimeout := 5 * time.Second
opt := tcpip.TCPTimeWaitTimeoutOption(tcpTimeWaitTimeout)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%s)): %s", tcp.ProtocolNumber, opt, tcpTimeWaitTimeout, err)
}
want := c.Stack().Stats().TCP.EstablishedClosed.Value() + 1
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send a SYN request.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
RcvWnd: 30000,
})
// Receive the SYN-ACK reply.
b := c.GetPacket()
defer b.Release()
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
ackHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 1,
}
// Send ACK.
c.SendPacket(nil, ackHeaders)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
c.EP.Close()
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(uint32(iss)+1),
checker.TCPFlags(header.TCPFlagFin|header.TCPFlagAck)))
finHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss + 1,
AckNum: c.IRS + 2,
}
c.SendPacket(nil, finHeaders)
// Get the ACK to the FIN we just sent.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+2)),
checker.TCPAckNum(uint32(iss)+2),
checker.TCPFlags(header.TCPFlagAck)))
time.Sleep(2 * time.Second)
// Now send a duplicate FIN. This should cause the TIME_WAIT to extend
// by another 5 seconds and also send us a duplicate ACK as it should
// indicate that the final ACK was potentially lost.
c.SendPacket(nil, finHeaders)
// Get the ACK to the FIN we just sent.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+2)),
checker.TCPAckNum(uint32(iss)+2),
checker.TCPFlags(header.TCPFlagAck)))
// Sleep for 4 seconds so at this point we are 1 second past the
// original tcpLingerTimeout of 5 seconds.
time.Sleep(4 * time.Second)
// Send an ACK and it should not generate any packet as the socket
// should still be in TIME_WAIT for another another 5 seconds due
// to the duplicate FIN we sent earlier.
*ackHeaders = *finHeaders
ackHeaders.SeqNum = ackHeaders.SeqNum + 1
ackHeaders.Flags = header.TCPFlagAck
c.SendPacket(nil, ackHeaders)
c.CheckNoPacketTimeout("unexpected packet received from endpoint in TIME_WAIT", 1*time.Second)
// Now sleep for another 2 seconds so that we are past the
// extended TIME_WAIT of 7 seconds (2 + 5).
time.Sleep(2 * time.Second)
// Resend the same ACK.
c.SendPacket(nil, ackHeaders)
// Receive the RST that should be generated as there is no valid
// endpoint.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(ackHeaders.AckNum)),
checker.TCPAckNum(0),
checker.TCPFlags(header.TCPFlagRst)))
if got := c.Stack().Stats().TCP.EstablishedClosed.Value(); got != want {
t.Errorf("got c.Stack().Stats().TCP.EstablishedClosed = %d, want = %d", got, want)
}
if got := c.Stack().Stats().TCP.CurrentEstablished.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentEstablished.Value() = %d, want = 0", got)
}
}
func TestTCPCloseWithData(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Set TCPTimeWaitTimeout to 5 seconds so that sockets are marked closed
// after 5 seconds in TIME_WAIT state.
tcpTimeWaitTimeout := 5 * time.Second
opt := tcpip.TCPTimeWaitTimeoutOption(tcpTimeWaitTimeout)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%s)): %s", tcp.ProtocolNumber, opt, tcpTimeWaitTimeout, err)
}
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Send a SYN request.
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
SeqNum: iss,
RcvWnd: 30000,
})
// Receive the SYN-ACK reply.
b := c.GetPacket()
defer b.Release()
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
ackHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 1,
AckNum: c.IRS + 1,
RcvWnd: 30000,
}
// Send ACK.
c.SendPacket(nil, ackHeaders)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
}
// Now trigger a passive close by sending a FIN.
finHeaders := &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck | header.TCPFlagFin,
SeqNum: iss + 1,
AckNum: c.IRS + 2,
RcvWnd: 30000,
}
c.SendPacket(nil, finHeaders)
// Get the ACK to the FIN we just sent.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(uint32(iss)+2),
checker.TCPFlags(header.TCPFlagAck)))
// Now write a few bytes and then close the endpoint.
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// Check that data is received.
b = c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(len(data)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+2), // Acknum is initial sequence number + 1
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
if p := b.AsSlice()[header.IPv4MinimumSize+header.TCPMinimumSize:]; !bytes.Equal(data, p) {
t.Errorf("got data = %x, want = %x", p, data)
}
c.EP.Close()
// Check the FIN.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)+uint32(len(data))),
checker.TCPAckNum(uint32(iss+2)),
checker.TCPFlags(header.TCPFlagFin|header.TCPFlagAck)))
// First send a partial ACK.
ackHeaders = &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 2,
AckNum: c.IRS + 1 + seqnum.Value(len(data)-1),
RcvWnd: 30000,
}
c.SendPacket(nil, ackHeaders)
// Now send a full ACK.
ackHeaders = &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 2,
AckNum: c.IRS + 1 + seqnum.Value(len(data)),
RcvWnd: 30000,
}
c.SendPacket(nil, ackHeaders)
// Now ACK the FIN.
ackHeaders.AckNum++
c.SendPacket(nil, ackHeaders)
// Now send an ACK and we should get a RST back as the endpoint should
// be in CLOSED state.
ackHeaders = &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: iss + 2,
AckNum: c.IRS + 1 + seqnum.Value(len(data)),
RcvWnd: 30000,
}
c.SendPacket(nil, ackHeaders)
// Check the RST.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(ackHeaders.AckNum)),
checker.TCPAckNum(0),
checker.TCPFlags(header.TCPFlagRst)))
}
func TestTCPUserTimeout(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
initRTO := 1 * time.Second
minRTOOpt := tcpip.TCPMinRTOOption(initRTO)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &minRTOOpt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%d)): %s", tcp.ProtocolNumber, minRTOOpt, minRTOOpt, err)
}
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
waitEntry, notifyCh := waiter.NewChannelEntry(waiter.EventHUp)
c.WQ.EventRegister(&waitEntry)
defer c.WQ.EventUnregister(&waitEntry)
origEstablishedTimedout := c.Stack().Stats().TCP.EstablishedTimedout.Value()
// Ensure that on the next retransmit timer fire, the user timeout has
// expired.
userTimeout := initRTO / 2
v := tcpip.TCPUserTimeoutOption(userTimeout)
if err := c.EP.SetSockOpt(&v); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%s): %s", v, userTimeout, err)
}
// Send some data and wait before ACKing it.
view := make([]byte, 3)
var r bytes.Reader
r.Reset(view)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
next := uint32(c.IRS) + 1
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
b := c.GetPacket()
defer b.Release()
checker.IPv4(t, b,
checker.PayloadLen(len(view)+header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlagsMatch(header.TCPFlagAck, ^header.TCPFlagPsh),
),
)
// Wait for the retransmit timer to be fired and the user timeout to cause
// close of the connection.
select {
case <-notifyCh:
case <-time.After(2 * initRTO):
t.Fatalf("connection still alive after %s, should have been closed after %s", 2*initRTO, userTimeout)
}
// No packet should be received as the connection should be silently
// closed due to timeout.
c.CheckNoPacket("unexpected packet received after userTimeout has expired")
next += uint32(len(view))
// The connection should be terminated after userTimeout has expired.
// Send an ACK to trigger a RST from the stack as the endpoint should
// be dead.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: seqnum.Value(next),
RcvWnd: 30000,
})
b = c.GetPacket()
defer b.Release()
checker.IPv4(t, b, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(next),
checker.TCPAckNum(uint32(0)),
checker.TCPFlags(header.TCPFlagRst),
),
)
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrTimeout{})
if got, want := c.Stack().Stats().TCP.EstablishedTimedout.Value(), origEstablishedTimedout+1; got != want {
t.Errorf("got c.Stack().Stats().TCP.EstablishedTimedout = %d, want = %d", got, want)
}
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 0", got)
}
}
func TestKeepaliveWithUserTimeout(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
origEstablishedTimedout := c.Stack().Stats().TCP.EstablishedTimedout.Value()
const keepAliveIdle = 100 * time.Millisecond
const keepAliveInterval = 3 * time.Second
keepAliveIdleOption := tcpip.KeepaliveIdleOption(keepAliveIdle)
if err := c.EP.SetSockOpt(&keepAliveIdleOption); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%s)): %s", keepAliveIdleOption, keepAliveIdle, err)
}
keepAliveIntervalOption := tcpip.KeepaliveIntervalOption(keepAliveInterval)
if err := c.EP.SetSockOpt(&keepAliveIntervalOption); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%s)): %s", keepAliveIntervalOption, keepAliveInterval, err)
}
if err := c.EP.SetSockOptInt(tcpip.KeepaliveCountOption, 10); err != nil {
t.Fatalf("c.EP.SetSockOptInt(tcpip.KeepaliveCountOption, 10): %s", err)
}
c.EP.SocketOptions().SetKeepAlive(true)
// Set userTimeout to be the duration to be 1 keepalive
// probes. Which means that after the first probe is sent
// the second one should cause the connection to be
// closed due to userTimeout being hit.
userTimeout := tcpip.TCPUserTimeoutOption(keepAliveInterval)
if err := c.EP.SetSockOpt(&userTimeout); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%s)): %s", userTimeout, keepAliveInterval, err)
}
// Check that the connection is still alive.
ept := endpointTester{c.EP}
ept.CheckReadError(t, &tcpip.ErrWouldBlock{})
// Now receive 1 keepalives, but don't ACK it.
b := c.GetPacket()
defer b.Release()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
checker.IPv4(t, b,
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Sleep for a litte over the KeepAlive interval to make sure
// the timer has time to fire after the last ACK and close the
// close the socket.
time.Sleep(keepAliveInterval + keepAliveInterval/2)
// The connection should be closed with a timeout.
// Send an ACK to trigger a RST from the stack as the endpoint should
// be dead.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS + 1,
RcvWnd: 30000,
})
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS+1)),
checker.TCPAckNum(uint32(0)),
checker.TCPFlags(header.TCPFlagRst),
),
)
ept.CheckReadError(t, &tcpip.ErrTimeout{})
if got, want := c.Stack().Stats().TCP.EstablishedTimedout.Value(), origEstablishedTimedout+1; got != want {
t.Errorf("got c.Stack().Stats().TCP.EstablishedTimedout = %d, want = %d", got, want)
}
if got := c.Stack().Stats().TCP.CurrentConnected.Value(); got != 0 {
t.Errorf("got stats.TCP.CurrentConnected.Value() = %d, want = 0", got)
}
}
func TestIncreaseWindowOnRead(t *testing.T) {
// This test ensures that the endpoint sends an ack,
// after read() when the window grows by more than 1 MSS.
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
const rcvBuf = 65535 * 10
c.CreateConnected(context.TestInitialSequenceNumber, 30000, rcvBuf)
// Write chunks of ~30000 bytes. It's important that two
// payloads make it equal or longer than MSS.
remain := rcvBuf * 2
sent := 0
data := make([]byte, e2e.DefaultMTU/2)
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for remain > len(data) {
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(seqnum.Size(sent)),
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
sent += len(data)
remain -= len(data)
pkt := c.GetPacket()
defer pkt.Release()
checker.IPv4(t, pkt,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(sent)),
checker.TCPFlags(header.TCPFlagAck),
),
)
// Break once the window drops below e2e.DefaultMTU/2
if wnd := header.TCP(header.IPv4(pkt.AsSlice()).Payload()).WindowSize(); wnd < e2e.DefaultMTU/2 {
break
}
}
// We now have < 1 MSS in the buffer space. Read at least > 2 MSS
// worth of data as receive buffer space
w := tcpip.LimitedWriter{
W: ioutil.Discard,
// e2e.DefaultMTU is a good enough estimate for the MSS used for this
// connection.
N: e2e.DefaultMTU * 2,
}
for w.N != 0 {
_, err := c.EP.Read(&w, tcpip.ReadOptions{})
if err != nil {
t.Fatalf("Read failed: %s", err)
}
}
// After reading > MSS worth of data, we surely crossed MSS. See the ack:
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(sent)),
checker.TCPWindow(uint16(0xffff)),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestIncreaseWindowOnBufferResize(t *testing.T) {
// This test ensures that the endpoint sends an ack,
// after available recv buffer grows to more than 1 MSS.
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
const rcvBuf = 65535 * 10
c.CreateConnected(context.TestInitialSequenceNumber, 30000, rcvBuf)
// Write chunks of ~30000 bytes. It's important that two
// payloads make it equal or longer than MSS.
remain := rcvBuf
sent := 0
data := make([]byte, e2e.DefaultMTU/2)
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
for remain > len(data) {
c.SendPacket(data, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss.Add(seqnum.Size(sent)),
AckNum: c.IRS.Add(1),
RcvWnd: 30000,
})
sent += len(data)
remain -= len(data)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(sent)),
checker.TCPWindowLessThanEq(0xffff),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
// Increasing the buffer from should generate an ACK,
// since window grew from small value to larger equal MSS
c.EP.SocketOptions().SetReceiveBufferSize(rcvBuf*4, true /* notify */)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v,
checker.PayloadLen(header.TCPMinimumSize),
checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)+uint32(sent)),
checker.TCPWindow(uint16(0xffff)),
checker.TCPFlags(header.TCPFlagAck),
),
)
}
func TestTCPDeferAccept(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(10); err != nil {
t.Fatal("Listen failed:", err)
}
const tcpDeferAccept = 1 * time.Second
tcpDeferAcceptOption := tcpip.TCPDeferAcceptOption(tcpDeferAccept)
if err := c.EP.SetSockOpt(&tcpDeferAcceptOption); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%s)): %s", tcpDeferAcceptOption, tcpDeferAccept, err)
}
irs, iss := executeHandshake(t, c, context.TestPort, false /* synCookiesInUse */)
_, _, err := c.EP.Accept(nil)
if d := cmp.Diff(&tcpip.ErrWouldBlock{}, err); d != "" {
t.Fatalf("c.EP.Accept(nil) mismatch (-want +got):\n%s", d)
}
// Send data. This should result in an acceptable endpoint.
c.SendPacket([]byte{1, 2, 3, 4}, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: irs + 1,
AckNum: iss + 1,
})
// Receive ACK for the data we sent.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPSeqNum(uint32(iss+1)),
checker.TCPAckNum(uint32(irs+5))))
// Give a bit of time for the socket to be delivered to the accept queue.
time.Sleep(50 * time.Millisecond)
aep, _, err := c.EP.Accept(nil)
if err != nil {
t.Fatalf("got c.EP.Accept(nil) = %s, want: nil", err)
}
aep.Close()
// Closing aep without reading the data should trigger a RST.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagRst|header.TCPFlagAck),
checker.TCPSeqNum(uint32(iss+1)),
checker.TCPAckNum(uint32(irs+5))))
}
func TestTCPDeferAcceptTimeout(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.Create(-1)
if err := c.EP.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatal("Bind failed:", err)
}
if err := c.EP.Listen(10); err != nil {
t.Fatal("Listen failed:", err)
}
const tcpDeferAccept = 1 * time.Second
tcpDeferAcceptOpt := tcpip.TCPDeferAcceptOption(tcpDeferAccept)
if err := c.EP.SetSockOpt(&tcpDeferAcceptOpt); err != nil {
t.Fatalf("c.EP.SetSockOpt(&%T(%s)) failed: %s", tcpDeferAcceptOpt, tcpDeferAccept, err)
}
irs, iss := executeHandshake(t, c, context.TestPort, false /* synCookiesInUse */)
_, _, err := c.EP.Accept(nil)
if d := cmp.Diff(&tcpip.ErrWouldBlock{}, err); d != "" {
t.Fatalf("c.EP.Accept(nil) mismatch (-want +got):\n%s", d)
}
// Sleep for a little of the tcpDeferAccept timeout.
time.Sleep(tcpDeferAccept + 100*time.Millisecond)
// On timeout expiry we should get a SYN-ACK retransmission.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagSyn),
checker.TCPAckNum(uint32(irs)+1)))
// Send data. This should result in an acceptable endpoint.
c.SendPacket([]byte{1, 2, 3, 4}, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
SeqNum: irs + 1,
AckNum: iss + 1,
})
// Receive ACK for the data we sent.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPSeqNum(uint32(iss+1)),
checker.TCPAckNum(uint32(irs+5))))
// Give sometime for the endpoint to be delivered to the accept queue.
time.Sleep(50 * time.Millisecond)
aep, _, err := c.EP.Accept(nil)
if err != nil {
t.Fatalf("got c.EP.Accept(nil) = %s, want: nil", err)
}
aep.Close()
// Closing aep without reading the data should trigger a RST.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.SrcPort(context.StackPort),
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagRst|header.TCPFlagAck),
checker.TCPSeqNum(uint32(iss+1)),
checker.TCPAckNum(uint32(irs+5))))
}
func TestResetDuringClose(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRecvBuf */)
// Send some data to make sure there is some unread
// data to trigger a reset on c.Close.
irs := c.IRS
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
c.SendPacket([]byte{1, 2, 3, 4}, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: irs.Add(1),
RcvWnd: 30000,
})
// Receive ACK for the data we sent.
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPFlags(header.TCPFlagAck),
checker.TCPSeqNum(uint32(irs.Add(1))),
checker.TCPAckNum(uint32(iss)+4)))
// Close in a separate goroutine so that we can trigger
// a race with the RST we send below. This should not
// panic due to the route being released depeding on
// whether Close() sends an active RST or the RST sent
// below is processed by the worker first.
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
SeqNum: iss.Add(4),
AckNum: c.IRS.Add(5),
RcvWnd: 30000,
Flags: header.TCPFlagRst,
})
}()
wg.Add(1)
go func() {
defer wg.Done()
c.EP.Close()
}()
wg.Wait()
}
func TestStackTimeWaitReuse(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
s := c.Stack()
var twReuse tcpip.TCPTimeWaitReuseOption
if err := s.TransportProtocolOption(tcp.ProtocolNumber, &twReuse); err != nil {
t.Fatalf("s.TransportProtocolOption(%v, %v) = %v", tcp.ProtocolNumber, &twReuse, err)
}
if got, want := twReuse, tcpip.TCPTimeWaitReuseLoopbackOnly; got != want {
t.Fatalf("got tcpip.TCPTimeWaitReuseOption: %v, want: %v", got, want)
}
}
func TestSetStackTimeWaitReuse(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
s := c.Stack()
testCases := []struct {
v int
err tcpip.Error
}{
{int(tcpip.TCPTimeWaitReuseDisabled), nil},
{int(tcpip.TCPTimeWaitReuseGlobal), nil},
{int(tcpip.TCPTimeWaitReuseLoopbackOnly), nil},
{int(tcpip.TCPTimeWaitReuseLoopbackOnly) + 1, &tcpip.ErrInvalidOptionValue{}},
{int(tcpip.TCPTimeWaitReuseDisabled) - 1, &tcpip.ErrInvalidOptionValue{}},
}
for _, tc := range testCases {
opt := tcpip.TCPTimeWaitReuseOption(tc.v)
err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &opt)
if got, want := err, tc.err; got != want {
t.Fatalf("s.SetTransportProtocolOption(%d, &%T(%d)) = %s, want = %s", tcp.ProtocolNumber, tc.v, tc.v, err, tc.err)
}
if tc.err != nil {
continue
}
var twReuse tcpip.TCPTimeWaitReuseOption
if err := s.TransportProtocolOption(tcp.ProtocolNumber, &twReuse); err != nil {
t.Fatalf("s.TransportProtocolOption(%v, %v) = %v, want nil", tcp.ProtocolNumber, &twReuse, err)
}
if got, want := twReuse, tcpip.TCPTimeWaitReuseOption(tc.v); got != want {
t.Fatalf("got tcpip.TCPTimeWaitReuseOption: %v, want: %v", got, want)
}
}
}
func TestHandshakeRTT(t *testing.T) {
type testCase struct {
connect bool
tsEnabled bool
useCookie bool
retrans bool
delay time.Duration
wantRTT time.Duration
}
var testCases []testCase
for _, connect := range []bool{false, true} {
for _, tsEnabled := range []bool{false, true} {
for _, useCookie := range []bool{false, true} {
for _, retrans := range []bool{false, true} {
if connect && useCookie {
continue
}
delay := 800 * time.Millisecond
if retrans {
delay = 1200 * time.Millisecond
}
wantRTT := delay
// If syncookie is enabled, sample RTT only when TS option is enabled.
if !retrans && useCookie && !tsEnabled {
wantRTT = 0
}
// If retransmitted, sample RTT only when TS option is enabled.
if retrans && !tsEnabled {
wantRTT = 0
}
testCases = append(testCases, testCase{connect, tsEnabled, useCookie, retrans, delay, wantRTT})
}
}
}
}
for _, tt := range testCases {
tt := tt
t.Run(fmt.Sprintf("connect=%t,TS=%t,cookie=%t,retrans=%t)", tt.connect, tt.tsEnabled, tt.useCookie, tt.retrans), func(t *testing.T) {
t.Parallel()
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
if tt.useCookie {
opt := tcpip.TCPAlwaysUseSynCookies(true)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %s", tcp.ProtocolNumber, opt, opt, err)
}
}
synOpts := header.TCPSynOptions{}
if tt.tsEnabled {
synOpts.TS = true
synOpts.TSVal = 42
}
if tt.connect {
c.CreateConnectedWithOptions(synOpts, tt.delay)
} else {
synOpts.MSS = e2e.DefaultIPv4MSS
synOpts.WS = -1
c.AcceptWithOptions(-1, synOpts, tt.delay)
}
var info tcpip.TCPInfoOption
if err := c.EP.GetSockOpt(&info); err != nil {
t.Fatalf("c.EP.GetSockOpt(&%T) = %s", info, err)
}
if got := info.RTT.Round(tt.wantRTT); got != tt.wantRTT {
t.Fatalf("got info.RTT=%s, expect %s", got, tt.wantRTT)
}
if info.RTTVar != 0 && tt.wantRTT == 0 {
t.Fatalf("got info.RTTVar=%s, expect 0", info.RTTVar)
}
if info.RTTVar == 0 && tt.wantRTT != 0 {
t.Fatalf("got info.RTTVar=0, expect non zero")
}
})
}
}
func TestSetRTO(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
minRTO, maxRTO := tcpRTOMinMax(t, c)
c.Cleanup()
for _, tt := range []struct {
name string
RTO time.Duration
minRTO time.Duration
maxRTO time.Duration
err tcpip.Error
}{
{
name: "invalid minRTO",
minRTO: maxRTO + time.Second,
err: &tcpip.ErrInvalidOptionValue{},
},
{
name: "invalid maxRTO",
maxRTO: minRTO - time.Millisecond,
err: &tcpip.ErrInvalidOptionValue{},
},
{
name: "valid minRTO",
minRTO: maxRTO - time.Second,
},
{
name: "valid maxRTO",
maxRTO: minRTO + time.Millisecond,
},
} {
t.Run(tt.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
var opt tcpip.SettableTransportProtocolOption
if tt.minRTO > 0 {
min := tcpip.TCPMinRTOOption(tt.minRTO)
opt = &min
}
if tt.maxRTO > 0 {
max := tcpip.TCPMaxRTOOption(tt.maxRTO)
opt = &max
}
err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, opt)
if got, want := err, tt.err; got != want {
t.Fatalf("c.Stack().SetTransportProtocolOption(TCP, &%T(%v)) = %v, want = %v", opt, opt, got, want)
}
if tt.err == nil {
minRTO, maxRTO := tcpRTOMinMax(t, c)
if tt.minRTO > 0 && tt.minRTO != minRTO {
t.Fatalf("got minRTO = %s, want %s", minRTO, tt.minRTO)
}
if tt.maxRTO > 0 && tt.maxRTO != maxRTO {
t.Fatalf("got maxRTO = %s, want %s", maxRTO, tt.maxRTO)
}
}
})
}
}
func tcpRTOMinMax(t *testing.T, c *context.Context) (time.Duration, time.Duration) {
t.Helper()
var minOpt tcpip.TCPMinRTOOption
var maxOpt tcpip.TCPMaxRTOOption
if err := c.Stack().TransportProtocolOption(tcp.ProtocolNumber, &minOpt); err != nil {
t.Fatalf("c.Stack().TransportProtocolOption(TCP, %T): %s", minOpt, err)
}
if err := c.Stack().TransportProtocolOption(tcp.ProtocolNumber, &maxOpt); err != nil {
t.Fatalf("c.Stack().TransportProtocolOption(TCP, %T): %s", maxOpt, err)
}
return time.Duration(minOpt), time.Duration(maxOpt)
}
// generateRandomPayload generates a random byte slice of the specified length
// causing a fatal test failure if it is unable to do so.
func generateRandomPayload(t *testing.T, n int) []byte {
t.Helper()
buf := make([]byte, n)
if _, err := rand.Read(buf); err != nil {
t.Fatalf("rand.Read(buf) failed: %s", err)
}
return buf
}
func TestSendBufferTuning(t *testing.T) {
const maxPayload = 536
const mtu = header.TCPMinimumSize + header.IPv4MinimumSize + e2e.MaxTCPOptionSize + maxPayload
const packetOverheadFactor = 2
testCases := []struct {
name string
autoTuningDisabled bool
}{
{"autoTuningDisabled", true},
{"autoTuningEnabled", false},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
c := context.New(t, mtu)
defer c.Cleanup()
// Set the stack option for send buffer size.
const defaultSndBufSz = maxPayload * tcp.InitialCwnd
const maxSndBufSz = defaultSndBufSz * 10
{
opt := tcpip.TCPSendBufferSizeRangeOption{Min: 1, Default: defaultSndBufSz, Max: maxSndBufSz}
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%#v): %s", tcp.ProtocolNumber, opt, err)
}
}
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
oldSz := c.EP.SocketOptions().GetSendBufferSize()
if oldSz != defaultSndBufSz {
t.Fatalf("Wrong send buffer size got %d want %d", oldSz, defaultSndBufSz)
}
if tc.autoTuningDisabled {
c.EP.SocketOptions().SetSendBufferSize(defaultSndBufSz, true /* notify */)
}
data := make([]byte, maxPayload)
for i := range data {
data[i] = byte(i)
}
w, ch := waiter.NewChannelEntry(waiter.WritableEvents)
c.WQ.EventRegister(&w)
defer c.WQ.EventUnregister(&w)
bytesRead := 0
for {
// Packets will be sent till the send buffer
// size is reached.
var r bytes.Reader
r.Reset(data[bytesRead : bytesRead+maxPayload])
_, err := c.EP.Write(&r, tcpip.WriteOptions{})
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
break
}
c.ReceiveAndCheckPacketWithOptions(data, bytesRead, maxPayload, 0)
bytesRead += maxPayload
data = append(data, data...)
}
// Send an ACK and wait for connection to become writable again.
c.SendAck(seqnum.Value(context.TestInitialSequenceNumber).Add(1), bytesRead)
select {
case <-ch:
if err := c.EP.LastError(); err != nil {
t.Fatalf("Write failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for connection")
}
outSz := int64(defaultSndBufSz)
if !tc.autoTuningDisabled {
// Calculate the new auto tuned send buffer.
var info tcpip.TCPInfoOption
if err := c.EP.GetSockOpt(&info); err != nil {
t.Fatalf("GetSockOpt failed: %v", err)
}
outSz = int64(info.SndCwnd) * packetOverheadFactor * maxPayload
}
if newSz := c.EP.SocketOptions().GetSendBufferSize(); newSz != outSz {
t.Fatalf("Wrong send buffer size, got %d want %d", newSz, outSz)
}
})
}
}
func TestTimestampSynCookies(t *testing.T) {
clock := faketime.NewManualClock()
tsNow := func() uint32 {
return uint32(clock.NowMonotonic().Sub(tcpip.MonotonicTime{}).Milliseconds())
}
// Advance the clock so that NowMonotonic is non-zero.
clock.Advance(time.Second)
c := context.NewWithOpts(t, context.Options{
EnableV4: true,
EnableV6: true,
MTU: e2e.DefaultMTU,
Clock: clock,
})
defer c.Cleanup()
opt := tcpip.TCPAlwaysUseSynCookies(true)
if err := c.Stack().SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
t.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %s", tcp.ProtocolNumber, opt, opt, err)
}
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer ep.Close()
tcpOpts := [12]byte{header.TCPOptionNOP, header.TCPOptionNOP}
header.EncodeTSOption(42, 0, tcpOpts[2:])
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
iss := seqnum.Value(context.TestInitialSequenceNumber)
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagSyn,
RcvWnd: seqnum.Size(512),
SeqNum: iss,
TCPOpts: tcpOpts[:],
})
// Get the TSVal of SYN-ACK.
b := c.GetPacket()
defer b.Release()
tcpHdr := header.TCP(header.IPv4(b.AsSlice()).Payload())
c.IRS = seqnum.Value(tcpHdr.SequenceNumber())
initialTSVal := tcpHdr.ParsedOptions().TSVal
// derive the tsOffset.
tsOffset := initialTSVal - tsNow()
header.EncodeTSOption(420, initialTSVal, tcpOpts[2:])
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: context.StackPort,
Flags: header.TCPFlagAck,
RcvWnd: seqnum.Size(512),
SeqNum: iss + 1,
AckNum: c.IRS + 1,
TCPOpts: tcpOpts[:],
})
c.EP, _, err = ep.Accept(nil)
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
} else if err != nil {
t.Fatalf("failed to accept: %s", err)
}
// Advance the clock again so that we expect the next TSVal to change.
clock.Advance(time.Second)
data := []byte{1, 2, 3}
var r bytes.Reader
r.Reset(data)
if _, err := c.EP.Write(&r, tcpip.WriteOptions{}); err != nil {
t.Fatalf("Write failed: %s", err)
}
// The endpoint should have a correct TSOffset so that the received TSVal
// should match our expectation.
p := c.GetPacket()
defer p.Release()
if got, want := header.TCP(header.IPv4(p.AsSlice()).Payload()).ParsedOptions().TSVal, tsNow()+tsOffset; got != want {
t.Fatalf("got TSVal = %d, want %d", got, want)
}
}
// TestECNFlagsAccept tests that an ECN non-setup/setup SYN is accepted
// and the connection is correctly completed.
func TestECNFlagsAccept(t *testing.T) {
testCases := []struct {
name string
flags header.TCPFlags
}{
{name: "non-setup ECN SYN w/ ECE", flags: header.TCPFlagEce},
{name: "non-setup ECN SYN w/ CWR", flags: header.TCPFlagCwr},
{name: "setup ECN SYN", flags: header.TCPFlagEce | header.TCPFlagCwr},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
// Create EP and start listening.
wq := &waiter.Queue{}
ep, err := c.Stack().NewEndpoint(tcp.ProtocolNumber, ipv4.ProtocolNumber, wq)
if err != nil {
t.Fatalf("NewEndpoint failed: %s", err)
}
defer ep.Close()
if err := ep.Bind(tcpip.FullAddress{Port: context.StackPort}); err != nil {
t.Fatalf("Bind failed: %s", err)
}
if err := ep.Listen(10); err != nil {
t.Fatalf("Listen failed: %s", err)
}
// Do 3-way handshake.
const maxPayload = 100
c.PassiveConnect(maxPayload, -1 /* wndScale */, header.TCPSynOptions{MSS: e2e.DefaultIPv4MSS, Flags: tc.flags})
// Try to accept the connection.
we, ch := waiter.NewChannelEntry(waiter.ReadableEvents)
wq.EventRegister(&we)
defer wq.EventUnregister(&we)
c.EP, _, err = ep.Accept(nil)
if cmp.Equal(&tcpip.ErrWouldBlock{}, err) {
// Wait for connection to be established.
select {
case <-ch:
c.EP, _, err = ep.Accept(nil)
if err != nil {
t.Fatalf("Accept failed: %s", err)
}
case <-time.After(1 * time.Second):
t.Fatalf("Timed out waiting for accept")
}
} else if err != nil {
t.Fatalf("Accept failed: %s", err)
}
})
}
}
func TestReadAfterCloseWithBufferedData(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
con := c.CreateConnectedWithOptionsNoDelay(header.TCPSynOptions{})
// Fill up the receive queue.
for i := 0; i < 300; i++ {
con.SendPacket([]byte{1, 2, 3, 4}, nil)
}
timeout := time.After(5 * time.Second)
// If the receive queue is not properly drained, the endpoint will never
// return ErrClosedForReceive.
c.EP.Close()
for {
select {
case <-timeout:
t.Fatalf("timed out waiting for read to return error %q", &tcpip.ErrClosedForReceive{})
return
default:
if _, err := c.EP.Read(ioutil.Discard, tcpip.ReadOptions{}); cmp.Equal(err, &tcpip.ErrClosedForReceive{}) {
return
}
}
}
}
func TestReleaseDanglingEndpoints(t *testing.T) {
c := context.New(t, e2e.DefaultMTU)
defer c.Cleanup()
c.CreateConnected(context.TestInitialSequenceNumber, 30000, -1 /* epRcvBuf */)
ep := c.EP
c.EP = nil
// Close the endpoint, make sure we get a FIN segment. The endpoint should be
// dangling.
ep.Close()
iss := seqnum.Value(context.TestInitialSequenceNumber).Add(1)
v := c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+1),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagAck|header.TCPFlagFin),
))
tcpip.ReleaseDanglingEndpoints()
// ReleaseDanglingEndpoints should abort the half-closed endpoint causing
// a RST to be sent.
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+2),
checker.TCPAckNum(uint32(iss)),
checker.TCPFlags(header.TCPFlagRst|header.TCPFlagAck),
))
// Now send an ACK and it should trigger a RST as the endpoint is aborted.
c.SendPacket(nil, &context.Headers{
SrcPort: context.TestPort,
DstPort: c.Port,
Flags: header.TCPFlagAck,
SeqNum: iss,
AckNum: c.IRS.Add(2),
RcvWnd: 30000,
})
v = c.GetPacket()
defer v.Release()
checker.IPv4(t, v, checker.TCP(
checker.DstPort(context.TestPort),
checker.TCPSeqNum(uint32(c.IRS)+2),
checker.TCPAckNum(0),
checker.TCPFlags(header.TCPFlagRst),
))
}
func TestMain(m *testing.M) {
refs.SetLeakMode(refs.LeaksPanic)
code := m.Run()
tcpip.ReleaseDanglingEndpoints()
// Allow TCP async work to complete to avoid false reports of leaks.
// TODO(gvisor.dev/issue/5940): Use fake clock in tests.
time.Sleep(1 * time.Second)
refs.DoLeakCheck()
os.Exit(code)
}
|
package hash
import (
"testing"
)
func Test_Hash(t *testing.T) {
msg := []byte("this is a test msg")
sha256 := UsingSha256(msg)
doubleSha256 := DoubleSha256(msg)
ripemd160 := UsingRipemd160(msg)
seed := []byte("this is seed")
hmac512 := HashUsingHmac512(seed, msg)
t.Logf("sha256=%v, doubleSha256=%v, ripemd160=%v, hmac512=%v\n", sha256, doubleSha256, ripemd160, hmac512)
}
|
//Collection functions
package main
import (
"fmt"
"strings"
)
func Index(vs []string, s string) int {
for i, e := range vs {
if e == s {
return i
}
}
return -1
}
func Include(vs []string, s string) bool {
return Index(vs, s) >= 0
}
func Any(vs []string, f func(string) bool) bool {
for _, e := range vs {
if f(e) {
return true
}
}
return false
}
func All(vs []string, f func(string) bool) bool {
for _, e := range vs {
if !f(e) {
return false
}
}
return true
}
func Filter(vs []string, f func(string) bool) []string {
filtered := []string{}
for _, e := range vs {
if f(e) {
filtered = append(filtered, e)
}
}
return filtered
}
func Map(vs []string, f func(string) string) []string {
mapped := make([]string, len(vs))
for i, e := range vs {
mapped[i] = f(e)
}
return mapped
}
func main() {
testSlice := []string{"boo", "bah", "gahgah", "booboo"}
fmt.Println("testSlice:", testSlice)
fmt.Println("Does slice include 'boo' ? :", Include(testSlice, "boo"))
fmt.Println("Where does it include 'boo' ? :", Index(testSlice, "boo"))
fmt.Println("Do any of the strings start with 'a' ? :", Any(testSlice, func(s string) bool {
return string(s[0]) == "a"
}))
fmt.Println("Do any of the strings start with 'g' ? :", Any(testSlice, func(s string) bool {
return string(s[0]) == "g"
}))
fmt.Println("Do all the strings contain the letter b? : ", All(testSlice, func(s string) bool {
for _, e := range s {
if string(e) == "b" {
return true
}
}
return false
}))
fmt.Println("Do all of the strings have 3 or more characters? :", All(testSlice, func(s string) bool {
return len(s) >= 3
}))
fmt.Println("Filter out any string without the substring 'boo' in it somewhere", Filter(testSlice, func(s string) bool {
substring := "boo"
for i := 0; i <= (len(s) - len(substring)); i++ {
match := 1
for j := 0; j < len(substring); j++ {
if s[i+j] != substring[j] {
match = 0
break
}
}
if match == 1 {
return true
}
}
return false
}))
fmt.Println("Filter out any string without the substring 'ah' in it somewhere", Filter(testSlice, func(s string) bool {
return strings.Contains(s, "ah")
}))
fmt.Println("Map by concatenating each string to itself: ", Map(testSlice, func(s string) string {
return strings.Join([]string{s, s}, "")
}))
}
|
package capability
import (
"context"
"reflect"
dynatracev1beta1 "github.com/Dynatrace/dynatrace-operator/src/api/v1beta1"
"github.com/Dynatrace/dynatrace-operator/src/controllers"
"github.com/Dynatrace/dynatrace-operator/src/controllers/dynakube/activegate/capability"
"github.com/Dynatrace/dynatrace-operator/src/kubeobjects"
"github.com/pkg/errors"
corev1 "k8s.io/api/core/v1"
k8serrors "k8s.io/apimachinery/pkg/api/errors"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
)
var _ controllers.Reconciler = &Reconciler{}
type Reconciler struct {
client client.Client
capability capability.Capability
statefulsetReconciler controllers.Reconciler
customPropertiesReconciler controllers.Reconciler
dynakube *dynatracev1beta1.DynaKube
}
func NewReconciler(clt client.Client, capability capability.Capability, dynakube *dynatracev1beta1.DynaKube, statefulsetReconciler controllers.Reconciler, customPropertiesReconciler controllers.Reconciler) *Reconciler { //nolint:revive // argument-limit doesn't apply to constructors
return &Reconciler{
statefulsetReconciler: statefulsetReconciler,
customPropertiesReconciler: customPropertiesReconciler,
capability: capability,
dynakube: dynakube,
client: clt,
}
}
type NewReconcilerFunc = func(clt client.Client, capability capability.Capability, dynakube *dynatracev1beta1.DynaKube, statefulsetReconciler controllers.Reconciler, customPropertiesReconciler controllers.Reconciler) *Reconciler
func (r *Reconciler) Reconcile() error {
err := r.customPropertiesReconciler.Reconcile()
if err != nil {
return errors.WithStack(err)
}
if r.dynakube.NeedsActiveGateService() {
err = r.createOrUpdateService()
if err != nil {
return errors.WithStack(err)
}
}
err = r.statefulsetReconciler.Reconcile()
return errors.WithStack(err)
}
func (r *Reconciler) createOrUpdateService() error {
desired := CreateService(r.dynakube, r.capability.ShortName())
installed := &corev1.Service{}
err := r.client.Get(context.TODO(), kubeobjects.Key(desired), installed)
if k8serrors.IsNotFound(err) {
log.Info("creating AG service", "module", r.capability.ShortName())
err = controllerutil.SetControllerReference(r.dynakube, desired, r.client.Scheme())
if err != nil {
return errors.WithStack(err)
}
err = r.client.Create(context.TODO(), desired)
return errors.WithStack(err)
}
if err != nil {
return errors.WithStack(err)
}
if r.portsAreOutdated(installed, desired) || r.labelsAreOutdated(installed, desired) {
desired.Spec.ClusterIP = installed.Spec.ClusterIP
desired.ObjectMeta.ResourceVersion = installed.ObjectMeta.ResourceVersion
err = r.client.Update(context.TODO(), desired)
if err != nil {
return err
}
}
return nil
}
func (r *Reconciler) portsAreOutdated(installedService, desiredService *corev1.Service) bool {
return !reflect.DeepEqual(installedService.Spec.Ports, desiredService.Spec.Ports)
}
func (r *Reconciler) labelsAreOutdated(installedService, desiredService *corev1.Service) bool {
return !reflect.DeepEqual(installedService.Labels, desiredService.Labels) ||
!reflect.DeepEqual(installedService.Spec.Selector, desiredService.Spec.Selector)
}
|
package avl
import (
"fmt"
)
//func ExampleLeftRotationAndRightRotationAVLTree() {
// t := &Tree{}
// for _, v := range []int{14, 8, 24, 2, 11, 1} {
// t.Add(v)
// }
//
// for v := range t.Preorder() {
// fmt.Printf(" %d", v)
// }
// fmt.Println()
//
// t.rightRotation(t.root.Left)
// for v := range t.Preorder() {
// fmt.Printf(" %d", v)
// }
// fmt.Println()
//
// t.leftRotation(t.root.Left)
// for v := range t.Preorder() {
// fmt.Printf(" %d", v)
// }
// fmt.Println()
//
// // Output:
// // 14 8 2 1 11 24
// // 14 2 1 8 11 24
// // 14 8 2 1 11 24
//}
//
//func ExampleLeftRightRotationAVLTree() {
// t := &Tree{}
// for _, v := range []int{5, 3, 4} {
// t.Add(v)
// }
//
// for v := range t.Preorder() {
// fmt.Printf(" %d", v)
// }
// fmt.Println()
//
// t.leftRightRotation(t.root)
// for v := range t.Preorder() {
// fmt.Printf(" %d", v)
// }
// fmt.Println()
//
// // Output:
// // 5 3 4
// // 4 3 5
//}
//
//func ExampleRightLeftRotationAVLTree() {
// t := &Tree{}
// for _, v := range []int{1, 5, 4} {
// t.Add(v)
// }
//
// for v := range t.Preorder() {
// fmt.Printf(" %d", v)
// }
// fmt.Println()
//
// t.rightLeftRotation(t.root)
// for v := range t.Preorder() {
// fmt.Printf(" %d", v)
// }
// fmt.Println()
//
// // Output:
// // 1 5 4
// // 4 1 5
//}
func ExampleLeftCheckBalance() {
t := &Tree{}
for _, v := range []int{1, 2, 3} {
t.Add(v)
}
t.CheckBalance(t.root)
for v := range t.Preorder() {
fmt.Printf(" %d", v)
}
fmt.Println()
// Output:
// 2 1 3
}
func ExampleRightCheckBalance() {
t := &Tree{}
for _, v := range []int{3, 2, 1} {
t.Add(v)
}
t.CheckBalance(t.root)
for v := range t.Preorder() {
fmt.Printf(" %d", v)
}
fmt.Println()
// Output:
// 2 1 3
}
func ExampleLeftRightCheckBalance() {
t := &Tree{}
for _, v := range []int{3, 1, 2} {
t.Add(v)
}
t.CheckBalance(t.root)
for v := range t.Preorder() {
fmt.Printf(" %d", v)
}
fmt.Println()
// Output:
// 2 1 3
}
//func ExampleRightLeftCheckBalance() {
// t := &Tree{}
// for _, v := range []int{1, 3, 2} {
// t.Add(v)
// }
//
// t.CheckBalance(t.root)
//
// for v := range t.Preorder() {
// fmt.Printf(" %d", v)
// }
// fmt.Println()
//
// // Output:
// // 2 1 3
//}
func ExampleAVLTree() {
t := &Tree{}
for _, v := range []int{2, 8, 11, 15, 14, 24} {
t.Add(v)
}
for v := range t.Preorder() {
fmt.Printf(" %d", v)
}
fmt.Println()
for v := range t.Inorder() {
fmt.Printf(" %d", v)
}
fmt.Println()
t.Remove(24)
for v := range t.Preorder() {
fmt.Printf(" %d", v)
}
fmt.Println()
t.Remove(8)
for v := range t.Preorder() {
fmt.Printf(" %d", v)
}
fmt.Println()
t.Remove(14)
t.Remove(2)
for v := range t.Preorder() {
fmt.Printf(" %d", v)
}
fmt.Println()
// Output:
// 14 8 2 11 15 24
// 2 8 11 14 15 24
// 14 8 2 11 15
// 14 2 11 15
// 11 15
}
|
package challenge_1
import (
"encoding/base64"
"encoding/hex"
"log"
)
func DecodeHex(src []byte) []byte {
dst := make([]byte, hex.DecodedLen(len(src)))
_, err := hex.Decode(dst, src)
if err != nil {
log.Fatal(err)
}
return dst
}
func hexToBase64(src []byte) []byte {
dst := DecodeHex(src)
base64Dst := make([]byte, base64.StdEncoding.EncodedLen(len(dst)))
base64.StdEncoding.Encode(base64Dst, dst)
return base64Dst
}
|
/*
Copyright 2020 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package pipelinelooprun
import (
"context"
"encoding/json"
"fmt"
"reflect"
"strconv"
"time"
"github.com/hashicorp/go-multierror"
"github.com/tektoncd/experimental/pipeline-loops/pkg/apis/pipelineloop"
pipelineloopv1alpha1 "github.com/tektoncd/experimental/pipeline-loops/pkg/apis/pipelineloop/v1alpha1"
pipelineloopclientset "github.com/tektoncd/experimental/pipeline-loops/pkg/client/clientset/versioned"
listerspipelineloop "github.com/tektoncd/experimental/pipeline-loops/pkg/client/listers/pipelineloop/v1alpha1"
"github.com/tektoncd/pipeline/pkg/apis/pipeline"
"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1"
clientset "github.com/tektoncd/pipeline/pkg/client/clientset/versioned"
runreconciler "github.com/tektoncd/pipeline/pkg/client/injection/reconciler/pipeline/v1alpha1/run"
listersalpha "github.com/tektoncd/pipeline/pkg/client/listers/pipeline/v1alpha1"
listers "github.com/tektoncd/pipeline/pkg/client/listers/pipeline/v1beta1"
"github.com/tektoncd/pipeline/pkg/names"
"github.com/tektoncd/pipeline/pkg/reconciler/events"
"go.uber.org/zap"
"gomodules.xyz/jsonpatch/v2"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/types"
"knative.dev/pkg/apis"
"knative.dev/pkg/logging"
pkgreconciler "knative.dev/pkg/reconciler"
)
const (
// pipelineLoopLabelKey is the label identifier for a PipelineLoop. This label is added to the Run and its PipelineRuns.
pipelineLoopLabelKey = "/pipelineLoop"
// pipelineLoopRunLabelKey is the label identifier for a Run. This label is added to the Run's PipelineRuns.
pipelineLoopRunLabelKey = "/run"
// pipelineLoopIterationLabelKey is the label identifier for the iteration number. This label is added to the Run's PipelineRuns.
pipelineLoopIterationLabelKey = "/pipelineLoopIteration"
)
// Reconciler implements controller.Reconciler for Configuration resources.
type Reconciler struct {
pipelineClientSet clientset.Interface
pipelineloopClientSet pipelineloopclientset.Interface
runLister listersalpha.RunLister
pipelineLoopLister listerspipelineloop.PipelineLoopLister
pipelineRunLister listers.PipelineRunLister
}
var (
// Check that our Reconciler implements runreconciler.Interface
_ runreconciler.Interface = (*Reconciler)(nil)
)
// ReconcileKind compares the actual state with the desired, and attempts to converge the two.
// It then updates the Status block of the Run resource with the current status of the resource.
func (c *Reconciler) ReconcileKind(ctx context.Context, run *v1alpha1.Run) pkgreconciler.Event {
var merr error
logger := logging.FromContext(ctx)
logger.Infof("Reconciling Run %s/%s at %v", run.Namespace, run.Name, time.Now())
// Check that the Run references a PipelineLoop CRD. The logic is controller.go should ensure that only this type of Run
// is reconciled this controller but it never hurts to do some bullet-proofing.
if run.Spec.Ref == nil ||
run.Spec.Ref.APIVersion != pipelineloopv1alpha1.SchemeGroupVersion.String() ||
run.Spec.Ref.Kind != pipelineloop.PipelineLoopControllerName {
logger.Errorf("Received control for a Run %s/%s that does not reference a PipelineLoop custom CRD", run.Namespace, run.Name)
return nil
}
// If the Run has not started, initialize the Condition and set the start time.
if !run.HasStarted() {
logger.Infof("Starting new Run %s/%s", run.Namespace, run.Name)
run.Status.InitializeConditions()
// In case node time was not synchronized, when controller has been scheduled to other nodes.
if run.Status.StartTime.Sub(run.CreationTimestamp.Time) < 0 {
logger.Warnf("Run %s createTimestamp %s is after the Run started %s", run.Name, run.CreationTimestamp, run.Status.StartTime)
run.Status.StartTime = &run.CreationTimestamp
}
// Emit events. During the first reconcile the status of the Run may change twice
// from not Started to Started and then to Running, so we need to sent the event here
// and at the end of 'Reconcile' again.
// We also want to send the "Started" event as soon as possible for anyone who may be waiting
// on the event to perform user facing initialisations, such has reset a CI check status
afterCondition := run.Status.GetCondition(apis.ConditionSucceeded)
events.Emit(ctx, nil, afterCondition, run)
}
if run.IsDone() {
logger.Infof("Run %s/%s is done", run.Namespace, run.Name)
return nil
}
// Store the condition before reconcile
beforeCondition := run.Status.GetCondition(apis.ConditionSucceeded)
status := &pipelineloopv1alpha1.PipelineLoopRunStatus{}
if err := run.Status.DecodeExtraFields(status); err != nil {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonInternalError.String(),
"Internal error calling DecodeExtraFields: %v", err)
logger.Errorf("DecodeExtraFields error: %v", err.Error())
}
// Reconcile the Run
if err := c.reconcile(ctx, run, status); err != nil {
logger.Errorf("Reconcile error: %v", err.Error())
merr = multierror.Append(merr, err)
}
if err := c.updateLabelsAndAnnotations(ctx, run); err != nil {
logger.Warn("Failed to update Run labels/annotations", zap.Error(err))
merr = multierror.Append(merr, err)
}
if err := run.Status.EncodeExtraFields(status); err != nil {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonInternalError.String(),
"Internal error calling EncodeExtraFields: %v", err)
logger.Errorf("EncodeExtraFields error: %v", err.Error())
}
afterCondition := run.Status.GetCondition(apis.ConditionSucceeded)
events.Emit(ctx, beforeCondition, afterCondition, run)
// Only transient errors that should retry the reconcile are returned.
return merr
}
func (c *Reconciler) reconcile(ctx context.Context, run *v1alpha1.Run, status *pipelineloopv1alpha1.PipelineLoopRunStatus) error {
logger := logging.FromContext(ctx)
// Get the PipelineLoop referenced by the Run
pipelineLoopMeta, pipelineLoopSpec, err := c.getPipelineLoop(ctx, run)
if err != nil {
return nil
}
// Store the fetched PipelineLoopSpec on the Run for auditing
storePipelineLoopSpec(status, pipelineLoopSpec)
// Propagate labels and annotations from PipelineLoop to Run.
propagatePipelineLoopLabelsAndAnnotations(run, pipelineLoopMeta)
// Validate PipelineLoop spec
if err := pipelineLoopSpec.Validate(ctx); err != nil {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonFailedValidation.String(),
"PipelineLoop %s/%s can't be Run; it has an invalid spec: %s",
pipelineLoopMeta.Namespace, pipelineLoopMeta.Name, err)
return nil
}
// Determine how many iterations of the Task will be done.
totalIterations, err := computeIterations(run, pipelineLoopSpec)
if err != nil {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonFailedValidation.String(),
"Cannot determine number of iterations: %s", err)
return nil
}
// Update status of PipelineRuns. Return the PipelineRun representing the highest loop iteration.
highestIteration, highestIterationPr, err := c.updatePipelineRunStatus(logger, run, status)
if err != nil {
return fmt.Errorf("error updating PipelineRun status for Run %s/%s: %w", run.Namespace, run.Name, err)
}
// Check the status of the PipelineRun for the highest iteration.
if highestIterationPr != nil {
// If it's not done, wait for it to finish or cancel it if the run is cancelled.
if !highestIterationPr.IsDone() {
if run.IsCancelled() {
logger.Infof("Run %s/%s is cancelled. Cancelling PipelineRun %s.", run.Namespace, run.Name, highestIterationPr.Name)
b, err := getCancelPatch()
if err != nil {
return fmt.Errorf("Failed to make patch to cancel PipelineRun %s: %v", highestIterationPr.Name, err)
}
if _, err := c.pipelineClientSet.TektonV1beta1().PipelineRuns(run.Namespace).Patch(ctx, highestIterationPr.Name, types.JSONPatchType, b, metav1.PatchOptions{}); err != nil {
run.Status.MarkRunRunning(pipelineloopv1alpha1.PipelineLoopRunReasonCouldntCancel.String(),
"Failed to patch PipelineRun `%s` with cancellation: %v", highestIterationPr.Name, err)
return nil
}
// Update status. It is still running until the PipelineRun is actually cancelled.
run.Status.MarkRunRunning(pipelineloopv1alpha1.PipelineLoopRunReasonRunning.String(),
"Cancelling PipelineRun %s", highestIterationPr.Name)
return nil
}
run.Status.MarkRunRunning(pipelineloopv1alpha1.PipelineLoopRunReasonRunning.String(),
"Iterations completed: %d", highestIteration-1)
return nil
}
if !highestIterationPr.Status.GetCondition(apis.ConditionSucceeded).IsTrue() {
if run.IsCancelled() {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonCancelled.String(),
"Run %s/%s was cancelled",
run.Namespace, run.Name)
} else {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonFailed.String(),
"PipelineRun %s has failed", highestIterationPr.Name)
}
return nil
}
// Mark run successful if the condition are met.
// if the last loop task is skipped, but the highestIterationPr successed. Mark run success.
// lastLoopTask := highestIterationPr.ObjectMeta.Annotations["last-loop-task"]
lastLoopTask := ""
for key, val := range run.ObjectMeta.Labels {
if key == "last-loop-task" {
lastLoopTask = val
}
}
if lastLoopTask != "" {
skippedTaskList := highestIterationPr.Status.SkippedTasks
for _, task := range skippedTaskList {
if task.Name == lastLoopTask {
// Mark run successful and stop the loop pipelinerun
run.Status.MarkRunSucceeded(pipelineloopv1alpha1.PipelineLoopRunReasonSucceeded.String(),
"PipelineRuns completed successfully with the conditions are met")
run.Status.Results = []v1beta1.TaskRunResult{{
Name: "condition",
Value: "pass",
}}
return nil
}
}
}
}
// Move on to the next iteration (or the first iteration if there was no PipelineRun).
// Check if the Run is done.
nextIteration := highestIteration + 1
if nextIteration > totalIterations {
run.Status.MarkRunSucceeded(pipelineloopv1alpha1.PipelineLoopRunReasonSucceeded.String(),
"All PipelineRuns completed successfully")
run.Status.Results = []v1beta1.TaskRunResult{{
Name: "condition",
Value: "fail",
}}
return nil
}
// Before starting up another PipelineRun, check if the run was cancelled.
if run.IsCancelled() {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonCancelled.String(),
"Run %s/%s was cancelled",
run.Namespace, run.Name)
return nil
}
// Create a PipelineRun to run this iteration.
pr, err := c.createPipelineRun(ctx, logger, pipelineLoopSpec, run, nextIteration)
if err != nil {
return fmt.Errorf("error creating PipelineRun from Run %s: %w", run.Name, err)
}
status.PipelineRuns[pr.Name] = &pipelineloopv1alpha1.PipelineLoopPipelineRunStatus{
Iteration: nextIteration,
Status: &pr.Status,
}
run.Status.MarkRunRunning(pipelineloopv1alpha1.PipelineLoopRunReasonRunning.String(),
"Iterations completed: %d", highestIteration)
return nil
}
func (c *Reconciler) getPipelineLoop(ctx context.Context, run *v1alpha1.Run) (*metav1.ObjectMeta, *pipelineloopv1alpha1.PipelineLoopSpec, error) {
pipelineLoopMeta := metav1.ObjectMeta{}
pipelineLoopSpec := pipelineloopv1alpha1.PipelineLoopSpec{}
if run.Spec.Ref != nil && run.Spec.Ref.Name != "" {
// Use the k8 client to get the PipelineLoop rather than the lister. This avoids a timing issue where
// the PipelineLoop is not yet in the lister cache if it is created at nearly the same time as the Run.
// See https://github.com/tektoncd/pipeline/issues/2740 for discussion on this issue.
//
// tl, err := c.pipelineLoopLister.PipelineLoops(run.Namespace).Get(run.Spec.Ref.Name)
tl, err := c.pipelineloopClientSet.CustomV1alpha1().PipelineLoops(run.Namespace).Get(ctx, run.Spec.Ref.Name, metav1.GetOptions{})
if err != nil {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonCouldntGetPipelineLoop.String(),
"Error retrieving PipelineLoop for Run %s/%s: %s",
run.Namespace, run.Name, err)
return nil, nil, fmt.Errorf("Error retrieving PipelineLoop for Run %s: %w", fmt.Sprintf("%s/%s", run.Namespace, run.Name), err)
}
pipelineLoopMeta = tl.ObjectMeta
pipelineLoopSpec = tl.Spec
} else {
// Run does not require name but for PipelineLoop it does.
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonCouldntGetPipelineLoop.String(),
"Missing spec.ref.name for Run %s/%s",
run.Namespace, run.Name)
return nil, nil, fmt.Errorf("Missing spec.ref.name for Run %s", fmt.Sprintf("%s/%s", run.Namespace, run.Name))
}
return &pipelineLoopMeta, &pipelineLoopSpec, nil
}
func (c *Reconciler) createPipelineRun(ctx context.Context, logger *zap.SugaredLogger, tls *pipelineloopv1alpha1.PipelineLoopSpec, run *v1alpha1.Run, iteration int) (*v1beta1.PipelineRun, error) {
// Create name for PipelineRun from Run name plus iteration number.
prName := names.SimpleNameGenerator.RestrictLengthWithRandomSuffix(fmt.Sprintf("%s-%s", run.Name, fmt.Sprintf("%05d", iteration)))
pr := &v1beta1.PipelineRun{
ObjectMeta: metav1.ObjectMeta{
Name: prName,
Namespace: run.Namespace,
OwnerReferences: []metav1.OwnerReference{run.GetOwnerReference()},
Labels: getPipelineRunLabels(run, strconv.Itoa(iteration)),
Annotations: getPipelineRunAnnotations(run),
},
Spec: v1beta1.PipelineRunSpec{
Params: getParameters(run, tls, iteration),
Timeout: tls.Timeout,
ServiceAccountName: "", // TODO: Implement service account name
PodTemplate: nil, // TODO: Implement pod template
}}
if tls.PipelineRef != nil {
pr.Spec.PipelineRef = &v1beta1.PipelineRef{
Name: tls.PipelineRef.Name,
// Kind: tls.PipelineRef.Kind,
}
} else if tls.PipelineSpec != nil {
pr.Spec.PipelineSpec = tls.PipelineSpec
}
logger.Infof("Creating a new PipelineRun object %s", prName)
return c.pipelineClientSet.TektonV1beta1().PipelineRuns(run.Namespace).Create(ctx, pr, metav1.CreateOptions{})
}
// func (c *Reconciler) retryPipelineRun(ctx context.Context, tr *v1beta1.PipelineRun) (*v1beta1.PipelineRun, error) {
// newStatus := *tr.Status.DeepCopy()
// newStatus.RetriesStatus = nil
// tr.Status.RetriesStatus = append(tr.Status.RetriesStatus, newStatus)
// tr.Status.StartTime = nil
// tr.Status.CompletionTime = nil
// tr.Status.PodName = ""
// tr.Status.SetCondition(&apis.Condition{
// Type: apis.ConditionSucceeded,
// Status: corev1.ConditionUnknown,
// })
// return c.pipelineClientSet.TektonV1beta1().PipelineRuns(tr.Namespace).UpdateStatus(ctx, tr, metav1.UpdateOptions{})
// }
func (c *Reconciler) updateLabelsAndAnnotations(ctx context.Context, run *v1alpha1.Run) error {
newRun, err := c.runLister.Runs(run.Namespace).Get(run.Name)
if err != nil {
return fmt.Errorf("error getting Run %s when updating labels/annotations: %w", run.Name, err)
}
if !reflect.DeepEqual(run.ObjectMeta.Labels, newRun.ObjectMeta.Labels) || !reflect.DeepEqual(run.ObjectMeta.Annotations, newRun.ObjectMeta.Annotations) {
mergePatch := map[string]interface{}{
"metadata": map[string]interface{}{
"labels": run.ObjectMeta.Labels,
"annotations": run.ObjectMeta.Annotations,
},
}
patch, err := json.Marshal(mergePatch)
if err != nil {
return err
}
_, err = c.pipelineClientSet.TektonV1alpha1().Runs(run.Namespace).Patch(ctx, run.Name, types.MergePatchType, patch, metav1.PatchOptions{})
return err
}
return nil
}
func (c *Reconciler) updatePipelineRunStatus(logger *zap.SugaredLogger, run *v1alpha1.Run, status *pipelineloopv1alpha1.PipelineLoopRunStatus) (int, *v1beta1.PipelineRun, error) {
highestIteration := 0
var highestIterationPr *v1beta1.PipelineRun = nil
if status.PipelineRuns == nil {
status.PipelineRuns = make(map[string]*pipelineloopv1alpha1.PipelineLoopPipelineRunStatus)
}
pipelineRunLabels := getPipelineRunLabels(run, "")
pipelineRuns, err := c.pipelineRunLister.PipelineRuns(run.Namespace).List(labels.SelectorFromSet(pipelineRunLabels))
if err != nil {
return 0, nil, fmt.Errorf("could not list PipelineRuns %#v", err)
}
if pipelineRuns == nil || len(pipelineRuns) == 0 {
return 0, nil, nil
}
for _, pr := range pipelineRuns {
lbls := pr.GetLabels()
iterationStr := lbls[pipelineloop.GroupName+pipelineLoopIterationLabelKey]
iteration, err := strconv.Atoi(iterationStr)
if err != nil {
run.Status.MarkRunFailed(pipelineloopv1alpha1.PipelineLoopRunReasonFailedValidation.String(),
"Error converting iteration number in PipelineRun %s: %#v", pr.Name, err)
logger.Errorf("Error converting iteration number in PipelineRun %s: %#v", pr.Name, err)
return 0, nil, nil
}
status.PipelineRuns[pr.Name] = &pipelineloopv1alpha1.PipelineLoopPipelineRunStatus{
Iteration: iteration,
Status: &pr.Status,
}
if iteration > highestIteration {
highestIteration = iteration
highestIterationPr = pr
}
}
return highestIteration, highestIterationPr, nil
}
func getCancelPatch() ([]byte, error) {
patches := []jsonpatch.JsonPatchOperation{{
Operation: "add",
Path: "/spec/status",
Value: v1beta1.PipelineRunSpecStatusCancelled,
}}
patchBytes, err := json.Marshal(patches)
if err != nil {
return nil, fmt.Errorf("failed to marshal patch bytes in order to cancel: %v", err)
}
return patchBytes, nil
}
func computeIterations(run *v1alpha1.Run, tls *pipelineloopv1alpha1.PipelineLoopSpec) (int, error) {
// Find the iterate parameter.
numberOfIterations := -1
from := -1
step := -1
to := -1
for _, p := range run.Spec.Params {
if tls.IterateNumeric != "" {
if p.Name == "from" {
from, _ = strconv.Atoi(p.Value.StringVal)
}
if p.Name == "step" {
step, _ = strconv.Atoi(p.Value.StringVal)
}
if p.Name == "to" {
to, _ = strconv.Atoi(p.Value.StringVal)
}
} else if p.Name == tls.IterateParam {
if p.Value.Type == v1beta1.ParamTypeString {
// Transfer p.Value to Array.
var strings []string
var ints []int
var dictsString []map[string]string
var dictsInt []map[string]int
errString := json.Unmarshal([]byte(p.Value.StringVal), &strings)
errInt := json.Unmarshal([]byte(p.Value.StringVal), &ints)
errDictString := json.Unmarshal([]byte(p.Value.StringVal), &dictsString)
errDictInt := json.Unmarshal([]byte(p.Value.StringVal), &dictsInt)
if errString != nil && errInt != nil && errDictString != nil && errDictInt != nil {
return 0, fmt.Errorf("The value of the iterate parameter %q can not transfer to array", tls.IterateParam)
}
if errString == nil {
numberOfIterations = len(strings)
break
} else if errInt == nil {
numberOfIterations = len(ints)
break
} else if errDictString == nil {
numberOfIterations = len(dictsString)
break
} else if errDictInt == nil {
numberOfIterations = len(dictsInt)
break
}
}
if p.Value.Type == v1beta1.ParamTypeArray {
numberOfIterations = len(p.Value.ArrayVal)
break
}
}
}
if tls.IterateNumeric != "" {
if from == -1 || to == -1 {
return 0, fmt.Errorf("The from or to parameters was not found in runs")
}
if step == -1 {
step = 1
}
// numberOfIterations is the number of (to - from) / step + 1
numberOfIterations = (to-from)/step + 1
} else if numberOfIterations == -1 {
return 0, fmt.Errorf("The iterate parameter %q was not found", tls.IterateParam)
}
return numberOfIterations, nil
}
func getParameters(run *v1alpha1.Run, tls *pipelineloopv1alpha1.PipelineLoopSpec, iteration int) []v1beta1.Param {
var out []v1beta1.Param
if tls.IterateParam != "" {
// IterateParam defined
for i, p := range run.Spec.Params {
if p.Name == tls.IterateParam {
if p.Value.Type == v1beta1.ParamTypeArray {
out = append(out, v1beta1.Param{
Name: p.Name,
Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeString, StringVal: p.Value.ArrayVal[iteration-1]},
})
}
if p.Value.Type == v1beta1.ParamTypeString {
var strings []string
var ints []int
var dictsString []map[string]string
var dictsInt []map[string]int
errString := json.Unmarshal([]byte(p.Value.StringVal), &strings)
errInt := json.Unmarshal([]byte(p.Value.StringVal), &ints)
errDictString := json.Unmarshal([]byte(p.Value.StringVal), &dictsString)
errDictInt := json.Unmarshal([]byte(p.Value.StringVal), &dictsInt)
if errString == nil {
out = append(out, v1beta1.Param{
Name: p.Name,
Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeString, StringVal: strings[iteration-1]},
})
} else if errInt == nil {
out = append(out, v1beta1.Param{
Name: p.Name,
Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeString, StringVal: strconv.Itoa(ints[iteration-1])},
})
} else if errDictString == nil {
for dictParam := range dictsString[iteration-1] {
out = append(out, v1beta1.Param{
Name: p.Name + "-subvar-" + dictParam,
Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeString, StringVal: dictsString[iteration-1][dictParam]},
})
}
} else if errDictInt == nil {
for dictParam := range dictsInt[iteration-1] {
out = append(out, v1beta1.Param{
Name: p.Name + "-subvar-" + dictParam,
Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeString, StringVal: strconv.Itoa(dictsInt[iteration-1][dictParam])},
})
}
}
}
} else {
out = append(out, run.Spec.Params[i])
}
}
} else {
// IterateNumeric defined
IterateStrings := []string{"from", "step", "to"}
for i, p := range run.Spec.Params {
if _, found := Find(IterateStrings, p.Name); !found {
out = append(out, run.Spec.Params[i])
}
}
out = append(out, v1beta1.Param{
Name: tls.IterateNumeric,
Value: v1beta1.ArrayOrString{Type: v1beta1.ParamTypeString, StringVal: strconv.Itoa(iteration)},
})
}
return out
}
func getPipelineRunAnnotations(run *v1alpha1.Run) map[string]string {
// Propagate annotations from Run to PipelineRun.
annotations := make(map[string]string, len(run.ObjectMeta.Annotations)+1)
for key, val := range run.ObjectMeta.Annotations {
annotations[key] = val
}
return annotations
}
// Find takes a slice and looks for an element in it. If found it will
// return it's key, otherwise it will return -1 and a bool of false.
func Find(slice []string, val string) (int, bool) {
for i, item := range slice {
if item == val {
return i, true
}
}
return -1, false
}
func getPipelineRunLabels(run *v1alpha1.Run, iterationStr string) map[string]string {
// Propagate labels from Run to PipelineRun.
labels := make(map[string]string, len(run.ObjectMeta.Labels)+1)
ignnoreLabelsKey := []string{"tekton.dev/pipelineRun", "tekton.dev/pipelineTask", "tekton.dev/pipeline", "custom.tekton.dev/pipelineLoopIteration"}
for key, val := range run.ObjectMeta.Labels {
if _, found := Find(ignnoreLabelsKey, key); !found {
labels[key] = val
}
}
// Note: The Run label uses the normal Tekton group name.
labels[pipeline.GroupName+pipelineLoopRunLabelKey] = run.Name
if iterationStr != "" {
labels[pipelineloop.GroupName+pipelineLoopIterationLabelKey] = iterationStr
}
return labels
}
func propagatePipelineLoopLabelsAndAnnotations(run *v1alpha1.Run, pipelineLoopMeta *metav1.ObjectMeta) {
// Propagate labels from PipelineLoop to Run.
if run.ObjectMeta.Labels == nil {
run.ObjectMeta.Labels = make(map[string]string, len(pipelineLoopMeta.Labels)+1)
}
for key, value := range pipelineLoopMeta.Labels {
run.ObjectMeta.Labels[key] = value
}
run.ObjectMeta.Labels[pipelineloop.GroupName+pipelineLoopLabelKey] = pipelineLoopMeta.Name
// Propagate annotations from PipelineLoop to Run.
if run.ObjectMeta.Annotations == nil {
run.ObjectMeta.Annotations = make(map[string]string, len(pipelineLoopMeta.Annotations))
}
for key, value := range pipelineLoopMeta.Annotations {
run.ObjectMeta.Annotations[key] = value
}
}
func storePipelineLoopSpec(status *pipelineloopv1alpha1.PipelineLoopRunStatus, tls *pipelineloopv1alpha1.PipelineLoopSpec) {
// Only store the PipelineLoopSpec once, if it has never been set before.
if status.PipelineLoopSpec == nil {
status.PipelineLoopSpec = tls
}
}
|
// Copyright (c) 2016-2019 Uber Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package writeback
import (
"errors"
"fmt"
"time"
"github.com/uber/kraken/lib/persistedretry"
"github.com/jmoiron/sqlx"
"github.com/mattn/go-sqlite3"
)
// Store stores writeback tasks.
type Store struct {
db *sqlx.DB
}
// NewStore creates a new Store.
func NewStore(db *sqlx.DB) *Store {
return &Store{db}
}
// GetPending returns all pending tasks.
func (s *Store) GetPending() ([]persistedretry.Task, error) {
return s.selectStatus("pending")
}
// GetFailed returns all failed tasks.
func (s *Store) GetFailed() ([]persistedretry.Task, error) {
return s.selectStatus("failed")
}
// AddPending adds r as pending.
func (s *Store) AddPending(r persistedretry.Task) error {
return s.addWithStatus(r, "pending")
}
// AddFailed adds r as failed.
func (s *Store) AddFailed(r persistedretry.Task) error {
return s.addWithStatus(r, "failed")
}
// MarkPending marks r as pending.
func (s *Store) MarkPending(r persistedretry.Task) error {
res, err := s.db.NamedExec(`
UPDATE writeback_task
SET status = "pending"
WHERE namespace=:namespace AND name=:name
`, r.(*Task))
if err != nil {
return err
}
if n, err := res.RowsAffected(); err != nil {
panic("driver does not support RowsAffected")
} else if n == 0 {
return persistedretry.ErrTaskNotFound
}
return nil
}
// MarkFailed marks r as failed.
func (s *Store) MarkFailed(r persistedretry.Task) error {
t := r.(*Task)
res, err := s.db.NamedExec(`
UPDATE writeback_task
SET last_attempt = CURRENT_TIMESTAMP,
failures = failures + 1,
status = "failed"
WHERE namespace=:namespace AND name=:name
`, t)
if err != nil {
return err
}
if n, err := res.RowsAffected(); err != nil {
panic("driver does not support RowsAffected")
} else if n == 0 {
return persistedretry.ErrTaskNotFound
}
t.Failures++
t.LastAttempt = time.Now()
return nil
}
// Remove removes r.
func (s *Store) Remove(r persistedretry.Task) error {
_, err := s.db.NamedExec(`
DELETE FROM writeback_task
WHERE namespace=:namespace AND name=:name
`, r.(*Task))
return err
}
// Find finds tasks matching query.
func (s *Store) Find(query interface{}) ([]persistedretry.Task, error) {
var tasks []*Task
var err error
switch q := query.(type) {
case *NameQuery:
err = s.db.Select(&tasks, `
SELECT namespace, name, created_at, last_attempt, failures, delay
FROM writeback_task
WHERE name=?
`, q.name)
default:
return nil, errors.New("unknown query type")
}
if err != nil {
return nil, err
}
return convert(tasks), nil
}
func (s *Store) addWithStatus(r persistedretry.Task, status string) error {
query := fmt.Sprintf(`
INSERT INTO writeback_task (
namespace,
name,
last_attempt,
failures,
delay,
status
) VALUES (
:namespace,
:name,
:last_attempt,
:failures,
:delay,
%q
)
`, status)
_, err := s.db.NamedExec(query, r.(*Task))
if se, ok := err.(sqlite3.Error); ok {
if se.ExtendedCode == sqlite3.ErrConstraintPrimaryKey {
return persistedretry.ErrTaskExists
}
}
return err
}
func (s *Store) selectStatus(status string) ([]persistedretry.Task, error) {
var tasks []*Task
err := s.db.Select(&tasks, `
SELECT namespace, name, created_at, last_attempt, failures, delay
FROM writeback_task
WHERE status=?
`, status)
if err != nil {
return nil, err
}
return convert(tasks), nil
}
func convert(tasks []*Task) (result []persistedretry.Task) {
for _, t := range tasks {
result = append(result, t)
}
return result
}
|
package integration
import (
"encoding/json"
"fmt"
"io"
"log"
"net"
"net/http"
"time"
"github.com/gorilla/mux"
"github.com/tilt-dev/wmclient/pkg/analytics"
)
type MemoryStatsServer struct {
ma *analytics.MemoryAnalytics
ss StatsServer
listener net.Listener
}
func StartMemoryStatsServer() (mss *MemoryStatsServer, port int, err error) {
mss = &MemoryStatsServer{}
mss.ma = analytics.NewMemoryAnalytics()
sr := &MemoryStatsReporter{mss.ma}
mss.ss = NewStatsServer(sr)
mux := http.NewServeMux()
mux.Handle("/", mss.ss.Router())
mss.listener, err = net.Listen("tcp", ":0")
if err != nil {
return nil, 0, err
}
go func() {
err := http.Serve(mss.listener, mux)
if err != nil {
fmt.Println(err)
}
}()
return mss, mss.listener.Addr().(*net.TCPAddr).Port, nil
}
func (mss *MemoryStatsServer) TearDown() error {
return mss.listener.Close()
}
type MemoryStatsReporter struct {
a *analytics.MemoryAnalytics
}
var _ StatsReporter = &MemoryStatsReporter{}
func (sr *MemoryStatsReporter) Close() error {
return nil
}
func (sr *MemoryStatsReporter) Timing(name string, value time.Duration, tags map[string]string, rate float64) error {
sr.a.Timer(name, value, tags)
return nil
}
func (sr *MemoryStatsReporter) Count(name string, value int64, tags map[string]string, rate float64) error {
sr.a.Count(name, tags, int(value))
return nil
}
func (sr *MemoryStatsReporter) Incr(name string, tags map[string]string, rate float64) error {
sr.a.Incr(name, tags)
return nil
}
const keyTime = "time"
type StatsReporter interface {
io.Closer
Timing(name string, value time.Duration, tags map[string]string, rate float64) error
Count(name string, value int64, tags map[string]string, rate float64) error
Incr(name string, tags map[string]string, rate float64) error
}
// A small http server that decodes json and sends it to our metrics services
type StatsServer struct {
router *mux.Router
reporter StatsReporter
}
func NewStatsServer(stats StatsReporter) StatsServer {
r := mux.NewRouter().UseEncodedPath()
s := StatsServer{router: r, reporter: stats}
r.HandleFunc("/report", s.Report).Methods("POST")
r.HandleFunc("/", s.Index).Methods("GET")
return s
}
func (s StatsServer) Router() *mux.Router {
return s.router
}
func (s StatsServer) Index(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte("OK"))
}
func (s StatsServer) Report(w http.ResponseWriter, r *http.Request) {
now := time.Now()
events, err := parseJSON(r)
if err != nil {
http.Error(w, fmt.Sprintf("JSON decode: %v", err), http.StatusBadRequest)
return
}
for _, event := range events {
name := event.Name()
if name == "" {
http.Error(w, fmt.Sprintf("Missing name: %v", event), http.StatusBadRequest)
return
}
event[keyTime] = now.Format(time.RFC3339)
dur := event.Duration()
if dur == 0 {
// TODO: support count
err := s.reporter.Incr(name, event.Tags(), 1)
if err != nil {
log.Printf("Report error: %v", err)
}
} else {
err := s.reporter.Timing(name, dur, event.Tags(), 1)
if err != nil {
log.Printf("Report error: %v", err)
}
}
}
}
type Event map[string]interface{}
func (e Event) Name() string {
name, ok := e["name"].(string)
if !ok {
return ""
}
return name
}
func (e Event) Duration() time.Duration {
// all json numbers are float64
dur, ok := e["duration"].(float64)
if !ok {
return 0
}
return time.Duration(dur)
}
func (e Event) Tags() map[string]string {
tags := make(map[string]string)
for k, v := range e {
if k == "name" || k == "duration" {
continue
}
if vStr, ok := v.(string); ok {
tags[k] = vStr
}
}
return tags
}
func parseJSON(r *http.Request) ([]Event, error) {
d := json.NewDecoder(r.Body)
result := make([]Event, 0)
for d.More() {
data := make(map[string]interface{})
err := d.Decode(&data)
if err != nil {
return nil, err
}
result = append(result, Event(data))
}
return result, nil
}
|
// Copyright 2021 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package request
import "chromiumos/tast/errors"
// DayStart is part of an Omaha Request.
type DayStart struct {
XMLName struct{} `xml:"daystart" json:"-"`
ElapsedDays int `xml:"elapsed_days,attr"`
ElapsedSeconds int `xml:"elapsed_seconds,attr"`
}
// Action is part of an Omaha Request.
type Action struct {
XMLName struct{} `xml:"action" json:"-"`
Event string `xml:"event,attr"`
ChromeVersion string `xml:"ChromeVersion,attr"`
ChromeOSVersion string `xml:"ChromeOSVersion,attr"`
}
// Actions is part of an Omaha Request.
type Actions struct {
XMLName struct{} `xml:"actions" json:"-"`
Actions []Action `xml:"action"`
}
// Manifest is part of an Omaha Request.
type Manifest struct {
XMLName struct{} `xml:"manifest" json:"-"`
Version string `xml:"version,attr"`
Actions Actions `xml:"actions"`
}
// ResponseUpdateCheck is part of an Omaha Request.
type ResponseUpdateCheck struct {
XMLName struct{} `xml:"updatecheck" json:"-"`
Status string `xml:"status,attr"`
Rollback bool `xml:"_rollback,attr"`
Manifest Manifest `xml:"manifest"`
}
// ResponseApp is part of an Omaha Request.
type ResponseApp struct {
XMLName struct{} `xml:"app" json:"-"`
AppID string `xml:"appid,attr"`
Cohort string `xml:"cohort,attr,omitempty"`
CohortName string `xml:"cohortname,attr,omitempty"`
Status string `xml:"status,attr"`
UpdateCheck ResponseUpdateCheck `xml:"updatecheck"`
}
// Response can be parsed from an Omaha response.
// Structure based on real Omaha responses.
// Official documentation: https://chromium.googlesource.com/chromium/src.git/+/refs/heads/main/docs/updater/protocol_3_1.md
type Response struct {
XMLName struct{} `xml:"response" json:"-"`
Protocol string `xml:"protocol,attr"`
Server string `xml:"server,attr"`
DayStart DayStart `xml:"daystart"`
App ResponseApp `xml:"app"`
}
func (r *Response) postInstallEvent() (*Action, error) {
for _, action := range r.App.UpdateCheck.Manifest.Actions.Actions {
if action.Event == "postinstall" {
return &action, nil
}
}
return nil, errors.New("could not find postinstall event in response")
}
// ChromeVersion gets the Chrome version from an Omaha response.
// Returns an error if not found.
func (r *Response) ChromeVersion() (string, error) {
action, err := r.postInstallEvent()
if err != nil {
return "", err
}
return action.ChromeVersion, nil
}
// ChromeOSVersion gets the ChromeOS version from an Omaha response.
// Returns an error if not found.
func (r *Response) ChromeOSVersion() (string, error) {
action, err := r.postInstallEvent()
if err != nil {
return "", err
}
return action.ChromeOSVersion, nil
}
// ValidateUpdateResponse checks that the response contains an update payload.
func (r *Response) ValidateUpdateResponse() error {
if r.Server != "prod" {
return errors.Errorf("reached wrong server: got %q; want %q", r.Server, "prod")
}
if r.App.Status != "ok" {
return errors.Errorf("unexpected App status: got %q; want %q", r.App.Status, "ok")
}
if r.App.UpdateCheck.Status != "ok" {
return errors.Errorf("unexpected UpdateCheck status: got %q; want %q", r.App.UpdateCheck.Status, "ok")
}
if _, err := r.postInstallEvent(); err != nil {
return err
}
return nil
}
|
// Copyright (C) 2017 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package parse_test
import (
"bytes"
"context"
"fmt"
"testing"
"github.com/google/gapid/core/assert"
"github.com/google/gapid/core/fault"
"github.com/google/gapid/core/log"
"github.com/google/gapid/core/text/parse"
"github.com/google/gapid/core/text/parse/cst"
"github.com/google/gapid/core/text/parse/test"
)
var (
B = test.Branch
N = test.Node
S = test.Separator
F = test.Fragment
List = test.List
Array = test.Array
Call = test.Call
)
func TestEmpty(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx, ``, B(), List())
}
func TestErrorInvalid(t *testing.T) {
ctx := log.Testing(t)
testFail(ctx, `@`)
}
func TestErrorExpected(t *testing.T) {
ctx := log.Testing(t)
testFail(ctx, `[,]`)
testFail(ctx, `[ 0`)
}
func TestUnconsumed(t *testing.T) {
ctx := log.Testing(t)
testCustomFail(ctx, "a", func(p *parse.Parser, n *cst.Branch) {})
}
func TestUnconsumedByBranch(t *testing.T) {
ctx := log.Testing(t)
testCustomFail(ctx, "a", func(p *parse.Parser, n *cst.Branch) {
p.ParseBranch(n, func(n *cst.Branch) {
p.NotSpace()
})
})
}
func TestUnconsumedOnBranch(t *testing.T) {
ctx := log.Testing(t)
testCustomFail(ctx, "a", func(p *parse.Parser, n *cst.Branch) {
p.NotSpace()
p.ParseBranch(n, func(n *cst.Branch) {})
})
}
func TestSpace(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx, ` `, N(" ", B(), nil), List())
testParse(ctx, ` `, N(" ", B(), nil), List())
}
func TestLineComment(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx, `//note`, N(S(F("//note")), B(), nil), List())
testParse(ctx, `//note
`, N(S(F("//note"), "\n"), B(), nil), List())
}
func TestBlockComment(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx, `/*note*/`, N(S(F("/*note*/")), B(), nil), List())
}
func TestCommentUnclosed(t *testing.T) {
ctx := log.Testing(t)
testFail(ctx, `/*a`)
}
func TestComplexComment(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx, `
///*a*/
/*b//c*
//*/ //d
d //e
`, N(
S("\n", F("///*a*/"), "\n", F("/*b//c*\n//*/"), " ", F("//d"), "\n"),
B("d"),
S(" ", F("//e"), "\n")),
List("d"))
}
func TestValue(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx, `a`, B("a"), List("a"))
testParse(ctx, `0xA4`, B("0xA4"), List(164))
testParse(ctx, ` a`, N(" ", B("a"), nil), nil)
}
func TestArray(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx, `[]`, B(B("[", B(), "]")), List(Array()))
testParse(ctx, `[a]`, B(B("[", B("a"), "]")), List(Array("a")))
testParse(ctx, `[a,b]`, B(B("[", B("a", ",", "b"), "]")), List(Array("a", "b")))
}
func TestCall1(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx, `a(b)`, B("a", B("(", B("b"), ")")), List(Call("a", "b")))
testParse(ctx, `a(b,c)`, B("a", B("(", B("b", ",", "c"), ")")), List(Call("a", "b", "c")))
}
func TestComplex(t *testing.T) {
ctx := log.Testing(t)
testParse(ctx,
` a (b ,c)`,
N(" ", B(
N(nil, "a", " "),
B("(", B(N(nil, "b", " "), ",", "c"), ")"),
), nil),
List(Call("a", "b", "c")))
}
func TestErrorLimit(t *testing.T) {
ctx := log.Testing(t)
errs := parse.Parse("parser_test.api", "", parse.NewSkip("//", "/*", "*/"), func(p *parse.Parser, n *cst.Branch) {
for i := 0; true; i++ {
p.ErrorAt(n, "failure")
if i >= parse.ParseErrorLimit {
log.F(ctx, true, "Parsing not terminated. %d errors", i)
}
}
})
assert.For(ctx, "errs").ThatSlice(errs).IsLength(parse.ParseErrorLimit)
}
func TestCursor(t *testing.T) {
ctx := log.Testing(t)
root := List()
filename, line, column := "parser_test.api", 3, 5
content := ""
for i := 1; i < line; i++ {
content += "\n"
}
for i := 1; i < column; i++ {
content += " "
}
content += "@ \n "
errs := parse.Parse(filename, content, parse.NewSkip("//", "/*", "*/"), func(p *parse.Parser, b *cst.Branch) {
root.Parser(p)(b)
})
if len(errs) == 0 {
log.E(ctx, "Expected errors")
}
l, c := errs[0].At.Tok().Cursor()
assert.For(ctx, "Line").That(l).Equals(line)
assert.For(ctx, "Column").That(c).Equals(column)
assert.For(ctx, "Error").ThatString(errs[0]).HasPrefix(fmt.Sprintf("%s:%v:%v: Unexpected", filename, line, column))
}
func TestCustomPanic(t *testing.T) {
ctx := log.Testing(t)
const custom = fault.Const("custom")
defer func() {
assert.For(ctx, "recover").That(recover()).Equals(custom)
}()
parse.Parse("parser_test.api", "", parse.NewSkip("//", "/*", "*/"), func(p *parse.Parser, _ *cst.Branch) {
panic(custom)
})
}
func testParse(ctx context.Context, content string, n cst.Node, ast *test.ListNode) {
ctx = log.V{"content": content}.Bind(ctx)
root := List()
var gotCst *cst.Branch
rootParse := func(p *parse.Parser, n *cst.Branch) {
gotCst = n
root.Parser(p)(n)
}
errs := parse.Parse("parser_test.api", content, parse.NewSkip("//", "/*", "*/"), rootParse)
assert.For(ctx, "errors").ThatSlice(errs).IsEmpty()
out := &bytes.Buffer{}
gotCst.Write(out)
assert.For(ctx, "content").ThatString(out).Equals(content)
test.VerifyTokens(ctx, gotCst)
if n != nil {
assert.For(ctx, "CST").That(gotCst).DeepEquals(n)
}
if ast != nil {
assert.For(ctx, "AST").That(root).DeepEquals(ast)
}
}
func testCustomFail(ctx context.Context, content string, do parse.RootParser) {
errs := parse.Parse("parser_test.api", content, parse.NewSkip("//", "/*", "*/"), do)
if len(errs) == 0 {
log.E(ctx, "Expected errors")
} else {
for _, e := range errs {
line, column := e.At.Tok().Cursor()
log.I(ctx, "%v:%v: %s\n", line, column, e.Message)
}
}
}
func testFail(ctx context.Context, content string) {
root := List()
testCustomFail(ctx, content, func(p *parse.Parser, b *cst.Branch) {
root.Parser(p)(b)
})
}
|
package peerstore
import (
"encoding/json"
ma "gx/ipfs/QmSWLfmj5frN9xVLMMN846dMDriy5wN5jeghUm7aTW3DAG/go-multiaddr"
"gx/ipfs/QmWUswjn261LSyVxWAEpMVtPdy8zmKBJJfBpG3Qdpa8ZsE/go-libp2p-peer"
)
// PeerInfo is a small struct used to pass around a peer with
// a set of addresses (and later, keys?). This is not meant to be
// a complete view of the system, but rather to model updates to
// the peerstore. It is used by things like the routing system.
type PeerInfo struct {
ID peer.ID
Addrs []ma.Multiaddr
}
func (pi *PeerInfo) Loggable() map[string]interface{} {
return map[string]interface{}{
"peerID": pi.ID.Pretty(),
"addrs": pi.Addrs,
}
}
func (pi *PeerInfo) MarshalJSON() ([]byte, error) {
out := make(map[string]interface{})
out["ID"] = pi.ID.Pretty()
var addrs []string
for _, a := range pi.Addrs {
addrs = append(addrs, a.String())
}
out["Addrs"] = addrs
return json.Marshal(out)
}
func (pi *PeerInfo) UnmarshalJSON(b []byte) error {
var data map[string]interface{}
err := json.Unmarshal(b, &data)
if err != nil {
return err
}
pid, err := peer.IDB58Decode(data["ID"].(string))
if err != nil {
return err
}
pi.ID = pid
addrs, ok := data["Addrs"].([]interface{})
if ok {
for _, a := range addrs {
pi.Addrs = append(pi.Addrs, ma.StringCast(a.(string)))
}
}
return nil
}
|
package postgres
import (
"net/url"
"time"
"github.com/Alireza-Ta/goask/model"
"github.com/go-pg/pg/urlvalues"
)
// CreateQuestion persists a question in db.
func (s *Store) CreateQuestion(q *model.Question) error {
return s.DB.Insert(q)
}
// ListQuestion returns a list of questions.
func (s *Store) ListQuestion(query url.Values) (model.Questions, error) {
var q model.Questions
err := s.DB.Model(&q).
Apply(urlvalues.Pagination(urlvalues.Values(query))).
Relation("Replies").
Relation("Comments").
Relation("Tags").
Select()
return q, err
}
// QuestionWithRelations returns question with its relations.
func (s *Store) QuestionWithRelations(id int) (*model.Question, error) {
q := new(model.Question)
err := s.DB.Model(q).Where("id = ?", id).Relation("Replies").Relation("Comments").Relation("Tags").Select()
return q, err
}
// FindQuestion finds question by its id.
func (s *Store) FindQuestion(id int) (*model.Question, error) {
q := new(model.Question)
err := s.DB.Model(q).Where("id = ?", id).Select()
return q, err
}
// UpdateQuestion updates the question.
func (s *Store) UpdateQuestion(q *model.Question) error {
q.UpdatedAt = time.Now()
return s.DB.Update(q)
}
// UpdateVote updates question's vote.
func (s *Store) UpdateVote(q *model.Question) error {
_, err := s.DB.Model(q).Column("vote", "updated_at").WherePK().Update()
return err
}
|
// Copyright 2020 Ant Group. All rights reserved.
//
// SPDX-License-Identifier: Apache-2.0
package cache
import (
"strconv"
"testing"
"github.com/opencontainers/go-digest"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/stretchr/testify/assert"
"github.com/dragonflyoss/image-service/contrib/nydusify/pkg/utils"
)
func makeRecord(id int64, hashBlob bool) *CacheRecord {
var blobDesc *ocispec.Descriptor
idStr := strconv.FormatInt(id, 10)
if hashBlob {
blobDesc = &ocispec.Descriptor{
MediaType: utils.MediaTypeNydusBlob,
Digest: digest.FromString("blob-" + idStr),
Size: id,
}
}
return &CacheRecord{
SourceChainID: digest.FromString("chain-" + idStr),
NydusBootstrapDesc: &ocispec.Descriptor{
MediaType: ocispec.MediaTypeImageLayerGzip,
Digest: digest.FromString("bootstrap-" + idStr),
Size: id,
},
NydusBootstrapDiffID: digest.FromString("bootstrap-uncompressed-" + idStr),
NydusBlobDesc: blobDesc,
}
}
func makeBootstrapLayer(id int64) ocispec.Descriptor {
idStr := strconv.FormatInt(id, 10)
return ocispec.Descriptor{
MediaType: ocispec.MediaTypeImageLayerGzip,
Digest: digest.FromString("bootstrap-" + idStr),
Size: id,
Annotations: map[string]string{
utils.LayerAnnotationNydusBootstrap: "true",
utils.LayerAnnotationNydusSourceChainID: digest.FromString("chain-" + idStr).String(),
utils.LayerAnnotationUncompressed: digest.FromString("bootstrap-uncompressed-" + idStr).String(),
},
}
}
func makeBlobLayer(id int64) ocispec.Descriptor {
idStr := strconv.FormatInt(id, 10)
return ocispec.Descriptor{
MediaType: utils.MediaTypeNydusBlob,
Digest: digest.FromString("blob-" + idStr),
Size: id,
Annotations: map[string]string{
utils.LayerAnnotationNydusBlob: "true",
utils.LayerAnnotationNydusSourceChainID: digest.FromString("chain-" + idStr).String(),
},
}
}
func TestCache(t *testing.T) {
cache, err := New(nil, Opt{
MaxRecords: 3,
DockerV2Format: false,
})
assert.Nil(t, err)
exported := []*CacheRecord{
makeRecord(1, true),
makeRecord(2, true),
makeRecord(3, false),
}
cache.Record(exported)
cache.Record(exported)
layers := cache.exportRecordsToLayers()
assert.Equal(t, layers, []ocispec.Descriptor{
makeBootstrapLayer(1),
makeBlobLayer(1),
makeBootstrapLayer(2),
makeBlobLayer(2),
makeBootstrapLayer(3),
})
cache.importLayersToRecords(layers)
cache.Record([]*CacheRecord{
makeRecord(4, true),
makeRecord(5, true),
})
layers = cache.exportRecordsToLayers()
assert.Equal(t, layers, []ocispec.Descriptor{
makeBootstrapLayer(4),
makeBlobLayer(4),
makeBootstrapLayer(5),
makeBlobLayer(5),
makeBootstrapLayer(1),
makeBlobLayer(1),
})
}
|
package auth_test
import (
"context"
"strconv"
"sync"
"testing"
"time"
pb "github.com/SmitSheth/Mini-twitter/internal/auth/authentication"
server "github.com/SmitSheth/Mini-twitter/internal/auth/service"
)
func TestConcurrentCredential(t *testing.T) {
var wg sync.WaitGroup
numUsers := 100
wg.Add(numUsers)
authServer := server.GetAuthServer()
credsArray := make([]*pb.UserCredential, numUsers)
for i := 0; i < numUsers; i++ {
credsArray[i] = &pb.UserCredential{Username: strconv.Itoa(i), Password: strconv.Itoa(i)}
}
for i := 0; i < numUsers; i++ {
go func(uid int) {
defer wg.Done()
_, err := authServer.AddCredential(context.Background(), credsArray[uid])
if err != nil {
t.Error(err.Error())
}
}(i)
}
wg.Wait()
wg.Add(numUsers)
for i := 0; i < numUsers; i++ {
go func(uid int) {
defer wg.Done()
temp, err := authServer.CheckAuthentication(context.Background(), credsArray[uid])
if err != nil {
t.Error(err.Error())
}
if !temp.Authenticated {
t.Error("Not Authenticated")
}
}(i)
}
}
func TestConcurrentAuthToken(t *testing.T) {
var wg sync.WaitGroup
mu := sync.Mutex{}
numUsers := 100
wg.Add(numUsers)
authServer := server.GetAuthServer()
authArr := make([]*pb.AuthToken, numUsers)
for i := 0; i < numUsers; i++ {
go func(uid uint64) {
defer wg.Done()
temp, err := authServer.GetAuthToken(context.Background(), &pb.UserId{UserId: uid})
if err != nil {
t.Error(err)
}
mu.Lock()
authArr[uid] = temp
mu.Unlock()
}(uint64(i))
}
wg.Wait()
wg.Add(numUsers)
for i := 0; i < numUsers; i++ {
go func(uid uint64) {
defer wg.Done()
_, err := authServer.GetUserId(context.Background(), authArr[uid])
if err != nil {
t.Error(err)
}
}(uint64(i))
}
wg.Wait()
wg.Add(numUsers)
for i := 0; i < numUsers; i++ {
go func(uid uint64) {
defer wg.Done()
_, err := authServer.RemoveAuthToken(context.Background(), authArr[uid])
if err != nil {
t.Error(err)
}
}(uint64(i))
}
wg.Wait()
wg.Add(numUsers)
for i := 0; i < numUsers; i++ {
go func(uid uint64) {
defer wg.Done()
_, err := authServer.GetUserId(context.Background(), authArr[uid])
if err == nil {
t.Error("user still authenticated")
}
}(uint64(i))
}
}
func TestContextTimeoutCredential(t *testing.T) {
var err error
authServer := server.GetTestAuthServer()
errchan := make(chan error)
ctx, cancel := context.WithCancel(context.Background())
cred := &pb.UserCredential{Username: "test", Password: "test"}
go func() {
_, err := authServer.AddCredential(ctx, cred)
errchan <- err
}()
time.Sleep(1 * time.Second)
cancel()
err = <-errchan
if err == nil {
t.Error("No error returned")
}
result, err := authServer.CheckAuthentication(context.Background(), cred)
if err != nil {
t.Error(err.Error())
}
if result.Authenticated {
t.Error("User authenticated")
}
}
func TestContextTimeoutAuthToken(t *testing.T) {
var err error
authServer := server.GetTestAuthServer()
resultchan := make(chan *pb.AuthToken)
errchan := make(chan error)
ctx, cancel := context.WithCancel(context.Background())
go func() {
temp, err := authServer.GetAuthToken(ctx, &pb.UserId{UserId: uint64(1)})
if err != nil {
errchan <- err
}
resultchan <- temp
}()
time.Sleep(1 * time.Second)
cancel()
select {
case <-resultchan:
case err = <-errchan:
}
if err == nil {
t.Error("No error returned")
}
}
func TestContextTimeoutRemoveAuthToken(t *testing.T) {
var err error
authServer := server.GetTestAuthServer()
token, err := authServer.GetAuthToken(context.Background(), &pb.UserId{UserId: uint64(1)})
errchan := make(chan error)
ctx, cancel := context.WithCancel(context.Background())
go func() {
_, err := authServer.RemoveAuthToken(ctx, token)
errchan <- err
}()
time.Sleep(1 * time.Second)
cancel()
err = <-errchan
if err == nil {
t.Error("No error returned")
}
_, err = authServer.GetUserId(context.Background(), token)
if err != nil {
t.Error("Token removed")
}
}
|
package main
import "testing"
func TestNewCredential(t *testing.T) {
credentials := "username:password"
credential := NewCredential(credentials)
if credential.Username != "username" {
t.Error("Expected username, got", credential.Username)
}
if credential.Password != "password" {
t.Error("Expected password, got", credential.Password)
}
}
|
// Copyright 2021 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package buffer
import (
"bytes"
"context"
"fmt"
"io"
"math/rand"
"reflect"
"strings"
"testing"
"gvisor.dev/gvisor/pkg/state"
"gvisor.dev/gvisor/pkg/tcpip/checksum"
)
func BenchmarkReadAt(b *testing.B) {
b.ReportAllocs()
var buf Buffer
buf.Append(NewView(100))
defer buf.Release()
bytes := make([]byte, 10)
for i := 0; i < b.N; i++ {
buf.ReadAt(bytes, 0)
}
}
func BenchmarkWriteRead(b *testing.B) {
b.ReportAllocs()
var buf Buffer
defer buf.Release()
sz := 1000
rbuf := bytes.NewBuffer(make([]byte, sz))
for i := 0; i < b.N; i++ {
buf.Append(NewView(sz))
rbuf.Reset()
buf.ReadToWriter(rbuf, int64(sz))
}
}
func fillAppend(b *Buffer, data []byte) {
b.Append(NewViewWithData(data))
}
func fillAppendEnd(b *Buffer, data []byte) {
b.GrowTo(baseChunkSize-1, false)
b.Append(NewViewWithData(data))
b.TrimFront(baseChunkSize - 1)
}
func fillWriteFromReader(b *Buffer, data []byte) {
buf := bytes.NewBuffer(data)
b.WriteFromReader(buf, int64(len(data)))
}
func fillWriteFromReaderEnd(b *Buffer, data []byte) {
b.GrowTo(baseChunkSize-1, false)
buf := bytes.NewBuffer(data)
b.WriteFromReader(buf, int64(len(data)))
b.TrimFront(baseChunkSize - 1)
}
var fillFuncs = map[string]func(*Buffer, []byte){
"append": fillAppend,
"appendEnd": fillAppendEnd,
"writeFromReader": fillWriteFromReader,
"writeFromReaderEnd": fillWriteFromReaderEnd,
}
func testReadAt(t *testing.T, b *Buffer, offset int64, n int, wantStr string, wantErr error) {
t.Helper()
d := make([]byte, n)
n, err := b.ReadAt(d, offset)
if n != len(wantStr) {
t.Errorf("got %d, want %d", n, len(wantStr))
}
if err != wantErr {
t.Errorf("got err %v, want %v", err, wantErr)
}
if !bytes.Equal(d[:n], []byte(wantStr)) {
t.Errorf("got %q, want %q", string(d[:n]), wantStr)
}
}
func TestBuffer(t *testing.T) {
testCases := []struct {
name string
input string
output string
op func(*testing.T, *Buffer)
}{
// Preconditions.
{
name: "truncate-check",
input: "hello",
output: "hello", // Not touched.
op: func(t *testing.T, b *Buffer) {
defer func() {
if r := recover(); r == nil {
t.Errorf("Truncate(-1) did not panic")
}
}()
b.Truncate(-1)
},
},
{
name: "growto-check",
input: "hello",
output: "hello", // Not touched.
op: func(t *testing.T, b *Buffer) {
defer func() {
if r := recover(); r == nil {
t.Errorf("GrowTo(-1) did not panic")
}
}()
b.GrowTo(-1, false)
},
},
{
name: "advance-check",
input: "hello",
output: "", // Consumed.
op: func(t *testing.T, b *Buffer) {
defer func() {
if r := recover(); r == nil {
t.Errorf("advanceRead(Size()+1) did not panic")
}
}()
b.advanceRead(b.Size() + 1)
},
},
// Prepend.
{
name: "prepend",
input: "world",
output: "hello world",
op: func(t *testing.T, b *Buffer) {
b.Prepend(NewViewWithData([]byte("hello ")))
},
},
{
name: "prepend-backfill-full",
input: "hello world",
output: "jello world",
op: func(t *testing.T, b *Buffer) {
b.TrimFront(1)
b.Prepend(NewViewWithData([]byte("j")))
},
},
{
name: "prepend-backfill-under",
input: "hello world",
output: "hola world",
op: func(t *testing.T, b *Buffer) {
b.TrimFront(5)
b.Prepend(NewViewWithData([]byte("hola")))
},
},
{
name: "prepend-backfill-over",
input: "hello world",
output: "smello world",
op: func(t *testing.T, b *Buffer) {
b.TrimFront(1)
b.Prepend(NewViewWithData([]byte("sm")))
},
},
{
name: "prepend-fill",
input: strings.Repeat("1", baseChunkSize-1),
output: "0" + strings.Repeat("1", baseChunkSize-1),
op: func(t *testing.T, b *Buffer) {
b.Prepend(NewViewWithData([]byte("0")))
},
},
{
name: "prepend-overflow",
input: strings.Repeat("1", baseChunkSize),
output: "0" + strings.Repeat("1", baseChunkSize),
op: func(t *testing.T, b *Buffer) {
b.Prepend(NewViewWithData([]byte("0")))
},
},
{
name: "prepend-multiple-buffers",
input: strings.Repeat("1", baseChunkSize-1),
output: strings.Repeat("0", baseChunkSize*3) + strings.Repeat("1", baseChunkSize-1),
op: func(t *testing.T, b *Buffer) {
b.Prepend(NewViewWithData([]byte(strings.Repeat("0", baseChunkSize))))
b.Prepend(NewViewWithData([]byte(strings.Repeat("0", baseChunkSize))))
b.Prepend(NewViewWithData([]byte(strings.Repeat("0", baseChunkSize))))
},
},
// Append and write.
{
name: "append",
input: "hello",
output: "hello world",
op: func(t *testing.T, b *Buffer) {
b.Append(NewViewWithData([]byte(" world")))
},
},
{
name: "append-fill",
input: strings.Repeat("1", baseChunkSize-1),
output: strings.Repeat("1", baseChunkSize-1) + "0",
op: func(t *testing.T, b *Buffer) {
b.Append(NewViewWithData([]byte("0")))
},
},
{
name: "append-overflow",
input: strings.Repeat("1", baseChunkSize),
output: strings.Repeat("1", baseChunkSize) + "0",
op: func(t *testing.T, b *Buffer) {
b.Append(NewViewWithData([]byte("0")))
},
},
{
name: "append-multiple-views",
input: strings.Repeat("1", baseChunkSize-1),
output: strings.Repeat("1", baseChunkSize-1) + strings.Repeat("0", baseChunkSize*3),
op: func(t *testing.T, b *Buffer) {
b.Append(NewViewWithData([]byte(strings.Repeat("0", baseChunkSize))))
b.Append(NewViewWithData([]byte(strings.Repeat("0", baseChunkSize))))
b.Append(NewViewWithData([]byte(strings.Repeat("0", baseChunkSize))))
},
},
// AppendOwned.
{
name: "append-owned",
input: "hello",
output: "hello world",
op: func(t *testing.T, b *Buffer) {
v := NewViewWithData([]byte("Xworld"))
// Appending to a buffer that has extra references means this will
// degrade into an "appendOwned" for the chunk being added.
c := b.Clone()
defer c.Release()
b.Append(v)
v.chunk.data[0] = ' '
},
},
// Truncate.
{
name: "truncate",
input: "hello world",
output: "hello",
op: func(t *testing.T, b *Buffer) {
b.Truncate(5)
},
},
{
name: "truncate-noop",
input: "hello world",
output: "hello world",
op: func(t *testing.T, b *Buffer) {
b.Truncate(b.Size() + 1)
},
},
{
name: "truncate-multiple-buffers",
input: strings.Repeat("1", baseChunkSize),
output: strings.Repeat("1", baseChunkSize*2-1),
op: func(t *testing.T, b *Buffer) {
b.Append(NewViewWithData([]byte(strings.Repeat("1", baseChunkSize))))
b.Truncate(baseChunkSize*2 - 1)
},
},
{
name: "truncate-multiple-buffers-to-one",
input: strings.Repeat("1", baseChunkSize),
output: "11111",
op: func(t *testing.T, b *Buffer) {
b.Append(NewViewWithData([]byte(strings.Repeat("1", baseChunkSize))))
b.Truncate(5)
},
},
// TrimFront.
{
name: "trim",
input: "hello world",
output: "world",
op: func(t *testing.T, b *Buffer) {
b.TrimFront(6)
},
},
{
name: "trim-too-large",
input: "hello world",
output: "",
op: func(t *testing.T, b *Buffer) {
b.TrimFront(b.Size() + 1)
},
},
{
name: "trim-multiple-buffers",
input: strings.Repeat("1", baseChunkSize),
output: strings.Repeat("1", baseChunkSize*2-1),
op: func(t *testing.T, b *Buffer) {
b.Append(NewViewWithData([]byte(strings.Repeat("1", baseChunkSize))))
b.TrimFront(1)
},
},
{
name: "trim-multiple-buffers-to-one-buffer",
input: strings.Repeat("1", baseChunkSize),
output: "1",
op: func(t *testing.T, b *Buffer) {
b.Append(NewViewWithData([]byte(strings.Repeat("1", baseChunkSize))))
b.TrimFront(baseChunkSize*2 - 1)
},
},
// GrowTo.
{
name: "growto",
input: "hello world",
output: "hello world",
op: func(t *testing.T, b *Buffer) {
b.GrowTo(1, true)
},
},
{
name: "growto-from-zero",
output: strings.Repeat("\x00", 1024),
op: func(t *testing.T, b *Buffer) {
b.GrowTo(1024, true)
},
},
{
name: "growto-from-non-zero",
input: strings.Repeat("1", baseChunkSize),
output: strings.Repeat("1", baseChunkSize) + strings.Repeat("\x00", baseChunkSize),
op: func(t *testing.T, b *Buffer) {
b.GrowTo(baseChunkSize*2, true)
},
},
// Clone.
{
name: "clone",
input: "hello",
output: "hello",
op: func(t *testing.T, b *Buffer) {
other := b.Clone()
bs := other.Flatten()
want := []byte("hello")
if !bytes.Equal(bs, want) {
t.Errorf("expected %v, got %v", want, bs)
}
},
},
{
name: "copy-large",
input: strings.Repeat("1", baseChunkSize+1),
output: strings.Repeat("1", baseChunkSize+1),
op: func(t *testing.T, b *Buffer) {
other := b.Clone()
bs := other.Flatten()
want := []byte(strings.Repeat("1", baseChunkSize+1))
if !bytes.Equal(bs, want) {
t.Errorf("expected %v, got %v", want, bs)
}
},
},
// Merge.
{
name: "merge",
input: "hello",
output: "hello world",
op: func(t *testing.T, b *Buffer) {
var other Buffer
other.Append(NewViewWithData([]byte(" world")))
b.Merge(&other)
if sz := other.Size(); sz != 0 {
t.Errorf("expected 0, got %d", sz)
}
},
},
{
name: "merge-large",
input: strings.Repeat("1", baseChunkSize+1),
output: strings.Repeat("1", baseChunkSize+1) + strings.Repeat("0", baseChunkSize+1),
op: func(t *testing.T, b *Buffer) {
var other Buffer
other.Append(NewViewWithData(([]byte(strings.Repeat("0", baseChunkSize+1)))))
b.Merge(&other)
if sz := other.Size(); sz != 0 {
t.Errorf("expected 0, got %d", sz)
}
},
},
// ReadAt.
{
name: "readat",
input: "hello",
output: "hello",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, 0, 6, "hello", io.EOF) },
},
{
name: "readat-long",
input: "hello",
output: "hello",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, 0, 8, "hello", io.EOF) },
},
{
name: "readat-short",
input: "hello",
output: "hello",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, 0, 3, "hel", nil) },
},
{
name: "readat-offset",
input: "hello",
output: "hello",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, 2, 3, "llo", io.EOF) },
},
{
name: "readat-long-offset",
input: "hello",
output: "hello",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, 2, 8, "llo", io.EOF) },
},
{
name: "readat-short-offset",
input: "hello",
output: "hello",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, 2, 2, "ll", nil) },
},
{
name: "readat-skip-all",
input: "hello",
output: "hello",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, baseChunkSize+1, 1, "", io.EOF) },
},
{
name: "readat-second-view",
input: strings.Repeat("0", baseChunkSize+1) + "12",
output: strings.Repeat("0", baseChunkSize+1) + "12",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, baseChunkSize+1, 1, "1", nil) },
},
{
name: "readat-second-buffer-end",
input: strings.Repeat("0", baseChunkSize+1) + "12",
output: strings.Repeat("0", baseChunkSize+1) + "12",
op: func(t *testing.T, b *Buffer) { testReadAt(t, b, baseChunkSize+1, 2, "12", io.EOF) },
},
}
for _, tc := range testCases {
for fillName, fn := range fillFuncs {
t.Run(fillName+"/"+tc.name, func(t *testing.T) {
// Construct & fill the view.
var buf Buffer
fn(&buf, []byte(tc.input))
// Run the operation.
if tc.op != nil {
tc.op(t, &buf)
}
// Flatten and validate.
out := buf.Flatten()
if !bytes.Equal([]byte(tc.output), out) {
t.Errorf("expected %q, got %q", tc.output, string(out))
}
// Ensure the size is correct.
if len(out) != int(buf.Size()) {
t.Errorf("size is wrong: expected %d, got %d", len(out), buf.Size())
}
// Calculate contents via apply.
var appliedOut []byte
buf.Apply(func(v *View) {
appliedOut = append(appliedOut, v.AsSlice()...)
})
if len(appliedOut) != len(out) {
t.Errorf("expected %d, got %d", len(out), len(appliedOut))
}
if !bytes.Equal(appliedOut, out) {
t.Errorf("expected %v, got %v", out, appliedOut)
}
// Calculate contents via ReadToWriter.
var b bytes.Buffer
n, err := buf.ReadToWriter(&b, int64(len(out)))
if n != int64(len(out)) {
t.Errorf("expected %d, got %d", len(out), n)
}
if err != nil {
t.Errorf("expected nil, got %v", err)
}
if !bytes.Equal(b.Bytes(), out) {
t.Errorf("expected %v, got %v", out, b.Bytes())
}
})
}
}
}
func TestBufferPullUp(t *testing.T) {
for _, tc := range []struct {
desc string
inputs []string
offset int
length int
output string
failed bool
// lengths is the lengths of each buffer node after the pull up.
lengths []int
}{
{
desc: "whole empty view",
},
{
desc: "zero pull",
inputs: []string{"hello", " world"},
lengths: []int{5, 6},
},
{
desc: "whole view",
inputs: []string{"hello", " world"},
offset: 0,
length: 11,
output: "hello world",
lengths: []int{11},
},
{
desc: "middle to end aligned",
inputs: []string{"0123", "45678", "9abcd"},
offset: 4,
length: 10,
output: "456789abcd",
lengths: []int{4, 10},
},
{
desc: "middle to end unaligned",
inputs: []string{"0123", "45678", "9abcd"},
offset: 6,
length: 8,
output: "6789abcd",
lengths: []int{4, 10},
},
{
desc: "middle aligned",
inputs: []string{"0123", "45678", "9abcd", "efgh"},
offset: 6,
length: 5,
output: "6789a",
lengths: []int{4, 10, 4},
},
// Failed cases.
{
desc: "empty view - length too long",
offset: 0,
length: 1,
failed: true,
},
{
desc: "empty view - offset too large",
offset: 1,
length: 1,
failed: true,
},
{
desc: "length too long",
inputs: []string{"0123", "45678", "9abcd"},
offset: 4,
length: 100,
failed: true,
lengths: []int{4, 5, 5},
},
{
desc: "offset too large",
inputs: []string{"0123", "45678", "9abcd"},
offset: 100,
length: 1,
failed: true,
lengths: []int{4, 5, 5},
},
} {
t.Run(tc.desc, func(t *testing.T) {
var b Buffer
defer b.Release()
for _, s := range tc.inputs {
v := NewViewWithData([]byte(s))
b.appendOwned(v)
}
got, gotOk := b.PullUp(tc.offset, tc.length)
want, wantOk := []byte(tc.output), !tc.failed
if gotOk == wantOk && got.Size() == 0 && len(want) == 0 {
return
}
if gotOk != wantOk || !bytes.Equal(got.AsSlice(), want) {
t.Errorf("v.PullUp(%d, %d) = %q, %t; %q, %t", tc.offset, tc.length, got.AsSlice(), gotOk, want, wantOk)
}
var gotLengths []int
for v := b.data.Front(); v != nil; v = v.Next() {
gotLengths = append(gotLengths, v.Size())
}
if !reflect.DeepEqual(gotLengths, tc.lengths) {
t.Errorf("lengths = %v; want %v", gotLengths, tc.lengths)
}
})
}
}
func TestReadFromLargeWriter(t *testing.T) {
writeSize := int64(1 << 20)
largeWriter := bytes.NewBuffer(make([]byte, writeSize))
b := Buffer{}
// Expect this write to be buffered into several MaxChunkSize sized views.
n, err := b.WriteFromReader(largeWriter, writeSize)
if err != nil {
t.Fatalf("b.WriteFromReader() failed: want err=nil, got %v", err)
}
if n != writeSize {
t.Errorf("got b.WriteFromReader()=%d, want %d", n, writeSize)
}
nChunks := int(writeSize / MaxChunkSize)
if b.data.Len() != nChunks {
t.Errorf("b.WriteFromReader() failed, got b.data.Len()=%d, want %d", b.data.Len(), nChunks)
}
}
func TestRead(t *testing.T) {
readStrings := []string{"abcdef", "123456", "ghijkl"}
totalSize := len(readStrings) * len(readStrings[0])
for readSz := 0; readSz < totalSize+1; readSz++ {
b := Buffer{}
for _, s := range readStrings {
v := NewViewWithData([]byte(s))
b.appendOwned(v)
}
orig := b.Clone()
orig.Truncate(int64(readSz))
p := make([]byte, readSz)
_, err := b.read(p)
if err != nil {
t.Fatalf("Read([]byte(%d)) failed: %v", readSz, err)
}
if !bytes.Equal(p, orig.Flatten()) {
t.Errorf("Read([]byte(%d)) failed, want p=%v, got %v", readSz, orig.Flatten(), p)
}
if int(b.Size()) != totalSize-readSz {
t.Errorf("Read([]byte(%d)) failed, want b.Size()=%v, got %v", readSz, totalSize-readSz, b.Size())
}
}
}
func TestReadByte(t *testing.T) {
readString := "abcdef123456ghijkl"
b := Buffer{}
nViews := 3
for i := 0; i < nViews; i++ {
vLen := len(readString) / nViews
v := NewViewWithData([]byte(readString[i*vLen : (i+1)*vLen]))
b.appendOwned(v)
}
for i := 0; i < len(readString); i++ {
orig := readString[i]
bt, err := b.readByte()
if err != nil {
t.Fatalf("readByte() failed: %v", err)
}
if bt != orig {
t.Errorf("readByte() failed, want %v, got %v", orig, bt)
}
if int(b.Size()) != len(readString[i+1:]) {
t.Errorf("readByte() failed, want b.Size()=%v, got %v", len(readString[i+1:]), b.Size())
}
}
}
func TestPullUpModifiedViews(t *testing.T) {
var b Buffer
defer b.Release()
for _, s := range []string{"abcdef", "123456", "ghijkl"} {
v := NewViewWithData([]byte(s))
v.TrimFront(3)
b.appendOwned(v)
}
v, ok := b.PullUp(3, 3)
if !ok {
t.Errorf("PullUp failed: want ok=true, got ok=false")
}
want := []byte("456")
if !bytes.Equal(v.AsSlice(), want) {
t.Errorf("PullUp failed: want %v, got %v", want, v.AsSlice())
}
}
func TestBufferClone(t *testing.T) {
const (
originalSize = 90
bytesToDelete = 30
)
b := MakeWithData(bytes.Repeat([]byte{originalSize}, originalSize))
clonedB := b.Clone()
b.TrimFront(bytesToDelete)
if got, want := int(b.Size()), originalSize-bytesToDelete; got != want {
t.Errorf("original buffer was not changed: size expected = %d, got = %d", want, got)
}
if got := clonedB.Size(); got != originalSize {
t.Errorf("cloned buffer should not be modified: expected size = %d, got = %d", originalSize, got)
}
}
func TestBufferSubApply(t *testing.T) {
var b Buffer
defer b.Release()
b.appendOwned(NewViewWithData([]byte("0123")))
b.appendOwned(NewViewWithData([]byte("45678")))
b.appendOwned(NewViewWithData([]byte("9abcd")))
data := []byte("0123456789abcd")
for i := 0; i <= len(data); i++ {
for j := i; j <= len(data); j++ {
t.Run(fmt.Sprintf("SubApply(%d,%d)", i, j), func(t *testing.T) {
var got []byte
b.SubApply(i, j-i, func(v *View) {
got = append(got, v.AsSlice()...)
})
if want := data[i:j]; !bytes.Equal(got, want) {
t.Errorf("got = %q; want %q", got, want)
}
})
}
}
}
func doSaveAndLoad(t *testing.T, toSave, toLoad *Buffer) {
t.Helper()
var buf bytes.Buffer
ctx := context.Background()
if _, err := state.Save(ctx, &buf, toSave); err != nil {
t.Fatal("state.Save:", err)
}
if _, err := state.Load(ctx, bytes.NewReader(buf.Bytes()), toLoad); err != nil {
t.Fatal("state.Load:", err)
}
}
func TestSaveRestoreBufferEmpty(t *testing.T) {
var toSave Buffer
var b Buffer
doSaveAndLoad(t, &toSave, &b)
if got := b.Flatten(); len(got) != 0 {
t.Errorf("v.Flatten() = %x, want []", got)
}
}
func TestSaveRestoreBuffer(t *testing.T) {
// Create data that fits slots.
data := bytes.Join([][]byte{
bytes.Repeat([]byte{1, 2}, baseChunkSize),
}, nil)
var toSave Buffer
toSave.appendOwned(NewViewWithData(data))
var b Buffer
doSaveAndLoad(t, &toSave, &b)
// Next available slot at index 3; 0-2 slot are used.
if got := b.Flatten(); !bytes.Equal(got, data) {
t.Errorf("v.Flatten() = %x, want %x", got, data)
}
}
func TestRangeIntersect(t *testing.T) {
for _, tc := range []struct {
desc string
x, y, want Range
}{
{
desc: "empty intersects empty",
},
{
desc: "empty intersection",
x: Range{end: 10},
y: Range{begin: 10, end: 20},
},
{
desc: "some intersection",
x: Range{begin: 5, end: 20},
y: Range{end: 10},
want: Range{begin: 5, end: 10},
},
} {
t.Run(tc.desc, func(t *testing.T) {
if got := tc.x.Intersect(tc.y); got != tc.want {
t.Errorf("(%#v).Intersect(%#v) = %#v; want %#v", tc.x, tc.y, got, tc.want)
}
if got := tc.y.Intersect(tc.x); got != tc.want {
t.Errorf("(%#v).Intersect(%#v) = %#v; want %#v", tc.y, tc.x, got, tc.want)
}
})
}
}
func TestRangeOffset(t *testing.T) {
for _, tc := range []struct {
input Range
offset int
output Range
}{
{
input: Range{},
offset: 0,
output: Range{},
},
{
input: Range{},
offset: -1,
output: Range{begin: -1, end: -1},
},
{
input: Range{begin: 10, end: 20},
offset: -1,
output: Range{begin: 9, end: 19},
},
{
input: Range{begin: 10, end: 20},
offset: 2,
output: Range{begin: 12, end: 22},
},
} {
if got := tc.input.Offset(tc.offset); got != tc.output {
t.Errorf("(%#v).Offset(%d) = %#v, want %#v", tc.input, tc.offset, got, tc.output)
}
}
}
func TestRangeLen(t *testing.T) {
for _, tc := range []struct {
r Range
want int
}{
{r: Range{}, want: 0},
{r: Range{begin: 1, end: 1}, want: 0},
{r: Range{begin: -1, end: -1}, want: 0},
{r: Range{end: 10}, want: 10},
{r: Range{begin: 5, end: 10}, want: 5},
} {
if got := tc.r.Len(); got != tc.want {
t.Errorf("(%#v).Len() = %d, want %d", tc.r, got, tc.want)
}
}
}
func TestChecksum(t *testing.T) {
data := make([]byte, 100)
rand.Read(data)
b := MakeWithData(data[:30])
b.appendOwned(NewViewWithData(data[30:70]))
b.appendOwned(NewViewWithData(data[70:]))
for offset := 0; offset < 100; offset++ {
var cs checksum.Checksumer
cs.Add(data[offset:])
dataChecksum := cs.Checksum()
bufChecksum := b.Checksum(offset)
if dataChecksum != bufChecksum {
t.Errorf("(%#v).Checksum(%d) = %d, want %d", b, offset, bufChecksum, dataChecksum)
}
}
}
|
package saying
import (
"fmt"
"testing"
)
func TestGreet(t *testing.T) {
returnedString := Greet("Juan")
if returnedString != "Hello my dear Juan" {
t.Error("Got", returnedString, "Expected: Hello my dear Juan")
}
}
func ExampleGreet() {
fmt.Println(Greet("Juan"))
// Output:
// Hello my dear Juan
}
func BenchmarkGreet(b *testing.B) {
for i := 0; i < b.N; i++ {
Greet("Juan")
}
}
|
package diag
import (
"os"
pkgLog "github.com/kapitanov/natandb/pkg/log"
"github.com/spf13/cobra"
)
var log = pkgLog.New("")
// Command is root for diagnostics commands
var Command = &cobra.Command{
Use: "diag",
Short: "Diagnostics tools",
Hidden: true,
TraverseChildren: true,
Run: func(cmd *cobra.Command, args []string) {
cmd.Printf("try \"%s %s --help\" for more information\n", cmd.CommandPath(), cmd.Use)
os.Exit(0)
},
}
|
package apiset
import (
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
)
// A set of API Objects of different types.
type ObjectSet map[string]TypedObjectSet
func (s ObjectSet) GetSetForType(o Object) TypedObjectSet {
return s[o.GetGroupVersionResource().String()]
}
func (s ObjectSet) Add(o Object) {
s.GetOrCreateTypedSet(o)[o.GetName()] = o
}
// `o` is only used to indicate the type - it does not get added to the set
func (s ObjectSet) AddSetForType(o Object, set TypedObjectSet) {
gvk := o.GetGroupVersionResource()
dst := s[gvk.String()]
if dst == nil {
s[gvk.String()] = set
return
}
for k, v := range set {
dst[k] = v
}
}
func (s ObjectSet) GetOrCreateTypedSet(o Object) TypedObjectSet {
gvk := o.GetGroupVersionResource()
set := s[gvk.String()]
if set == nil {
set = TypedObjectSet{}
s[gvk.String()] = set
}
return set
}
// A set of API Objects of the same type.
type TypedObjectSet map[string]Object
// An API object with the methods we need to do bulk creation.
type Object interface {
ctrlclient.Object
GetSpec() interface{}
GetGroupVersionResource() schema.GroupVersionResource
NewList() runtime.Object
}
|
package multimarshal
type JsonMarshall map[string]string
|
package main
import (
"fmt"
"strconv"
"sync"
)
func main() {
c1 := make(chan int)
c2 := make(chan int)
go func() {
c1 <- 3
close(c1)
}()
go func() {
c2 <- 1
close(c2)
}()
res := combine(c1, c2)
for v := range res {
fmt.Println(v)
}
}
func combine(chs ...<-chan int) <-chan int {
var wg sync.WaitGroup
output := make(chan int)
send := func(c <-chan int) {
for val := range c {
output <- val
fmt.Println(":" + strconv.Itoa(val))
}
// select {
// case val := <-c:
// output <- val
// }
fmt.Println("before done")
wg.Done()
}
wg.Add(len(chs))
for _, c := range chs {
go send(c)
}
go func() {
wg.Wait()
close(output)
}()
return output
}
|
package model
type Role int
const(
Regular Role = iota
Administrator
Agent
)
|
package gitlabClient
import (
"fmt"
"github.com/xanzy/go-gitlab"
)
func (git *GitLab) GetMilestoneByProjectName(pid gitlab.Project, milestoune string) (*gitlab.Milestone, error) {
opt := gitlab.ListMilestonesOptions{
Search: milestoune,
ListOptions: gitlab.ListOptions{
PerPage: 100,
Page: 1,
},
}
for {
// Get the first page with projects.
milesounes, resp, err := git.Client.Milestones.ListMilestones(pid.ID, &opt)
if err != nil {
return nil, err
}
// List all the projects we've found so far.
//for _, p := range milesounes {
// fmt.Printf("Found milesoune: %s", p.Title)
//}
// Exit the loop when we've seen all pages.
if resp.CurrentPage >= resp.TotalPages {
if len(milesounes) != 0 {
return milesounes[0], err
}
return nil, err
}
// Update the page number to get the next page.
opt.Page = resp.NextPage
}
}
func (git *GitLab) GetProjectMilestoneIssues(name string) ([]*gitlab.Issue, error) {
var issues []*gitlab.Issue
nameMilestoune := fmt.Sprintf("\"%s\"", name)
projects, err := git.GetListProject()
if err != nil {
return nil, err
}
for _, project := range projects {
m, err := git.GetMilestoneByProjectName(*project, nameMilestoune)
if err != nil || m == nil {
// TODO: Check status code 403/404/etc
//return nil, err
continue
}
opt := gitlab.GetMilestoneIssuesOptions{
PerPage: 100,
Page: 1,
}
for {
// Get the first page with projects.
iss, resp, err := git.Client.Milestones.GetMilestoneIssues(project.ID, m.ID, &opt)
if err != nil {
return issues, err
}
// Exit the loop when we've seen all pages.
if resp.CurrentPage >= resp.TotalPages {
issues = append(issues, iss...)
break
}
// Update the page number to get the next page.
opt.Page = resp.NextPage
}
}
return issues, nil
}
|
/* -------------------------------------------------------------------------- */
/* https://leetcode.com/problems/3sum/ */
/* -------------------------------------------------------------------------- */
package main
import (
"sort"
)
func twoPointerSum(nums []int, target int, ans *[][]int) {
i := 0
j := len(nums) - 1
for i < j {
// Ignore this num if its same as previous number to avoid duplicates
if i > 0 && nums[i] == nums[i-1] {
i++
continue
}
// Ignore this num if its same as previous number to avoid duplicates
if j < len(nums)-1 && nums[j] == nums[j+1] {
j--
continue
}
if nums[i]+nums[j] < target {
i++
} else if nums[i]+nums[j] > target {
j--
} else {
*ans = append(*ans, []int{nums[i], nums[j], -target})
i++
j--
}
}
}
func ThreeSum(nums []int) [][]int {
sort.Ints(nums)
ans := [][]int{}
for i := range nums {
// Ignore this num if its same as previous number to avoid duplicates
if i > 0 && nums[i] == nums[i-1] {
continue
}
twoPointerSum(nums[i+1:], -nums[i], &ans)
}
return ans
}
|
package middleware
import (
"fmt"
"github.com/gin-gonic/gin"
)
func CORSMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
c.Writer.Header().Set("Access-Control-Max-Age", "86400")
c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
if c.Request.Method == "OPTIONS" {
fmt.Println("OPTIONS")
c.AbortWithStatus(200)
} else {
c.Next()
}
}
}
|
package format
import (
"context"
"testing"
"github.com/ipfs/go-cid"
mh "github.com/multiformats/go-multihash"
)
type TestNode struct {
links []*Link
data []byte
builder cid.Builder
}
var v0CidPrefix = cid.Prefix{
Codec: cid.DagProtobuf,
MhLength: -1,
MhType: mh.SHA2_256,
Version: 0,
}
func InitNode(d []byte) *TestNode {
return &TestNode{
data: d,
builder: v0CidPrefix,
}
}
func (n *TestNode) Resolve([]string) (interface{}, []string, error) {
return nil, nil, ErrEmptyNode
}
func (n *TestNode) Tree(string, int) []string {
return nil
}
func (n *TestNode) ResolveLink([]string) (*Link, []string, error) {
return nil, nil, ErrEmptyNode
}
func (n *TestNode) Copy() Node {
return &EmptyNode{}
}
func (n *TestNode) Cid() cid.Cid {
c, err := n.builder.Sum(n.RawData())
if err != nil {
return cid.Cid{}
}
return c
}
func (n *TestNode) Links() []*Link {
return n.links
}
func (n *TestNode) Loggable() map[string]interface{} {
return nil
}
func (n *TestNode) String() string {
return string(n.data)
}
func (n *TestNode) RawData() []byte {
return n.data
}
func (n *TestNode) Size() (uint64, error) {
return 0, nil
}
func (n *TestNode) Stat() (*NodeStat, error) {
return &NodeStat{}, nil
}
// AddNodeLink adds a link to another node.
func (n *TestNode) AddNodeLink(name string, that Node) error {
lnk, err := MakeLink(that)
if err != nil {
return err
}
lnk.Name = name
n.AddRawLink(name, lnk)
return nil
}
func (n *TestNode) AddRawLink(name string, l *Link) error {
n.links = append(n.links, &Link{
Name: name,
Size: l.Size,
Cid: l.Cid,
})
return nil
}
func TestCopy(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
from := newTestDag()
root := InitNode([]byte("level0"))
l11 := InitNode([]byte("leve1_node1"))
l12 := InitNode([]byte("leve1_node2"))
l21 := InitNode([]byte("leve2_node1"))
l22 := InitNode([]byte("leve2_node2"))
l23 := InitNode([]byte("leve2_node3"))
l11.AddNodeLink(l21.Cid().String(), l21)
l11.AddNodeLink(l22.Cid().String(), l22)
l11.AddNodeLink(l23.Cid().String(), l23)
root.AddNodeLink(l11.Cid().String(), l11)
root.AddNodeLink(l12.Cid().String(), l12)
for _, n := range []Node{l23, l22, l21, l12, l11, root} {
err := from.Add(ctx, n)
if err != nil {
t.Fatal(err)
}
}
to := newTestDag()
err := Copy(ctx, from, to, root.Cid())
if err != nil {
t.Error(err)
}
r, err := to.Get(ctx, root.Cid())
if err != nil || len(r.Links()) != 2 {
t.Error("fail to copy dag")
}
l1, err := to.Get(ctx, l11.Cid())
if err != nil || len(l1.Links()) != 3 {
t.Error("fail to copy dag")
}
}
|
//go:generate go run github.com/golang/mock/mockgen -source logging.go -destination mock/logging_mock.go -package mock
package utility
import (
"os"
log "github.com/sirupsen/logrus"
prefixed "github.com/x-cray/logrus-prefixed-formatter"
)
type LoggingInterface interface {
LogError(err error)
LogInfo(message string)
LogDebug(message string)
LogWarning(message interface{})
}
type Logging struct{}
func NewLogging() LoggingInterface {
log.SetOutput(os.Stderr)
log.SetFormatter(&prefixed.TextFormatter{
DisableColors: true,
TimestampFormat: "2006-01-02 15:04:05",
FullTimestamp: true,
ForceFormatting: true,
})
return &Logging{}
}
func (*Logging) LogError(err error) {
log.Error(err)
}
func (*Logging) LogInfo(message string) {
log.Info(message)
}
func (*Logging) LogDebug(message string) {
log.SetLevel(log.DebugLevel)
log.Debug(message)
}
func (*Logging) LogWarning(message interface{}) {
log.Warning(message)
}
// TODO: Add debug, info, warning, panic
|
package Pair
import (
"fmt"
"io"
"strings"
"unicode"
)
type Exchanger interface {
Exchange()
}
func ExchangeThese(exchangers ...Exchanger) {
for _, exchanger := range exchangers {
exchanger.Exchange()
}
}
//----------------------------------------
type LowerCaser interface {
LowerCase()
}
type UpperCaser interface {
UpperCase()
}
type LowerUpperCaser interface {
LowerCaser
UpperCaser
}
type FixCaser interface {
FixCase()
}
type ChangeCaser interface {
LowerUpperCaser
FixCaser
}
//------------------------------
type StringPair struct {
First, Second string
}
func (pair *StringPair) Exchange() {
pair.First, pair.Second = pair.Second, pair.First
}
func (pair StringPair) String() string {
return fmt.Sprintf("%q+%q", pair.First, pair.Second)
}
func (pair *StringPair) Read(data []byte) (n int, err error) {
if pair.First == "" && pair.Second == "" {
return 0, io.EOF
}
if pair.First != "" {
n = copy(data, pair.First)
pair.First = pair.First[n:]
}
if n < len(data) && pair.Second != "" {
m := copy(data[n:], pair.Second)
pair.Second = pair.Second[m:]
n += m
}
return n, nil
}
func (pair *StringPair) UpperCase() {
pair.First = strings.ToUpper(pair.First)
pair.Second = strings.ToUpper(pair.Second)
}
func (pair *StringPair) LowerCase() {
pair.First = strings.ToLower(pair.First)
pair.Second = strings.ToLower(pair.Second)
}
func (pair *StringPair) FixCase() {
pair.First = FixCase(pair.First)
pair.Second = FixCase(pair.Second)
}
//----------------------------
type Point [2]int
func (point *Point) Exchange() {
point[0], point[1] = point[1], point[0]
}
//-------------------------------
func FixCase(s string) string {
var chars []rune
upper := true
for _, char := range s {
if upper {
char = unicode.ToUpper(char)
} else {
char = unicode.ToLower(char)
}
chars = append(chars, char)
upper = unicode.IsSpace(char) || unicode.Is(unicode.Hyphen, char)
}
return string(chars)
}
|
// Package intset provides a specialized set for integers or runes
package intset
// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
func upTwo(v int) int {
v--
v |= v >> 1
v |= v >> 2
v |= v >> 4
v |= v >> 8
v |= v >> 16
v++
return v
}
|
// http://mattn.github.io/go-gtk/
// https://github.com/mattn/go-gtk
// apt-get install libgtk2.0-dev libglib2.0-dev libgtksourceview2.0-dev
// go get github.com/mattn/go-gtk/gdkpixbuf
// go get github.com/mattn/go-pointer
// go get https://github.com/mattn/go-gtk
package lib
import (
"fmt"
"github.com/mattn/go-gtk/glib"
"github.com/mattn/go-gtk/gtk"
)
func Run(db Database) (string, error) {
gtk.Init(nil)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetPosition(gtk.WIN_POS_CENTER)
window.SetResizable(false)
window.SetTitle("GoPass")
window.Connect("destroy", func(ctx *glib.CallbackContext) {
fmt.Println("Destroy!", ctx.Data().(string))
gtk.MainQuit()
}, "goodbye")
statusbar := gtk.NewStatusbar()
statusbar_context_id := statusbar.GetContextId("go-gtk")
statusbar.Push(statusbar_context_id, "")
//--------------------------------------------------------
// GtkVBox
//--------------------------------------------------------
vbox := gtk.NewVBox(false, 1)
//--------------------------------------------------------
// GtkMenuBar
//--------------------------------------------------------
menubar := gtk.NewMenuBar()
vbox.PackStart(menubar, false, false, 0)
//--------------------------------------------------------
// GtkVPaned
//--------------------------------------------------------
vpaned := gtk.NewVPaned()
vbox.Add(vpaned)
//--------------------------------------------------------
// GtkFrame
//--------------------------------------------------------
frame1 := gtk.NewFrame("Store")
framebox1 := gtk.NewVBox(false, 1)
frame1.Add(framebox1)
vpaned.Pack1(frame1, false, false)
//--------------------------------------------------------
// GtkEntry
//--------------------------------------------------------
pass_row := gtk.NewHBox(false, 1)
pass_label := gtk.NewLabel("Passphrase")
pass_row.Add(pass_label)
pass_entry := gtk.NewEntry()
pass_row.Add(pass_entry)
val_row := gtk.NewHBox(false, 1)
val_label := gtk.NewLabel("Value ")
val_row.Add(val_label)
val_entry := gtk.NewEntry()
val_row.Add(val_entry)
//
key_row := gtk.NewHBox(false, 1)
key_label := gtk.NewLabel("Key ")
// key_label := gtk.NewLabel("Key")
key_row.Add(key_label)
// key_entry := gtk.NewEntry()
// key_row.Add(key_entry)
// DROP DOWN
comboboxentry := gtk.NewComboBoxEntryNewText()
keys, _ := db.Keys("store")
for i := range keys {
comboboxentry.AppendText(keys[i])
}
comboboxentry.Connect("changed", func() {
val_entry.SetText("")
})
// remove keys
// n_keys := len(keys)
// for i := 0; i < n_keys+1; i++ {
// fmt.Println(i)
// comboboxentry.RemoveText(i)
// }
key_row.PackStart(comboboxentry, false, false, 0)
//.end
framebox1.Add(key_row)
framebox1.Add(pass_row)
framebox1.Add(val_row)
//--------------------------------------------------------
// GtkHBox
//--------------------------------------------------------
buttons := gtk.NewHBox(false, 1)
get_button := gtk.NewButtonWithLabel("GET")
get_button.Clicked(func() {
key := comboboxentry.GetActiveText()
value, err := db.Get("store", key, pass_entry.GetText())
// value, err := db.Get("store", key_entry.GetText(), pass_entry.GetText())
if nil != err {
val_entry.SetText("")
statusbar.Push(statusbar_context_id, err.Error())
} else {
val_entry.SetText(value)
statusbar.Push(statusbar_context_id, "Success")
}
})
buttons.Add(get_button)
set_button := gtk.NewButtonWithLabel("SET")
set_button.Clicked(func() {
// db.Set("store", key_entry.GetText(), val_entry.GetText(), pass_entry.GetText())
key := comboboxentry.GetActiveText()
db.Set("store", key, val_entry.GetText(), pass_entry.GetText())
})
buttons.Add(set_button)
framebox1.PackStart(buttons, false, false, 0)
//--------------------------------------------------------
// GtkStatusbar
//--------------------------------------------------------
// statusbar := gtk.NewStatusbar()
// context_id := statusbar.GetContextId("go-gtk")
// statusbar.Push(context_id, "")
framebox1.PackStart(statusbar, false, false, 0)
//--------------------------------------------------------
// Event
//--------------------------------------------------------
window.Add(vbox)
window.SetSizeRequest(300, 200)
window.ShowAll()
gtk.Main()
return "", nil
}
|
package main
import (
"fmt"
"log"
"net/http"
"time"
httputils "github.com/cascades-fbp/cascades-http/utils"
uuid "github.com/nu7hatch/gouuid"
)
const (
timeout = time.Duration(15) * time.Second
)
type HandlerRequest struct {
ResponseCh chan httputils.HTTPResponse
Request *httputils.HTTPRequest
}
func respondWithTimeout(rw http.ResponseWriter) {
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprint(rw, "Couldn't process request in a given time")
}
func Handler(out chan HandlerRequest) http.HandlerFunc {
return func(rw http.ResponseWriter, req *http.Request) {
log.Println("Handler:", req.Method, req.RequestURI)
id, _ := uuid.NewV4()
r := httputils.Request2Request(req)
r.Id = id.String()
hr := &HandlerRequest{
ResponseCh: make(chan httputils.HTTPResponse),
Request: r,
}
// Send request to OUT port
log.Println("Sending request to out channel (for OUTPUT port)")
select {
case out <- *hr:
case <-time.Tick(timeout):
respondWithTimeout(rw)
return
}
// Wait for response from IN port
log.Println("Waiting for response from a channel port (from INPUT port)")
var resp httputils.HTTPResponse
select {
case resp = <-hr.ResponseCh:
case <-time.Tick(timeout):
respondWithTimeout(rw)
return
}
log.Println("Data arrived. Responding to HTTP response...")
for name, values := range resp.Header {
for _, value := range values {
rw.Header().Add(name, value)
}
}
rw.WriteHeader(resp.StatusCode)
fmt.Fprint(rw, string(resp.Body))
}
}
|
package fmap_test
import (
"log"
"math/rand"
"os"
"github.com/lleo/go-functional-collections/fmap"
"github.com/lleo/go-functional-collections/key"
"github.com/lleo/stringutil"
"github.com/pkg/errors"
)
func init() {
log.SetFlags(log.Lshortfile)
var logFileName = "test.log"
var logFile, err = os.Create(logFileName)
if err != nil {
log.Fatal(errors.Wrapf(err, "failed to os.Create(%q)", logFileName))
}
log.SetOutput(logFile)
}
var Inc = stringutil.Lower.Inc
type KeyVal = fmap.KeyVal
func buildKvs(num int) []KeyVal {
var kvs = make([]KeyVal, num)
var keyStr = "a"
for i := 0; i < num; i++ {
kvs[i].Key = key.Str(keyStr)
kvs[i].Val = i
keyStr = Inc(keyStr)
}
return kvs
}
func buildStrings(num int) []string {
var strs = make([]string, num)
var str = "a"
for i := 0; i < num; i++ {
strs[i] = str
str = Inc(str)
}
return strs
}
func buildKeys(num int) []key.Hash {
var keys = make([]key.Hash, num)
for i, s := range buildStrings(num) {
keys[i] = key.Str(s)
}
return keys
}
func buildKvsFromStrings(strs []string) []KeyVal {
var kvs = make([]KeyVal, len(strs))
for i := 0; i < len(strs); i++ {
kvs[i].Key = key.Str(strs[i])
kvs[i].Val = i
}
return kvs
}
func randomizeKvs(kvs []KeyVal) []KeyVal {
var randKvs = make([]KeyVal, len(kvs))
copy(randKvs, kvs)
// randomize kvs
// https://en.wikipedia.org/wiki/Fisher–Yates_shuffle#The_modern_algorithm
for i := len(randKvs) - 1; i > 0; i-- {
var j = rand.Intn(i + 1)
randKvs[i], randKvs[j] = randKvs[j], randKvs[i]
}
return randKvs
}
func buildMap(kvs []KeyVal) *fmap.Map {
var m = fmap.New()
for _, kv := range kvs {
m = m.Put(kv.Key, kv.Val)
}
return m
}
|
package pingrr
const (
httpHeaderAuthorization = "Authorization"
)
type Credentials interface {
Headers() map[string]string
}
type oauthTokenCredentials struct {
oauthToken string
}
func NewOauthTokenCredentials(oauthToken string) Credentials {
return &oauthTokenCredentials{oauthToken: oauthToken}
}
func (c *oauthTokenCredentials) Headers() map[string]string {
return map[string]string{httpHeaderAuthorization: "Bearer " + c.oauthToken}
}
|
package handlers
import (
"encoding/json"
"net/http"
"rest/model"
)
// AddGarment - [Adds garment to list]
func AddGarment(w http.ResponseWriter, r *http.Request) {
garment := r.URL.Query().Get("garment")
list := model.AddToList(garment)
enableCors(&w)
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(list)
}
|
package main
import (
"sync"
"time"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
)
var client *mongo.Client
var lock sync.Mutex
var Defaultskip = int64(0)
var Defaultlimit = int64(10)
var skip = Defaultskip
var limit = Defaultlimit
type participant struct {
Name string `json:"name, omitempty" bson:"name, omitempty"`
Email string `json:"email, omitempty" bson:"email, omitempty"`
Rsvp string `json:"rsvp, omitempty" bson:"rsvp, omitempty"`
}
type Meeting struct {
ID primitive.ObjectID `json:"_id, omitempty" bson:"_id, omitempty"`
Title string `json:"title, omitempty" bson:"title, omitempty"`
Participants []participant `json:"participants, omitempty" bson:"participants, omitempty"`
Starttime string `json:"starttime, omitempty" bson:"starttime, omitempty"`
Endtime string `json:"endtime, omitempty" bson:"endtime, omitempty"`
Creationtime string `json:"creationtime, omitempty" bson:"creationtime, omitempty"`
}
func (person *participant) cons() {
if person.Rsvp == "" {
person.Rsvp = "Not Answered"
}
if person.Email == "" {
person.Email = "default@email.com"
}
if person.Name == "" {
person.Name = person.Email
}
}
func (obj *Meeting) def() {
if obj.Title == "" {
obj.Title = "Untitled Meeting"
}
if obj.Starttime == "" {
obj.Starttime = string(time.Now().Format(time.RFC3339))
}
if obj.Endtime == "" {
obj.Endtime = string(time.Now().Local().Add(time.Hour * time.Duration(1)).Format(time.RFC3339))
}
if obj.Creationtime == "" {
obj.Creationtime = string(time.Now().Format(time.RFC3339))
}
for i := range obj.Participants {
obj.Participants[i].cons()
}
}
|
package label
import (
"testing"
"github.com/google/go-github/v47/github"
)
func TestHasLabel(t *testing.T) {
basicLabels := []*github.Label{
{
Name: github.String("foo"),
},
{
Name: github.String("bar"),
},
{
Name: github.String("fii"),
},
{
Name: github.String("bir"),
},
}
testCases := []struct {
name string
labels []*github.Label
label string
expectedResult bool
}{
{
name: "label exists",
labels: basicLabels,
label: "foo",
expectedResult: true,
},
{
name: "label not exists",
labels: basicLabels,
label: "fuu",
expectedResult: false,
},
{
name: "empty labels",
labels: []*github.Label{},
label: "fuu",
expectedResult: false,
},
{
name: "empty label",
labels: basicLabels,
label: "",
expectedResult: false,
},
}
for _, test := range testCases {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
result := HasLabel(test.labels, test.label)
if result != test.expectedResult {
t.Errorf("Got %t, want %t", result, test.expectedResult)
}
})
}
}
func TestHasStatus(t *testing.T) {
testsCases := []struct {
name string
labels []*github.Label
expectedResult bool
}{
{
name: "with status label",
labels: []*github.Label{
{
Name: github.String("foo"),
},
{
Name: github.String("bar"),
},
{
Name: github.String("status/test"),
},
},
expectedResult: true,
},
{
name: "without status label",
labels: []*github.Label{
{
Name: github.String("foo"),
},
{
Name: github.String("bar"),
},
{
Name: github.String("fii"),
},
},
expectedResult: false,
},
{
name: "with WIP label",
labels: []*github.Label{
{
Name: github.String("foo"),
},
{
Name: github.String("bar"),
},
{
Name: github.String("WIP"),
},
},
expectedResult: true,
},
}
for _, test := range testsCases {
test := test
t.Run(test.name, func(t *testing.T) {
result := HasStatus(test.labels)
if result != test.expectedResult {
t.Errorf("Got %t, want %t", result, test.expectedResult)
}
})
}
}
|
package session
import (
"context"
"gamesvr/manager"
"shared/common"
"shared/csv/static"
"shared/protobuf/pb"
"shared/statistic/logreason"
"shared/utility/coordinate"
"shared/utility/errors"
"shared/utility/glog"
)
//TryPushGraveyard 因为Graveyard公会互助，别人触发自己的推送，所以只放在timmerpush
func (s *Session) TryPushGraveyard() {
for _, push := range s.User.Notifies.GraveyardPush {
cmd, err := manager.CSV.Protocol.GetCmdByProtoName(push)
if err != nil {
glog.Errorf("TryPushGraveyard GetCmdByProtoName err:%+v", err)
continue
}
err = s.push(cmd, push)
if err != nil {
glog.Errorf("TryPushGraveyard push err:%+v", err)
continue
}
}
s.User.Notifies.GraveyardPush = nil
}
// GraveyardGetInfo 进玩法
func (s *Session) GraveyardGetInfo(ctx context.Context, req *pb.C2SGraveyardGetInfo) (*pb.S2CGraveyardGetInfo, error) {
return s.User.GraveyardGetInfo(), nil
}
//--------------------------建造相关
// GraveyardBuildCreate 建造
func (s *Session) GraveyardBuildCreate(ctx context.Context, req *pb.C2SGraveyardBuildCreate) (*pb.S2CGraveyardBuildCreate, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
buildId := req.GetBuildId()
if buildId <= 0 {
return nil, errors.WrapTrace(common.ErrParamError)
}
if req.Position == nil {
return nil, errors.WrapTrace(common.ErrParamError)
}
position := coordinate.NewPositionFromVo(req.GetPosition())
vo, err := s.User.GraveyardBuildCreate(buildId, position)
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardBuildCreate{
Build: vo,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
// GraveyardRelocation 移动或者收到背包
func (s *Session) GraveyardRelocation(ctx context.Context, req *pb.C2SGraveyardRelocation) (*pb.S2CGraveyardRelocation, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
// uid和要移动到的position
relocationMap := map[int64]*coordinate.Position{}
// 参数检查
for _, relocation := range req.Relocations {
_, ok := relocationMap[relocation.BuildUid]
if ok {
return nil, errors.WrapTrace(common.ErrParamError)
}
if relocation.Position == nil {
relocationMap[relocation.BuildUid] = nil
} else {
position := coordinate.NewPositionFromVo(relocation.Position)
relocationMap[relocation.BuildUid] = position
}
}
if len(relocationMap) == 0 {
return nil, errors.WrapTrace(common.ErrParamError)
}
return s.User.GraveyardRelocation(relocationMap)
}
// GraveyardBuildLvUp 升级
func (s *Session) GraveyardBuildLvUp(ctx context.Context, req *pb.C2SGraveyardBuildLvUp) (*pb.S2CGraveyardBuildLvUp, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
vo, err := s.User.GraveyardBuildLvUp(req.BuildUid)
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardBuildLvUp{
Build: vo,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
// GraveyardBuildStageUp 升阶
func (s *Session) GraveyardBuildStageUp(ctx context.Context, req *pb.C2SGraveyardBuildStageUp) (*pb.S2CGraveyardBuildStageUp, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
vo, err := s.User.GraveyardBuildStageUp(req.BuildUid)
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardBuildStageUp{
Build: vo,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
// GraveyardOpenCurtain 建筑揭幕
func (s *Session) GraveyardOpenCurtain(ctx context.Context, req *pb.C2SGraveyardOpenCurtain) (*pb.S2CGraveyardOpenCurtain, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
vo, err := s.User.GraveyardOpenCurtain(req.BuildUid)
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardOpenCurtain{
Build: vo,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
//--------------------------产出相关
// GraveyardProduceStart 非持续性建筑开始产出
func (s *Session) GraveyardProduceStart(ctx context.Context, req *pb.C2SGraveyardProduceStart) (*pb.S2CGraveyardProduceStart, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
vos, err := s.User.GraveyardProduceStart(req.BuildUid, req.ProduceNum)
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardProduceStart{
Builds: vos,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
// GraveyardProductionGet 获得产出
func (s *Session) GraveyardProductionGet(ctx context.Context, req *pb.C2SGraveyardProductionGet) (*pb.S2CGraveyardProductionGet, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
voList, err := s.User.GraveyardProductionGet(req.BuildUidList)
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardProductionGet{
Builds: voList,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
// GraveyardRefreshBuildInfo 刷新产出，不收获
func (s *Session) GraveyardRefreshBuildInfo(ctx context.Context, req *pb.C2SGraveyardRefreshBuildInfo) (*pb.S2CGraveyardRefreshBuildInfo, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
voList, err := s.User.GraveyardRefreshBuildInfo(req.BuildUidList)
if err != nil {
return nil, err
}
return &pb.S2CGraveyardRefreshBuildInfo{
BuildInfoList: voList,
}, nil
}
// GraveyardCharacterDispatch 派遣侍从
func (s *Session) GraveyardCharacterDispatch(ctx context.Context, req *pb.C2SGraveyardCharacterDispatch) (*pb.S2CGraveyardCharacterDispatch, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
//参数检查
characterMap := map[int32]int32{}
for _, character := range req.Characters {
_, ok := characterMap[character.Position]
if ok {
return nil, errors.WrapTrace(common.ErrParamError)
}
characterMap[character.CharacterId] = character.Position
}
voList, err := s.User.GraveyardCharacterDispatch(req.BuildUid, common.NewCharacterPositions(characterMap))
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardCharacterDispatch{
Builds: voList,
}, nil
}
// GraveyardPopulationSet 设置人口
func (s *Session) GraveyardPopulationSet(ctx context.Context, req *pb.C2SGraveyardPopulationSet) (*pb.S2CGraveyardPopulationSet, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
//参数检查
populationMap := map[int64]int32{}
for _, population := range req.Populations {
if population.GetCurrPopulationCount() < 0 {
return nil, errors.WrapTrace(common.ErrParamError)
}
_, ok := populationMap[population.BuildUid]
if ok {
return nil, errors.WrapTrace(common.ErrParamError)
}
populationMap[population.BuildUid] = population.GetCurrPopulationCount()
}
if len(populationMap) == 0 {
return nil, errors.WrapTrace(common.ErrParamError)
}
voList, err := s.User.GraveyardPopulationSet(populationMap)
if err != nil {
return nil, err
}
return &pb.S2CGraveyardPopulationSet{
BuildInfos: voList,
}, nil
}
// GraveyardAccelerate 加速
func (s *Session) GraveyardAccelerate(ctx context.Context, req *pb.C2SGraveyardAccelerate) (*pb.S2CGraveyardAccelerate, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
// check param
if len(req.Consumes) == 0 {
return nil, common.ErrParamError
}
rewards, err := common.ParseFromVOConsume(req.Consumes)
if err != nil {
return nil, errors.WrapTrace(err)
}
// check consume
err = s.User.CheckRewardsEnough(rewards)
if err != nil {
return nil, errors.WrapTrace(err)
}
vo, err := s.User.GraveyardAccelerate(req.BuildUid, rewards)
return &pb.S2CGraveyardAccelerate{
VoBuild: vo,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
// GraveyardHelp 帮助他人减cd
func (s *Session) GraveyardHelp(ctx context.Context, req *pb.C2SGraveyardHelp) (*pb.S2CGraveyardHelp, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
err = s.GuildDataRefresh(ctx)
if err != nil {
return nil, errors.WrapTrace(err)
}
if s.Guild.GuildID == 0 {
return nil, errors.Swrapf(common.ErrGuildNotFound)
}
resp, err := s.RPCGuildHelpRequestsHandle(ctx)
if err != nil {
return nil, err
}
if resp.GetDailyAddGold() > s.User.Graveyard.DailyGuildGoldByHelp {
rewards := common.NewRewards()
rewards.AddReward(common.NewReward(static.CommonResourceTypeGuildMoney, resp.GetDailyAddGold()-s.User.Graveyard.DailyGuildGoldByHelp))
_, err = s.User.AddRewards(rewards, logreason.NewReason(logreason.GraveyardHelp))
if err != nil {
return nil, errors.WrapTrace(err)
}
}
s.User.Graveyard.DailyGuildGoldByHelp = resp.GetDailyAddGold()
s.User.Graveyard.DailyAddActivationByHelp = resp.GetDailyAddActivation()
s.User.Guild.AddTaskItem(static.GuildTaskHelp, 1)
return &pb.S2CGraveyardHelp{
HelpCount: resp.HelpCount,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
// GraveyardSendHelpRequest 请求减cd
func (s *Session) GraveyardSendHelpRequest(ctx context.Context, req *pb.C2SGraveyardSendHelpRequest) (*pb.S2CGraveyardSendHelpRequest, error) {
err := s.GuildDataRefresh(ctx)
if err != nil {
return nil, errors.WrapTrace(err)
}
if s.Guild.GuildID == 0 {
return nil, errors.Swrapf(common.ErrGuildNotFound)
}
// 检查模拟经营是否解锁
err = s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
build, err := s.Graveyard.FindByUid(req.GetBuildUid())
if err != nil {
return nil, errors.WrapTrace(err)
}
requestAdd, err := s.User.GenVOAddGraveyardRequest(req.GetBuildUid(), build)
if err != nil {
return nil, err
}
resp, err := s.RPCGuildAddGraveyardRequest(ctx, requestAdd)
if err != nil {
return nil, err
}
build.SetRequestId(resp.RequestUid)
s.Graveyard.SendRequestCount += 1
return &pb.S2CGraveyardSendHelpRequest{
Build: s.VOGraveyardBuild(req.BuildUid, build),
SendRequestCount: s.Graveyard.SendRequestCount,
}, nil
}
// GraveyardGetHelpRequests 获得请求帮助列表
func (s *Session) GraveyardGetHelpRequests(ctx context.Context, req *pb.C2SGraveyardGetHelpRequests) (*pb.S2CGraveyardGetHelpRequests, error) {
err := s.GuildDataRefresh(ctx)
if err != nil {
return nil, errors.WrapTrace(err)
}
if s.Guild.GuildID == 0 {
return nil, errors.Swrapf(common.ErrGuildNotFound)
}
resp, err := s.RPCGuildGetGraveyardRequests(ctx)
if err != nil {
return nil, err
}
return &pb.S2CGraveyardGetHelpRequests{
Requests: resp.Requests,
TodayHelpAddActivation: s.Graveyard.DailyAddActivationByHelp,
}, nil
}
// GraveyardReceivePlotReward 领取小人对话奖励
func (s *Session) GraveyardReceivePlotReward(ctx context.Context, req *pb.C2SGraveyardReceivePlotReward) (*pb.S2CGraveyardReceivePlotReward, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, err
}
rewardHours, err := s.User.GraveyardReceivePlotReward()
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardReceivePlotReward{
RewardHours: rewardHours,
ResourceResult: s.User.VOResourceResult(),
}, nil
}
func (s *Session) GraveyardGetRewardHours(ctx context.Context, req *pb.C2SGraveyardGetRewardHours) (*pb.S2CGraveyardGetRewardHours, error) {
//// 检查模拟经营是否解锁
//err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
//if err != nil {
// return nil, err
//}
return &pb.S2CGraveyardGetRewardHours{
RewardHours: s.User.GraveyardGetRewardHours(),
}, nil
}
func (s *Session) GraveyardUseBuff(ctx context.Context, req *pb.C2SGraveyardUseBuff) (*pb.S2CGraveyardUseBuff, error) {
// 检查模拟经营是否解锁
err := s.User.CheckActionUnlock(static.ActionIdTypeTycoonunlock)
if err != nil {
return nil, errors.WrapTrace(err)
}
vos, err := s.User.GraveyardUseBuff(req.ItemId, req.Amount)
if err != nil {
return nil, errors.WrapTrace(err)
}
return &pb.S2CGraveyardUseBuff{
ResourceResult: s.User.VOResourceResult(),
BuildInfoList: vos,
}, nil
}
|
// Copyright 2019 The Cockroach Authors.
//
// Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt.
//
// As of the Change Date specified in that file, in accordance with
// the Business Source License, use of this software will be governed
// by the Apache License, Version 2.0, included in the file
// licenses/APL.txt.
package acceptance
import (
"bytes"
"io"
"os"
"os/exec"
"path/filepath"
"testing"
)
func TestComposeGSS(t *testing.T) {
testCompose(t, filepath.Join("compose", "gss", "docker-compose.yml"), "psql")
}
func TestComposeGSSPython(t *testing.T) {
testCompose(t, filepath.Join("compose", "gss", "docker-compose-python.yml"), "python")
}
func TestComposeFlyway(t *testing.T) {
testCompose(t, filepath.Join("compose", "flyway", "docker-compose.yml"), "flyway")
}
func testCompose(t *testing.T, path string, exitCodeFrom string) {
cmd := exec.Command(
"docker-compose",
"--no-ansi",
"-f", path,
"up",
"--force-recreate",
"--build",
"--exit-code-from", exitCodeFrom,
)
var buf bytes.Buffer
if testing.Verbose() {
cmd.Stdout = io.MultiWriter(&buf, os.Stdout)
cmd.Stderr = io.MultiWriter(&buf, os.Stderr)
} else {
cmd.Stdout = &buf
cmd.Stderr = &buf
}
if err := cmd.Run(); err != nil {
t.Log(buf.String())
t.Fatal(err)
}
}
|
package types_test
import (
"testing"
"github.com/go-jstmpl/go-jstmpl/types"
hschema "github.com/lestrrat/go-jshschema"
schema "github.com/lestrrat/go-jsschema"
)
func TestNewRoot(t *testing.T) {
s, err := types.NewRoot(&hschema.HyperSchema{
Schema: &schema.Schema{
Title: "title",
Description: "description",
},
})
if err != nil {
t.Fatalf("fail to NewRoot with %s", err)
}
if s.Title() != "title" {
t.Fatalf("Title expected %s but actual %s", "title", s.Title())
}
if s.Description != "description" {
t.Fatalf("Description expected %s but actual %s", "description", s.Description)
}
}
|
package main
import (
"fmt"
"github.com/go-redis/redis"
)
func main(){
client := redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
sub := client.Subscribe("result")
fmt.Println(sub.Receive())
for msg := range sub.Channel(){
fmt.Println(msg.Payload)
}
}
|
/*
* @lc app=leetcode id=724 lang=golang
*
* [724] Find Pivot Index
*
* https://leetcode.com/problems/find-pivot-index/description/
*
* algorithms
* Easy (43.66%)
* Likes: 1063
* Dislikes: 240
* Total Accepted: 130.7K
* Total Submissions: 299.2K
* Testcase Example: '[1,7,3,6,5,6]'
*
* Given an array of integers nums, write a method that returns the "pivot"
* index of this array.
*
* We define the pivot index as the index where the sum of all the numbers to
* the left of the index is equal to the sum of all the numbers to the right of
* the index.
*
* If no such index exists, we should return -1. If there are multiple pivot
* indexes, you should return the left-most pivot index.
*
*
* Example 1:
*
*
* Input: nums = [1,7,3,6,5,6]
* Output: 3
* Explanation:
* The sum of the numbers to the left of index 3 (nums[3] = 6) is equal to the
* sum of numbers to the right of index 3.
* Also, 3 is the first index where this occurs.
*
*
* Example 2:
*
*
* Input: nums = [1,2,3]
* Output: -1
* Explanation:
* There is no index that satisfies the conditions in the problem
* statement.
*
*
*
* Constraints:
*
*
* The length of nums will be in the range [0, 10000].
* Each element nums[i] will be an integer in the range [-1000, 1000].
*
*
*/
// @lc code=start
func pivotIndex(nums []int) int {
return pivotIndex3(nums)
}
// solution by math sum, leftSum: leftSum = sum - leftSum - nums[i]
func pivotIndex3(nums []int) int {
sum := 0
for _, v := range nums {
sum += v
}
leftSum := 0
for i := 0; i < len(nums); i++ {
if leftSum == sum-leftSum-nums[i] {
return i
}
leftSum += nums[i]
}
return -1
}
func pivotIndex2(nums []int) int {
if len(nums) <= 2 {
return -1
}
sum := 0
for _, val := range nums {
sum += val
}
// handle special case: total sum minus first element, value is zero
// test case: [-1,-1,-1,0,1,1]
if sum-nums[0] == 0 {
return 0
}
leftSum := 0
for i := 0; i+2 < len(nums); i++ {
leftSum += nums[i]
midVal := nums[i+1]
if leftSum == (sum-midVal)/2 && (sum-midVal)%2 == 0 {
return i + 1
}
}
// handle special case: total sum minus last element, value is zero. this check step should put last, may be some other solution
// test case: [-1,-1,1,1,0,0]
if sum-nums[len(nums)-1] == 0 {
return len(nums) - 1
}
return -1
}
// 分别从两端开始遍历累加，这个方法有问题，如果数组中有负值，就有问题
func pivotIndex1(nums []int) int {
if len(nums) <= 2 {
return -1
}
leftSum := nums[0]
rightSum := nums[len(nums)-1]
for i, j := 0, len(nums)-1; i <= j; {
if leftSum == rightSum {
if i+2 == j {
return i + 1
} else {
i++
j--
leftSum += nums[i]
rightSum += nums[j]
}
} else if leftSum > rightSum {
j--
rightSum += nums[j]
} else {
i++
leftSum += nums[i]
}
}
return -1
}
// [-1,-1,-1,-1,-1,0]
// [-1,-1,-1,-1,-1,-1]
// [-1,-1,-1,0,1,1] --- 开头，结尾特殊案例
// [-1,-1,1,1,0,0] --- 去除最后一个为零，但是中间有其他方案，优先返回其他方案
// @lc code=end |
package main
import (
"fmt"
"log"
"net/http"
)
func main() {
fmt.Printf("Server started and listening to port 8080.\n")
router := NewRouter()
log.Fatal(http.ListenAndServe(":8080", router))
}
|
package models
type Node struct {
ID string `storm:"id"`
ConfigHash string
PayoutAddress string
Token string
Cooldown int
LastUsed int64
Active bool
}
|
package tempo
import (
"context"
"fmt"
"io"
"net/http"
"time"
"github.com/opentracing/opentracing-go"
ot_log "github.com/opentracing/opentracing-go/log"
"github.com/weaveworks/common/user"
"google.golang.org/grpc/metadata"
jaeger "github.com/jaegertracing/jaeger/model"
"github.com/jaegertracing/jaeger/storage/spanstore"
jaeger_spanstore "github.com/jaegertracing/jaeger/storage/spanstore"
ot_pdata "go.opentelemetry.io/collector/consumer/pdata"
ot_jaeger "go.opentelemetry.io/collector/translator/trace/jaeger"
)
const (
AcceptHeaderKey = "Accept"
ProtobufTypeHeaderValue = "application/protobuf"
)
type Backend struct {
tempoEndpoint string
}
func New(cfg *Config) *Backend {
return &Backend{
tempoEndpoint: "http://" + cfg.Backend + "/api/traces/",
}
}
func (b *Backend) GetDependencies(ctx context.Context, endTs time.Time, lookback time.Duration) ([]jaeger.DependencyLink, error) {
return nil, nil
}
func (b *Backend) GetTrace(ctx context.Context, traceID jaeger.TraceID) (*jaeger.Trace, error) {
hexID := fmt.Sprintf("%016x%016x", traceID.High, traceID.Low)
span, _ := opentracing.StartSpanFromContext(ctx, "GetTrace")
defer span.Finish()
req, err := http.NewRequestWithContext(ctx, "GET", b.tempoEndpoint+hexID, nil)
if err != nil {
return nil, err
}
if tracer := opentracing.GlobalTracer(); tracer != nil {
// this is not really loggable or anything we can react to. just ignoring this error
_ = tracer.Inject(span.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))
}
// currently Jaeger Query will only propagate bearer token to the grpc backend and no other headers
// so we are going to extract the tenant id from the header, if it exists and use it
tenantID, found := extractBearerToken(ctx)
if found {
req.Header.Set(user.OrgIDHeaderName, tenantID)
}
// Set content type to grpc
req.Header.Set(AcceptHeaderKey, ProtobufTypeHeaderValue)
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, fmt.Errorf("failed get to tempo %w", err)
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusNotFound {
return nil, jaeger_spanstore.ErrTraceNotFound
}
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("error reading response from tempo: %w", err)
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("%s", body)
}
otTrace := ot_pdata.NewTraces()
err = otTrace.FromOtlpProtoBytes(body)
if err != nil {
return nil, fmt.Errorf("Error converting tempo response to Otlp: %w", err)
}
jaegerBatches, err := ot_jaeger.InternalTracesToJaegerProto(otTrace)
if err != nil {
return nil, fmt.Errorf("error translating to jaegerBatches %v: %w", hexID, err)
}
jaegerTrace := &jaeger.Trace{
Spans: []*jaeger.Span{},
ProcessMap: []jaeger.Trace_ProcessMapping{},
}
span.LogFields(ot_log.String("msg", "build process map"))
// otel proto conversion doesn't set jaeger processes
for _, batch := range jaegerBatches {
for _, s := range batch.Spans {
s.Process = batch.Process
}
jaegerTrace.Spans = append(jaegerTrace.Spans, batch.Spans...)
jaegerTrace.ProcessMap = append(jaegerTrace.ProcessMap, jaeger.Trace_ProcessMapping{
Process: *batch.Process,
ProcessID: batch.Process.ServiceName,
})
}
return jaegerTrace, nil
}
func (b *Backend) GetServices(ctx context.Context) ([]string, error) {
return nil, nil
}
func (b *Backend) GetOperations(ctx context.Context, query jaeger_spanstore.OperationQueryParameters) ([]jaeger_spanstore.Operation, error) {
return nil, nil
}
func (b *Backend) FindTraces(ctx context.Context, query *jaeger_spanstore.TraceQueryParameters) ([]*jaeger.Trace, error) {
return nil, nil
}
func (b *Backend) FindTraceIDs(ctx context.Context, query *jaeger_spanstore.TraceQueryParameters) ([]jaeger.TraceID, error) {
return nil, nil
}
func (b *Backend) WriteSpan(ctx context.Context, span *jaeger.Span) error {
return nil
}
func extractBearerToken(ctx context.Context) (string, bool) {
if md, ok := metadata.FromIncomingContext(ctx); ok {
values := md.Get(spanstore.BearerTokenKey)
if len(values) > 0 {
return values[0], true
}
}
return "", false
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.