text stringlengths 11 4.05M |
|---|
package openstack
import (
"os"
"github.com/sirupsen/logrus"
"k8s.io/apimachinery/pkg/util/validation/field"
"github.com/openshift/installer/pkg/asset/installconfig/openstack/validation"
"github.com/openshift/installer/pkg/types"
"github.com/openshift/installer/pkg/types/openstack"
openstackdefaults "github.com/openshift/installer/pkg/types/openstack/defaults"
"github.com/openshift/installer/pkg/types/openstack/validation/networkextensions"
)
// Validate validates the given installconfig for OpenStack platform
func Validate(ic *types.InstallConfig) error {
if skip := os.Getenv("OPENSHIFT_INSTALL_SKIP_PREFLIGHT_VALIDATIONS"); skip == "1" {
logrus.Warnf("OVERRIDE: pre-flight validation disabled.")
return nil
}
ci, err := validation.GetCloudInfo(ic)
if err != nil {
return err
}
if ci == nil {
logrus.Warnf("Empty OpenStack cloud info and therefore will skip pre-flight validation.")
return nil
}
if err := ValidateCloud(ci); err != nil {
return err
}
allErrs := field.ErrorList{}
// Validate platform
allErrs = append(allErrs, validation.ValidatePlatform(ic.Platform.OpenStack, ic.Networking, ci)...)
// Validate control plane
controlPlane := defaultOpenStackMachinePoolPlatform()
controlPlane.Set(ic.Platform.OpenStack.DefaultMachinePlatform)
controlPlane.Set(ic.ControlPlane.Platform.OpenStack)
if controlPlane.RootVolume != nil && controlPlane.RootVolume.Zones == nil {
controlPlane.RootVolume.Zones = []string{openstackdefaults.DefaultRootVolumeAZ()}
}
allErrs = append(allErrs, validation.ValidateMachinePool(&controlPlane, ci, true, field.NewPath("controlPlane", "platform", "openstack"))...)
// Validate computes
for idx := range ic.Compute {
compute := defaultOpenStackMachinePoolPlatform()
compute.Set(ic.Platform.OpenStack.DefaultMachinePlatform)
compute.Set(ic.Compute[idx].Platform.OpenStack)
if compute.RootVolume != nil && compute.RootVolume.Zones == nil {
compute.RootVolume.Zones = []string{openstackdefaults.DefaultRootVolumeAZ()}
}
fldPath := field.NewPath("compute").Index(idx)
allErrs = append(allErrs, validation.ValidateMachinePool(&compute, ci, false, fldPath.Child("platform", "openstack"))...)
}
return allErrs.ToAggregate()
}
// ValidateForProvisioning validates that the install config is valid for provisioning the cluster.
func ValidateForProvisioning(ic *types.InstallConfig) error {
if ic.ControlPlane.Replicas != nil && *ic.ControlPlane.Replicas > 3 {
return field.Invalid(field.NewPath("controlPlane", "replicas"), ic.ControlPlane.Replicas, "control plane cannot be more than three nodes when provisioning on OpenStack")
}
return nil
}
func defaultOpenStackMachinePoolPlatform() openstack.MachinePool {
return openstack.MachinePool{
Zones: []string{""},
}
}
// ValidateCloud checks OpenStack requirements, regardless of the InstallConfig.
func ValidateCloud(ci *validation.CloudInfo) error {
return networkextensions.Validate(ci.NetworkExtensions)
}
|
package test
import (
"container/list"
"fmt"
"math/rand"
"time"
)
type Road struct {
name string //每条道路都有一个名字 S2N..
vechicles list.List //道路上的车辆集合
}
func (this *Road) Init(name string) {
this.name = name
//每隔一段时间道路上就添加一辆车
go func() {
rand.Seed(time.Now().UnixNano())
for i := 1; i < 1000; i++ {
sleepTime := (rand.Intn(10) + 1) * 1e6
time.Sleep(time.Duration(sleepTime))
this.vechicles.PushBack(name + "_" + fmt.Sprintf("%d", i))
}
}()
//每隔一秒去查看此道路的信号灯是否为绿 使用定时器
ticker := time.NewTicker(time.Second)
go func() {
for _ = range ticker.C {
if 0 < this.vechicles.Len() {
lighted := LampMap[name].lighted
if lighted {
first := this.vechicles.Front()
this.vechicles.Remove(first)
fmt.Println(first.Value.(string) + " is traversing !")
}
}
}
}()
}
|
/*
If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?
NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.
*/
package main
import (
"bytes"
"fmt"
"unicode"
)
func main() {
fmt.Println(solve(5))
fmt.Println(solve(1000))
}
func solve(n uint) int {
r := 0
for i := uint(1); i <= n; i++ {
r += chars(numeng(i))
}
return r
}
func chars(s string) int {
c := 0
for _, r := range s {
if unicode.IsSpace(r) || r == '-' {
continue
}
c += 1
}
return c
}
func numeng(n uint) string {
ones := []string{
"zero",
"one",
"two",
"three",
"four",
"five",
"six",
"seven",
"eight",
"nine",
"ten",
"eleven",
"twelve",
"thirteen",
"fourteen",
"fifteen",
"sixteen",
"seventeen",
"eighteen",
"nineteen",
}
tens := []string{
"twenty",
"thirty",
"forty",
"fifty",
"sixty",
"seventy",
"eighty",
"ninety",
}
if n > 1000 {
return "unsupported"
}
if n == 1000 {
return "one thousand"
}
s := fmt.Sprint(n)
m := len(s)
i := 0
o := false
w := new(bytes.Buffer)
for {
t := 0
r := m % 3
switch r {
case 0:
t += int(s[i]-'0') * 100
i += 1
fallthrough
case 2:
t += int(s[i]-'0') * 10
i += 1
fallthrough
case 1:
t += int(s[i] - '0')
i += 1
}
if t >= 100 {
fmt.Fprintf(w, "%s hundred", ones[t/100])
t %= 100
if t != 0 {
fmt.Fprintf(w, " and ")
}
}
if t >= 20 {
fmt.Fprintf(w, "%s", tens[t/10-2])
if t%10 != 0 {
fmt.Fprintf(w, " %s", ones[t%10])
}
} else if !(r == 0 && t == 0) || (!o && t != 0) {
fmt.Fprintf(w, "%s", ones[t])
}
if r == 0 {
m -= 3
} else {
m -= r
}
if m <= 0 {
break
}
o = true
}
return w.String()
}
|
package parser
import (
"bufio"
"bytes"
"encoding/base64"
"encoding/binary"
"github.com/limechain/hedera-state-proof-verifier-go/internal/constants"
"github.com/limechain/hedera-state-proof-verifier-go/internal/errors"
"github.com/limechain/hedera-state-proof-verifier-go/internal/types"
)
func ParseRecordFile(record string) (*types.RecordFile, error) {
bytesRf, err := base64.StdEncoding.DecodeString(record)
if err != nil {
return nil, err
}
bytesReader := bytes.NewReader(bytesRf)
reader := bufio.NewReader(bytesReader)
// record file format version
intBytes, err := reader.Peek(constants.IntSize)
if err != nil {
return nil, err
}
bytesReader.Reset(bytesRf)
version := binary.BigEndian.Uint32(intBytes)
var recordFile *types.RecordFile
switch version {
case constants.RecordFileFormatV1:
case constants.RecordFileFormatV2:
hash, err := types.CalculatePreV5FileHash(bytesReader, version)
if err != nil {
return nil, err
}
bytesReader.Reset(bytesRf)
recordFile, err = types.NewPreV5RecordFile(bytesReader)
if err != nil {
return nil, err
}
recordFile.Hash = hash
case constants.RecordFileFormatV5:
hash, err := types.CalculateV5FileHash(bytesReader)
if err != nil {
return nil, err
}
bytesReader.Reset(bytesRf)
recordFile, err = types.NewV5RecordFile(bytesReader)
if err != nil {
return nil, err
}
recordFile.Hash = hash
default:
return nil, errors.ErrorUnexpectedTypeDelimiter
}
return recordFile, nil
}
|
package main
import (
"os"
"image"
"image/png"
"image/color"
)
type Pixel struct {
R int
G int
B int
A int
}
func rgbaToPixel(r uint32, g uint32, b uint32, a uint32) Pixel {
return Pixel{ scale(r, 65535, 0, 255, 0),
scale(g, 65535, 0, 255, 0),
scale(b, 65535, 0, 255, 0),
scale(a, 65535, 0, 255, 0),
}
}
func scale(num uint32, max uint32, min uint32, newMax uint32, newMin uint32) int {
oldRange := max - min
newRange := newMax - newMin
return int((((num - min) * newRange) / oldRange) + newMin)
}
func imageToRGBA(i image.Image) [][]Pixel {
var imagePixels [][]Pixel
for r := 0 ; r < i.Bounds().Max.Y ; r++ {
var row []Pixel
for c := 0 ; c < i.Bounds().Max.X ; c++ {
a, b, c, d := i.At(c, r).RGBA()
row = append(row, rgbaToPixel(a,b,c,d))
}
imagePixels = append(imagePixels, row)
}
return imagePixels
}
func encodeMessage(s string) []byte {
newMessage := []byte{}
for _, b := range []byte(s) {
newMessage = append(newMessage, b >> 7 & 1)
newMessage = append(newMessage, b >> 6 & 1)
newMessage = append(newMessage, b >> 5 & 1)
newMessage = append(newMessage, b >> 4 & 1)
newMessage = append(newMessage, b >> 3 & 1)
newMessage = append(newMessage, b >> 2 & 1)
newMessage = append(newMessage, b >> 1 & 1)
newMessage = append(newMessage, b & 1)
}
return newMessage
}
func encodeImage(message []byte, i [][]Pixel) [][]Pixel {
index := 0
for a := 0 ; a < len(i) ; a++ {
for b := 0 ; b < len(i[a]) ; b++ {
if index >= len(message) { break }
i[a][b].R = encodePixel(i[a][b].R, message[index])
index++
if index >= len(message) { break }
i[a][b].G = encodePixel(i[a][b].G, message[index])
index++
if index >= len(message) { break }
i[a][b].B = encodePixel(i[a][b].B, message[index])
index++
}
}
return i
}
func encodePixel(colourValue int, LSB byte) int {
if LSB == 0 && colourValue % 2 == 1 {
return colourValue & (colourValue - 1)
} else if LSB == 1 && colourValue % 2 == 0 {
return (colourValue & (colourValue - 1)) + 1
} else {
return colourValue
}
}
func createImage(p [][]Pixel) {
//creates file in current directory
outputFile, err := os.Create("encodedPicture.png")
if err != nil {
panic(err)
}
//returns a new rgba image with the given dimensions
outputImage := image.NewRGBA(image.Rectangle{image.Point{0,0},image.Point{len(p[0]), len(p)}})
for y := 0 ; y < len(p) ; y++ {
for x := 0 ; x < len(p[y]) ; x++ {
outputImage.Set(x, y, color.RGBA{uint8(p[y][x].R),
uint8(p[y][x].G),
uint8(p[y][x].B),
uint8(p[y][x].A)})
}
}
png.Encode(outputFile, outputImage)
}
func main() {
file, err := os.Open("picture.png")
defer file.Close()
if err != nil {
panic(err)
}
ima, _, err := image.Decode(file)
if err != nil {
panic(err)
}
imagePixelsEncoded := encodeImage(encodeMessage("eric"), imageToRGBA(ima))
createImage(imagePixelsEncoded)
}
|
package main
import "fmt"
func main() {
//简单类型
var b byte
var i int
var ss string
fmt.Printf(" byte: %v \n int: %v \n string: %v \n", b, i, ss)
// 复杂类型
/*
Types which zero values can be represented with nil
The zero values of the following types can be represented with nil.
Type (T) Size Of T(nil)
pointer 1 word
slice 3 words
map 1 word
channel 1 word
function 1 word
interface 2 words
*/
var x []int
var s struct{}
var ifa interface{}
var c chan int
var m map[string]int
fmt.Println("[]int:", x)
fmt.Println("struct:", s)
fmt.Println("interface: ", ifa)
fmt.Println("chan int: ", c)
fmt.Println("map[string]int:", m)
}
|
/*****************************************************************
* Copyright©,2020-2022, email: 279197148@qq.com
* Version: 1.0.0
* @Author: yangtxiang
* @Date: 2020-08-03 10:33
* Description:
*****************************************************************/
package netstream
import (
"errors"
"github.com/go-xe2/x/core/logger"
"net"
)
// 网络流客户端
// 功能特点
// 1.与网络流服务端使用心跳方式保持长连接
// 2.具有心跳检查及断线重连功能
// 3.具有双向通讯功能
// 4.具有点对点发送功能
// 5.具有同步发送数据和异步发送数据功能
type StreamClient interface {
IsOpen() bool
Addr() net.Addr
RemoteAddr() net.Addr
Send(data []byte) (int, error)
Call(data []byte) (result []byte, err error)
SendTo(targetId string, data []byte) (int, error)
CallTo(targetId string, data []byte) (result []byte, err error)
Request(reqId string, namespace string, body []byte) error
Response(reqId string, body []byte) error
MakeRequestId() string
Id() string
Open() error
Close() error
OnReady(conn StreamConn)
SetHandler(handler ClientStreamHandler)
}
type StreamPoint interface {
ClientStreamHandler
Start(client StreamClient)
Stop()
}
type TStreamClient struct {
// 是否已经关闭
heartbeatIsRun int32
conn *tStreamConn
handler ClientStreamHandler
// 当前重试连接的次数
tryCount int
closed chan byte
options *TStmClientOptions
retryStatus int32
}
var _ StreamClient = (*TStreamClient)(nil)
var _ StreamConnHandler = (*TStreamClient)(nil)
func NewStreamClient(hostPort string, options *TStmClientOptions) (*TStreamClient, error) {
if options == nil {
options = DefaultStmClientOptions
}
addr, err := net.ResolveTCPAddr("tcp", hostPort)
if err != nil {
return nil, err
}
inst := &TStreamClient{
// 当前重试连接的次数
options: options,
tryCount: 0,
}
inst.conn = newStreamConn(inst, addr, options.TConnOptions)
return inst, nil
}
func (p *TStreamClient) SetHandler(handler ClientStreamHandler) {
p.handler = handler
}
func (p *TStreamClient) Id() string {
return p.conn.Id()
}
// 发送数据
func (p *TStreamClient) Send(data []byte) (int, error) {
if p.IsOpen() {
return p.conn.Send(data)
}
return 0, errors.New("未打开连接或已关闭连接")
}
func (p *TStreamClient) Call(data []byte) ([]byte, error) {
if !p.IsOpen() {
return nil, errors.New("连接未打开或已断开")
}
return p.conn.Call(data)
}
func (p *TStreamClient) SendTo(targetId string, data []byte) (int, error) {
if p.IsOpen() {
return p.conn.SendTo(targetId, data)
}
return 0, errors.New("未打开连接或已关闭连接")
}
func (p *TStreamClient) CallTo(targetId string, data []byte) ([]byte, error) {
if !p.IsOpen() {
return nil, errors.New("未打开连接或已关闭连接")
}
return p.conn.CallTo(targetId, data)
}
func (p *TStreamClient) Open() error {
if e := p.conn.Open(); e != nil {
return e
}
p.closed = make(chan byte, 1)
return nil
}
func (p *TStreamClient) Serve(point StreamPoint) error {
if point != nil {
p.handler = point
}
if !p.IsOpen() {
return errors.New("连接未打开，请先打开连接")
}
if point != nil {
point.Start(p)
}
select {
case <-p.closed:
}
if point != nil {
point.Stop()
}
return nil
}
// Retrieve the underlying net.Conn
func (p *TStreamClient) Conn() StreamConn {
return p.conn
}
// Returns true if the connection is open
func (p *TStreamClient) IsOpen() bool {
return p.conn.IsOpen()
}
func (p *TStreamClient) innerClose() {
if p.conn.IsOpen() {
p.conn.innerClose()
}
}
// Closes the socket.
func (p *TStreamClient) Close() error {
select {
case <-p.closed:
return nil
default:
}
if !p.IsOpen() {
return nil
}
close(p.closed)
return p.conn.Close()
}
func (p *TStreamClient) Addr() net.Addr {
return p.conn.addr
}
func (p *TStreamClient) RemoteAddr() net.Addr {
if p.conn == nil {
return nil
}
return p.conn.RemoteAddr()
}
func (p *TStreamClient) Log(level logger.LogLevel, args ...interface{}) {
Log("TStreamClient", p.options.GetLogger(), level, args...)
}
func (p *TStreamClient) Request(reqId string, namespace string, body []byte) error {
if p.IsOpen() {
return p.conn.Request(reqId, namespace, body)
}
return errors.New("客户端未连接")
}
func (p *TStreamClient) Response(reqId string, body []byte) error {
if p.IsOpen() {
return p.conn.Response(reqId, body)
}
return errors.New("客户端未连接")
}
func (p *TStreamClient) MakeRequestId() string {
return MakeRequestId()
}
|
package main
import (
"fmt"
"github.com/Horimotsu/PEGo/pe"
"time"
)
func main() {
fmt.Println("Project Euler Problem 012")
start := time.Now()
fmt.Println("The answer is ", pe.Solve012())
end := time.Now()
fmt.Printf("%f seconds\n", (end.Sub(start)).Seconds())
}
|
package main
import (
"encoding/json"
"errors"
"github.com/BurntSushi/toml"
"github.com/codegangsta/negroni"
"github.com/gorilla/mux"
"github.com/globalsign/mgo"
// "github.com/globalsign/mgo/bson"
// auth "github.com/nabeken/negroni-auth"
"io"
"log"
"net/http"
"os"
// "strconv"
"strings"
)
type DatabaseConfig struct {
Label string `json:"label"`
Database string `json:"-"`
ConnectionString string `json:"-"`
}
type Config struct {
DB []*DatabaseConfig
Port string
AuthUsername string
AuthPassword string
}
var appConfig *Config
func parseFile(file string) (*Config, error) {
conf := &Config{}
_, err := toml.DecodeFile(file, conf)
return conf, err
}
func getDatabase(req *http.Request) (*mgo.Session, *mgo.Database, error) {
vars := mux.Vars(req)
if db, ok := vars["db"]; ok {
for _, d := range appConfig.DB {
if d.Label == db {
sess, err := mgo.Dial(d.ConnectionString)
if err != nil {
return &mgo.Session{}, &mgo.Database{}, err
}
return sess, sess.DB(d.Database), nil
}
}
return &mgo.Session{}, &mgo.Database{}, errors.New("Could not find DB by name " + db)
}
return &mgo.Session{}, &mgo.Database{}, errors.New("Missing db parameter")
}
func getCollection(req *http.Request) (*mgo.Session, *mgo.Collection, error) {
vars := mux.Vars(req)
sess, db, err := getDatabase(req)
if err != nil {
return sess, &mgo.Collection{}, err
}
if colname, ok := vars["col"]; ok {
return sess, db.C(colname), nil
}
sess.Close()
return sess, &mgo.Collection{}, errors.New("Missing collection parameter")
}
func main() {
log.Println("booting")
args := os.Args
var conf *Config
var err error
// Need at least one (command is included)...
if len(args) == 1 {
log.Panic("Please specify toml config file")
}
if len(args) >= 2 && strings.HasSuffix(args[1], ".toml") {
log.Println("has toml arg")
conf, err = parseFile(args[1])
if err != nil {
log.Panic(err.Error())
}
}
// authenticator := auth.NewBasicAuthenticator("MongoAdmin", basicAuth)
appConfig = conf
router := mux.NewRouter()
router.HandleFunc("/databases", func(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Content-Type", "application/json")
marshaled, _ := json.Marshal(conf.DB)
io.WriteString(w, string(marshaled))
}).Methods("GET")
router.HandleFunc("/databases/{db}/collections", collections).Methods("GET")
router.HandleFunc("/databases/{db}/collections/{col}", insert).Methods("POST")
router.HandleFunc("/databases/{db}/collections/{col}/indexes", indexes).Methods("GET")
router.HandleFunc("/databases/{db}/collections/{col}/find", find).Methods("POST")
router.HandleFunc("/databases/{db}/collections/{col}/total", total).Methods("GET")
router.HandleFunc("/databases/{db}/collections/{col}/newIndex", addIndex).Methods("POST")
router.HandleFunc("/databases/{db}/collections/{col}/dropIndex", dropIndex).Methods("POST")
router.HandleFunc("/databases/{db}/collections/{col}/findById/{mongoId}", findById).Methods("GET")
router.HandleFunc("/databases/{db}/collections/{col}/update/{mongoId}", updateById).Methods("PUT", "POST")
router.HandleFunc("/databases/{db}/collections/{col}/delete/{mongoId}", deleteById).Methods("DELETE")
// http.Handle("/", router)
n := negroni.Classic()
// n.Use(negroni.HandlerFunc(auth.Basic(appConfig.AuthUsername, appConfig.AuthPassword)))
n.Use(negroni.NewStatic(http.Dir("public")))
n.UseHandler(router)
n.Run(":" + conf.Port)
// panic(http.ListenAndServe(":"+conf.Port, http.DefaultServeMux))
}
|
package main
import "github.com/gin-gonic/gin"
type User struct {
ID uint64
Name string
}
func main() {
users := []User{{ID: 123, Name: "正经按摩的"}, {ID: 456, Name: "不长进干嘛"}}
r := gin.Default()
r.GET("/users", func(c *gin.Context) {
c.JSON(200, users)
})
r.Run(":8090")
}
|
package commands
import (
"github.com/spf13/cobra"
"github.com/buildpacks/pack"
"github.com/buildpacks/pack/internal/config"
"github.com/buildpacks/pack/internal/style"
"github.com/buildpacks/pack/logging"
)
type BuildpackPullFlags struct {
BuildpackRegistry string
}
func BuildpackPull(logger logging.Logger, cfg config.Config, client PackClient) *cobra.Command {
var opts pack.PullBuildpackOptions
var flags BuildpackPullFlags
cmd := &cobra.Command{
Use: "pull <uri>",
Args: cobra.ExactArgs(1),
Short: prependExperimental("Pull the buildpack from a registry and store it locally"),
Example: "pack buildpack pull example/my-buildpack@1.0.0",
RunE: logError(logger, func(cmd *cobra.Command, args []string) error {
registry, err := config.GetRegistry(cfg, flags.BuildpackRegistry)
if err != nil {
return err
}
opts.URI = args[0]
opts.RegistryType = registry.Type
opts.RegistryURL = registry.URL
opts.RegistryName = registry.Name
if err := client.PullBuildpack(cmd.Context(), opts); err != nil {
return err
}
logger.Infof("Successfully pulled %s", style.Symbol(opts.URI))
return nil
}),
}
cmd.Flags().StringVarP(&flags.BuildpackRegistry, "buildpack-registry", "r", "", "Buildpack Registry name")
AddHelpFlag(cmd, "pull")
return cmd
}
|
package lexer
import "regexp"
func isSpace(str string) bool {
if str == "\n" || str == " " || str == "\t" {
return true
}
return false
}
func isDigit(str string) bool {
ok, _ := regexp.MatchString(`[0-9]+`, str)
return ok
}
func isWord(str string) bool {
ok, _ := regexp.MatchString(`[a-zA-Z]+`, str)
return ok
}
|
package main
import (
"net/http"
"net/http/cgi"
)
func CgiHandler(config map[string]string) http.Handler {
h := new(cgi.Handler)
h.Path = mustGet(config, "path")
h.Root = mustGet(config, "mount")
h.Dir = tryGet(config, "dir", "")
h.Args = getSlice(config, "args")
h.Env = getSlice(config, "env")
h.InheritEnv = getSlice(config, "inherit")
h.PathLocationHandler = http.DefaultServeMux
return h
}
|
package main
import "fmt"
//* Definition for a binary tree node.
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func constructMaximumBinaryTree(nums []int) *TreeNode {
if len(nums) == 0 {
return nil
}
left := 0
right := len(nums) - 1
return build(nums, left, right)
}
func build01(nums []int, left int, right int) *TreeNode {
if left > right {
return nil
}
var maxVal, index int
//maxVal = -10000
maxVal = nums[left]
index = left
fmt.Printf("maxvalue:%d ,left:%d\n", maxVal, left)
for i := left; i <= right; i++ {
if maxVal < nums[i] {
index = i
maxVal = nums[i]
}
}
root := &TreeNode{Val: maxVal}
root.Left = build(nums, left, index-1)
root.Right = build(nums, index+1, right)
return root
}
func build(nums []int, left int, right int) *TreeNode {
if left > right {
return nil
}
index := getMaxIndex(nums, left, right)
root := &TreeNode{Val: nums[index]}
root.Left = build(nums, left, index-1)
root.Right = build(nums, index+1, right)
return root
}
func getMaxIndex(nums []int, left int, right int) int {
maxIndex := left
for i := left; i <= right; i++ {
if nums[maxIndex] < nums[i] {
maxIndex = i
}
}
return maxIndex
}
func main() {
//var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
//make()
//nums := [3,2,1,6,0,5]
nums := [6]int{3, 2, 1, 6, 0, 5}
fmt.Println(nums)
}
|
package endpoints
import (
"context"
"encoding/json"
"fmt"
"net/http"
"github.com/go-kit/kit/endpoint"
kithttp "github.com/go-kit/kit/transport/http"
"github.com/google/uuid"
"github.com/sumelms/microservice-course/internal/matrix/domain"
"github.com/sumelms/microservice-course/pkg/validator"
)
type removeSubjectRequest struct {
MatrixID uuid.UUID `json:"matrix_id" validate:"required"`
SubjectID uuid.UUID `json:"subject_id" validate:"required"`
}
type removeSubjectResponse struct{}
func NewRemoveSubjectHandler(s domain.ServiceInterface, opts ...kithttp.ServerOption) *kithttp.Server {
return kithttp.NewServer(
makeRemoveSubjectEndpoint(s),
decodeRemoveSubjectRequest,
encodeRemoveSubjectResponse,
opts...,
)
}
func makeRemoveSubjectEndpoint(s domain.ServiceInterface) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (interface{}, error) {
req, ok := request.(removeSubjectRequest)
if !ok {
return nil, fmt.Errorf("invalid argument")
}
v := validator.NewValidator()
if err := v.Validate(req); err != nil {
return nil, err
}
if err := s.RemoveSubject(ctx, req.MatrixID, req.SubjectID); err != nil {
return nil, err
}
return removeSubjectResponse{}, nil
}
}
func decodeRemoveSubjectRequest(_ context.Context, r *http.Request) (interface{}, error) {
var req removeSubjectRequest
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
return nil, err
}
return req, nil
}
func encodeRemoveSubjectResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
return kithttp.EncodeJSONResponse(ctx, w, response)
}
|
package tfrecord
import (
"bytes"
"os"
"testing"
)
func TestIO(t *testing.T) {
records := []string{"Hello", "World!"}
buf := &bytes.Buffer{}
w := NewWriter(buf)
for _, r := range records {
n, err := w.Write([]byte(r))
if err != nil {
t.Errorf("failed wrting %s, %v", r, err)
}
if n != len(r) {
t.Errorf("expect write size %d, actual %d", len(r), n)
}
}
it := NewIterator(bytes.NewReader(buf.Bytes()), 1000, true)
var read []string
for it.Next() {
read = append(read, string(it.Value()))
}
if err := it.Err(); err != nil {
t.Fatalf("read error %v", err)
}
if len(records) != len(read) {
t.Fatalf("unmatched read len, expect %d, actual %d", len(records), len(read))
}
for i, v := range records {
if v != read[i] {
t.Errorf("unmatched read value idx %d, expect %s, actual %s", i, v, read[i])
}
}
}
func TestReadFromTF(t *testing.T) {
r, err := os.Open("testdata/test.tfrecord")
if err != nil {
t.Fatalf("failed opening test file %v", err)
}
defer r.Close()
out := ""
it := NewIterator(r, 1000, true)
for it.Next() {
out += string(it.Value())
}
if err := it.Err(); err != nil {
t.Fatalf("read error %v", err)
}
expect := "HelloWorldFromTensorflow"
if out != expect {
t.Errorf("unmatched read content, expect %s, acutal %s", expect, out)
}
}
|
package bukaaplikasi
import (
"context"
"github.com/mirzaakhena/danarisan/application/apperror"
"github.com/mirzaakhena/danarisan/domain/service"
"github.com/mirzaakhena/danarisan/usecase/bukaaplikasi/port"
)
//go:generate mockery --dir port/ --name BukaAplikasiOutport -output mocks/
type bukaAplikasiInteractor struct {
outport port.BukaAplikasiOutport
}
// NewUsecase ...
func NewUsecase(outputPort port.BukaAplikasiOutport) port.BukaAplikasiInport {
return &bukaAplikasiInteractor{
outport: outputPort,
}
}
// Execute ...
func (r *bukaAplikasiInteractor) Execute(ctx context.Context, req port.BukaAplikasiRequest) (*port.BukaAplikasiResponse, error) {
res := &port.BukaAplikasiResponse{}
err := service.ReadOnly(ctx, r.outport, func(ctx context.Context) error {
pesertaObj, err := r.outport.FindOnePeserta(ctx, req.PesertaID)
if err != nil {
return err
}
if pesertaObj == nil {
return apperror.PesertaTidakDitemukan
}
res.User = pesertaObj
arisanObj, err := r.outport.FindOneArisan(ctx, pesertaObj.ArisanID.String())
if err != nil {
return nil
}
if arisanObj == nil {
return nil
}
listPeserta, err := r.outport.FindAllPeserta(ctx, arisanObj.ID.String())
if err != nil {
return err
}
arisanObj.ListPeserta = listPeserta
listSlot, err := r.outport.FindAllSlot(ctx, arisanObj.ID.String())
if err != nil {
return err
}
arisanObj.ListSlot = listSlot
listUndian, err := r.outport.FindAllUndian(ctx, arisanObj.ID.String())
if err != nil {
return err
}
arisanObj.ListUndian = listUndian
listTagihan, err := r.outport.FindAllTagihanByArisanID(ctx, arisanObj.ID.String())
if err != nil {
return err
}
arisanObj.ListTagihan = listTagihan
listJurnal, err := r.outport.FindAllJurnal(ctx, arisanObj.ID.String())
if err != nil {
return err
}
arisanObj.ListJurnal = listJurnal
listSaldoAkun, err := r.outport.FindAllSaldoAkun(ctx, arisanObj.ID.String())
if err != nil {
return err
}
arisanObj.ListSaldoAkun = listSaldoAkun
res.Arisan = arisanObj
return nil
})
if err != nil {
return nil, err
}
return res, nil
}
|
package v29
import (
"net"
"github.com/giantswarm/apiextensions/pkg/clientset/versioned"
"github.com/giantswarm/micrologger"
"k8s.io/client-go/kubernetes"
"sigs.k8s.io/cluster-api/pkg/client/clientset_generated/clientset"
"github.com/giantswarm/aws-operator/client/aws"
"github.com/giantswarm/aws-operator/service/locker"
)
type MachineDeploymentResourceSetConfig struct {
CMAClient clientset.Interface
ControlPlaneAWSClients aws.Clients
G8sClient versioned.Interface
K8sClient kubernetes.Interface
Locker locker.Interface
Logger micrologger.Logger
EncrypterBackend string
GuestPrivateSubnetMaskBits int
GuestPublicSubnetMaskBits int
GuestSubnetMaskBits int
HostAWSConfig aws.Config
InstallationName string
IPAMNetworkRange net.IPNet
ProjectName string
Route53Enabled bool
RouteTables string
VaultAddress string
VPCPeerID string
}
func (c MachineDeploymentResourceSetConfig) GetEncrypterBackend() string {
return c.EncrypterBackend
}
func (c MachineDeploymentResourceSetConfig) GetInstallationName() string {
return c.InstallationName
}
func (c MachineDeploymentResourceSetConfig) GetLogger() micrologger.Logger {
return c.Logger
}
func (c MachineDeploymentResourceSetConfig) GetVaultAddress() string {
return c.VaultAddress
}
|
package control
import (
"encoding/json"
"errors"
"log"
"os"
"strconv"
"strings"
"sync"
"time"
"gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
//"github.com/go-redis/redis"
)
type Control struct {
ranList []string //nodeB list
eventCreateExpired int32 //maximum time for the RIC Subscription Request event creation procedure in the E2 Node
eventDeleteExpired int32 //maximum time for the RIC Subscription Request event deletion procedure in the E2 Node
rcChan chan *xapp.RMRParams //channel for receiving rmr message
//client *redis.Client //redis client
eventCreateExpiredMap map[string]bool //map for recording the RIC Subscription Request event creation procedure is expired or not
eventDeleteExpiredMap map[string]bool //map for recording the RIC Subscription Request event deletion procedure is expired or not
eventCreateExpiredMu *sync.Mutex //mutex for eventCreateExpiredMap
eventDeleteExpiredMu *sync.Mutex //mutex for eventDeleteExpiredMap
sdl *sdlgo.SdlInstance
}
func init() {
file := "/opt/kpimon.log"
logFile, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)
if err != nil {
panic(err)
}
log.SetOutput(logFile)
log.SetPrefix("[qSkipTool]")
log.SetFlags(log.LstdFlags | log.Lshortfile | log.LUTC)
xapp.Logger.SetLevel(4)
}
func NewControl() Control {
str := os.Getenv("ranList")
return Control{strings.Split(str, ","),
5, 5,
make(chan *xapp.RMRParams),
//redis.NewClient(&redis.Options{
// Addr: os.Getenv("DBAAS_SERVICE_HOST") + ":" + os.Getenv("DBAAS_SERVICE_PORT"), //"localhost:6379"
// Password: "",
// DB: 0,
//}),
make(map[string]bool),
make(map[string]bool),
&sync.Mutex{},
&sync.Mutex{},
sdlgo.NewSdlInstance("kpimon", sdlgo.NewDatabase())}
}
func ReadyCB(i interface{}) {
c := i.(*Control)
c.startTimerSubReq()
go c.controlLoop()
}
func (c *Control) Run() {
//_, err := c.client.Ping().Result()
//if err != nil {
// xapp.Logger.Error("Failed to connect to Redis DB with %v", err)
// log.Printf("Failed to connect to Redis DB with %v", err)
//}
if len(c.ranList) > 0 {
xapp.SetReadyCB(ReadyCB, c)
xapp.Run(c)
} else {
xapp.Logger.Error("gNodeB not set for subscription")
log.Printf("gNodeB not set for subscription")
}
}
func (c *Control) startTimerSubReq() {
timerSR := time.NewTimer(5 * time.Second)
count := 0
go func(t *time.Timer) {
defer timerSR.Stop()
for {
<-t.C
count++
xapp.Logger.Debug("send RIC_SUB_REQ to gNodeB with cnt=%d", count)
log.Printf("send RIC_SUB_REQ to gNodeB with cnt=%d", count)
err := c.sendRicSubRequest(1001, 1001, 0)
if err != nil && count < MAX_SUBSCRIPTION_ATTEMPTS {
t.Reset(5 * time.Second)
} else {
break
}
}
}(timerSR)
}
func (c *Control) Consume(rp *xapp.RMRParams) (err error) {
c.rcChan <- rp
return
}
func (c *Control) rmrSend(params *xapp.RMRParams) (err error) {
if !xapp.Rmr.Send(params, false) {
err = errors.New("rmr.Send() failed")
xapp.Logger.Error("Failed to rmrSend to %v", err)
log.Printf("Failed to rmrSend to %v", err)
}
return
}
func (c *Control) rmrReplyToSender(params *xapp.RMRParams) (err error) {
if !xapp.Rmr.Send(params, true) {
err = errors.New("rmr.Send() failed")
xapp.Logger.Error("Failed to rmrReplyToSender to %v", err)
log.Printf("Failed to rmrReplyToSender to %v", err)
}
return
}
func (c *Control) controlLoop() {
for {
msg := <-c.rcChan
xapp.Logger.Debug("Received message type: %d", msg.Mtype)
log.Printf("Received message type: %d", msg.Mtype)
switch msg.Mtype {
case 12050:
c.handleIndication(msg)
case 12011:
c.handleSubscriptionResponse(msg)
case 12012:
c.handleSubscriptionFailure(msg)
case 12021:
c.handleSubscriptionDeleteResponse(msg)
case 12022:
c.handleSubscriptionDeleteFailure(msg)
default:
err := errors.New("Message Type " + strconv.Itoa(msg.Mtype) + " is discarded")
xapp.Logger.Error("Unknown message type: %v", err)
log.Printf("Unknown message type: %v", err)
}
}
}
func (c *Control) handleIndication(params *xapp.RMRParams) (err error) {
var e2ap *E2ap
var e2sm *E2sm
indicationMsg, err := e2ap.GetIndicationMessage(params.Payload)
if err != nil {
xapp.Logger.Error("Failed to decode RIC Indication message: %v", err)
log.Printf("Failed to decode RIC Indication message: %v", err)
return
}
log.Printf("RIC Indication message from {%s} received", params.Meid.RanName)
log.Printf("RequestID: %d", indicationMsg.RequestID)
log.Printf("RequestSequenceNumber: %d", indicationMsg.RequestSequenceNumber)
log.Printf("FunctionID: %d", indicationMsg.FuncID)
log.Printf("ActionID: %d", indicationMsg.ActionID)
log.Printf("IndicationSN: %d", indicationMsg.IndSN)
log.Printf("IndicationType: %d", indicationMsg.IndType)
log.Printf("IndicationHeader: %x", indicationMsg.IndHeader)
log.Printf("IndicationMessage: %x", indicationMsg.IndMessage)
log.Printf("CallProcessID: %x", indicationMsg.CallProcessID)
indicationHdr, err := e2sm.GetIndicationHeader(indicationMsg.IndHeader)
if err != nil {
xapp.Logger.Error("Failed to decode RIC Indication Header: %v", err)
log.Printf("Failed to decode RIC Indication Header: %v", err)
return
}
var cellIDHdr string
var plmnIDHdr string
var sliceIDHdr int32
var fiveQIHdr int64
log.Printf("-----------RIC Indication Header-----------")
if indicationHdr.IndHdrType == 1 {
log.Printf("RIC Indication Header Format: %d", indicationHdr.IndHdrType)
indHdrFormat1 := indicationHdr.IndHdr.(*IndicationHeaderFormat1)
log.Printf("GlobalKPMnodeIDType: %d", indHdrFormat1.GlobalKPMnodeIDType)
if indHdrFormat1.GlobalKPMnodeIDType == 1 {
globalKPMnodegNBID := indHdrFormat1.GlobalKPMnodeID.(*GlobalKPMnodegNBIDType)
globalgNBID := globalKPMnodegNBID.GlobalgNBID
log.Printf("PlmnID: %x", globalgNBID.PlmnID.Buf)
log.Printf("gNB ID Type: %d", globalgNBID.GnbIDType)
if globalgNBID.GnbIDType == 1 {
gNBID := globalgNBID.GnbID.(*GNBID)
log.Printf("gNB ID ID: %x, Unused: %d", gNBID.Buf, gNBID.BitsUnused)
}
if globalKPMnodegNBID.GnbCUUPID != nil {
log.Printf("gNB-CU-UP ID: %x", globalKPMnodegNBID.GnbCUUPID.Buf)
}
if globalKPMnodegNBID.GnbDUID != nil {
log.Printf("gNB-DU ID: %x", globalKPMnodegNBID.GnbDUID.Buf)
}
} else if indHdrFormat1.GlobalKPMnodeIDType == 2 {
globalKPMnodeengNBID := indHdrFormat1.GlobalKPMnodeID.(*GlobalKPMnodeengNBIDType)
log.Printf("PlmnID: %x", globalKPMnodeengNBID.PlmnID.Buf)
log.Printf("en-gNB ID Type: %d", globalKPMnodeengNBID.GnbIDType)
if globalKPMnodeengNBID.GnbIDType == 1 {
engNBID := globalKPMnodeengNBID.GnbID.(*ENGNBID)
log.Printf("en-gNB ID ID: %x, Unused: %d", engNBID.Buf, engNBID.BitsUnused)
}
} else if indHdrFormat1.GlobalKPMnodeIDType == 3 {
globalKPMnodengeNBID := indHdrFormat1.GlobalKPMnodeID.(*GlobalKPMnodengeNBIDType)
log.Printf("PlmnID: %x", globalKPMnodengeNBID.PlmnID.Buf)
log.Printf("ng-eNB ID Type: %d", globalKPMnodengeNBID.EnbIDType)
if globalKPMnodengeNBID.EnbIDType == 1 {
ngeNBID := globalKPMnodengeNBID.EnbID.(*NGENBID_Macro)
log.Printf("ng-eNB ID ID: %x, Unused: %d", ngeNBID.Buf, ngeNBID.BitsUnused)
} else if globalKPMnodengeNBID.EnbIDType == 2 {
ngeNBID := globalKPMnodengeNBID.EnbID.(*NGENBID_ShortMacro)
log.Printf("ng-eNB ID ID: %x, Unused: %d", ngeNBID.Buf, ngeNBID.BitsUnused)
} else if globalKPMnodengeNBID.EnbIDType == 3 {
ngeNBID := globalKPMnodengeNBID.EnbID.(*NGENBID_LongMacro)
log.Printf("ng-eNB ID ID: %x, Unused: %d", ngeNBID.Buf, ngeNBID.BitsUnused)
}
} else if indHdrFormat1.GlobalKPMnodeIDType == 4 {
globalKPMnodeeNBID := indHdrFormat1.GlobalKPMnodeID.(*GlobalKPMnodeeNBIDType)
log.Printf("PlmnID: %x", globalKPMnodeeNBID.PlmnID.Buf)
log.Printf("eNB ID Type: %d", globalKPMnodeeNBID.EnbIDType)
if globalKPMnodeeNBID.EnbIDType == 1 {
eNBID := globalKPMnodeeNBID.EnbID.(*ENBID_Macro)
log.Printf("eNB ID ID: %x, Unused: %d", eNBID.Buf, eNBID.BitsUnused)
} else if globalKPMnodeeNBID.EnbIDType == 2 {
eNBID := globalKPMnodeeNBID.EnbID.(*ENBID_Home)
log.Printf("eNB ID ID: %x, Unused: %d", eNBID.Buf, eNBID.BitsUnused)
} else if globalKPMnodeeNBID.EnbIDType == 3 {
eNBID := globalKPMnodeeNBID.EnbID.(*ENBID_ShortMacro)
log.Printf("eNB ID ID: %x, Unused: %d", eNBID.Buf, eNBID.BitsUnused)
} else if globalKPMnodeeNBID.EnbIDType == 4 {
eNBID := globalKPMnodeeNBID.EnbID.(*ENBID_LongMacro)
log.Printf("eNB ID ID: %x, Unused: %d", eNBID.Buf, eNBID.BitsUnused)
}
}
if indHdrFormat1.NRCGI != nil {
log.Printf("nRCGI.PlmnID: %x", indHdrFormat1.NRCGI.PlmnID.Buf)
log.Printf("nRCGI.NRCellID ID: %x, Unused: %d", indHdrFormat1.NRCGI.NRCellID.Buf, indHdrFormat1.NRCGI.NRCellID.BitsUnused)
cellIDHdr, err = e2sm.ParseNRCGI(*indHdrFormat1.NRCGI)
if err != nil {
xapp.Logger.Error("Failed to parse NRCGI in RIC Indication Header: %v", err)
log.Printf("Failed to parse NRCGI in RIC Indication Header: %v", err)
return
}
} else {
cellIDHdr = ""
}
if indHdrFormat1.PlmnID != nil {
log.Printf("PlmnID: %x", indHdrFormat1.PlmnID.Buf)
plmnIDHdr, err = e2sm.ParsePLMNIdentity(indHdrFormat1.PlmnID.Buf, indHdrFormat1.PlmnID.Size)
if err != nil {
xapp.Logger.Error("Failed to parse PlmnID in RIC Indication Header: %v", err)
log.Printf("Failed to parse PlmnID in RIC Indication Header: %v", err)
return
}
} else {
plmnIDHdr = ""
}
if indHdrFormat1.SliceID != nil {
log.Printf("SST: %x", indHdrFormat1.SliceID.SST.Buf)
if indHdrFormat1.SliceID.SD != nil {
log.Printf("SD: %x", indHdrFormat1.SliceID.SD.Buf)
}
sliceIDHdr, err = e2sm.ParseSliceID(*indHdrFormat1.SliceID)
if err != nil {
xapp.Logger.Error("Failed to parse SliceID in RIC Indication Header: %v", err)
log.Printf("Failed to parse SliceID in RIC Indication Header: %v", err)
return
}
} else {
sliceIDHdr = -1
}
if indHdrFormat1.FiveQI != -1 {
log.Printf("5QI: %d", indHdrFormat1.FiveQI)
}
fiveQIHdr = indHdrFormat1.FiveQI
if indHdrFormat1.Qci != -1 {
log.Printf("QCI: %d", indHdrFormat1.Qci)
}
if indHdrFormat1.UeMessageType != -1 {
log.Printf("Ue Report type: %d", indHdrFormat1.UeMessageType)
}
if indHdrFormat1.GnbDUID != nil {
log.Printf("gNB-DU-ID: %x", indHdrFormat1.GnbDUID.Buf)
}
if indHdrFormat1.GnbNameType == 1 {
log.Printf("gNB-DU-Name: %x", (indHdrFormat1.GnbName.(*GNB_DU_Name)).Buf)
} else if indHdrFormat1.GnbNameType == 2 {
log.Printf("gNB-CU-CP-Name: %x", (indHdrFormat1.GnbName.(*GNB_CU_CP_Name)).Buf)
} else if indHdrFormat1.GnbNameType == 3 {
log.Printf("gNB-CU-UP-Name: %x", (indHdrFormat1.GnbName.(*GNB_CU_UP_Name)).Buf)
}
if indHdrFormat1.GlobalgNBID != nil {
log.Printf("PlmnID: %x", indHdrFormat1.GlobalgNBID.PlmnID.Buf)
log.Printf("gNB ID Type: %d", indHdrFormat1.GlobalgNBID.GnbIDType)
if indHdrFormat1.GlobalgNBID.GnbIDType == 1 {
gNBID := indHdrFormat1.GlobalgNBID.GnbID.(*GNBID)
log.Printf("gNB ID ID: %x, Unused: %d", gNBID.Buf, gNBID.BitsUnused)
}
}
} else {
xapp.Logger.Error("Unknown RIC Indication Header Format: %d", indicationHdr.IndHdrType)
log.Printf("Unknown RIC Indication Header Format: %d", indicationHdr.IndHdrType)
return
}
indMsg, err := e2sm.GetIndicationMessage(indicationMsg.IndMessage)
if err != nil {
xapp.Logger.Error("Failed to decode RIC Indication Message: %v", err)
log.Printf("Failed to decode RIC Indication Message: %v", err)
return
}
var flag bool
var containerType int32
var timestampPDCPBytes *Timestamp
var dlPDCPBytes int64
var ulPDCPBytes int64
var timestampPRB *Timestamp
var availPRBDL int64
var availPRBUL int64
log.Printf("-----------RIC Indication Message-----------")
log.Printf("StyleType: %d", indMsg.StyleType)
if indMsg.IndMsgType == 1 {
log.Printf("RIC Indication Message Format: %d", indMsg.IndMsgType)
indMsgFormat1 := indMsg.IndMsg.(*IndicationMessageFormat1)
log.Printf("PMContainerCount: %d", indMsgFormat1.PMContainerCount)
for i := 0; i < indMsgFormat1.PMContainerCount; i++ {
flag = false
timestampPDCPBytes = nil
dlPDCPBytes = -1
ulPDCPBytes = -1
timestampPRB = nil
availPRBDL = -1
availPRBUL = -1
log.Printf("PMContainer[%d]: ", i)
pmContainer := indMsgFormat1.PMContainers[i]
if pmContainer.PFContainer != nil {
containerType = pmContainer.PFContainer.ContainerType
log.Printf("PFContainerType: %d", containerType)
if containerType == 1 {
log.Printf("oDU PF Container: ")
oDU := pmContainer.PFContainer.Container.(*ODUPFContainerType)
cellResourceReportCount := oDU.CellResourceReportCount
log.Printf("CellResourceReportCount: %d", cellResourceReportCount)
for j := 0; j < cellResourceReportCount; j++ {
log.Printf("CellResourceReport[%d]: ", j)
cellResourceReport := oDU.CellResourceReports[j]
log.Printf("nRCGI.PlmnID: %x", cellResourceReport.NRCGI.PlmnID.Buf)
log.Printf("nRCGI.nRCellID: %x", cellResourceReport.NRCGI.NRCellID.Buf)
cellID, err := e2sm.ParseNRCGI(cellResourceReport.NRCGI)
if err != nil {
xapp.Logger.Error("Failed to parse CellID in DU PF Container: %v", err)
log.Printf("Failed to parse CellID in DU PF Container: %v", err)
continue
}
if cellID == cellIDHdr {
flag = true
}
log.Printf("TotalofAvailablePRBsDL: %d", cellResourceReport.TotalofAvailablePRBs.DL)
log.Printf("TotalofAvailablePRBsUL: %d", cellResourceReport.TotalofAvailablePRBs.UL)
if flag {
availPRBDL = cellResourceReport.TotalofAvailablePRBs.DL
availPRBUL = cellResourceReport.TotalofAvailablePRBs.UL
}
servedPlmnPerCellCount := cellResourceReport.ServedPlmnPerCellCount
log.Printf("ServedPlmnPerCellCount: %d", servedPlmnPerCellCount)
for k := 0; k < servedPlmnPerCellCount; k++ {
log.Printf("ServedPlmnPerCell[%d]: ", k)
servedPlmnPerCell := cellResourceReport.ServedPlmnPerCells[k]
log.Printf("PlmnID: %x", servedPlmnPerCell.PlmnID.Buf)
if servedPlmnPerCell.DUPM5GC != nil {
slicePerPlmnPerCellCount := servedPlmnPerCell.DUPM5GC.SlicePerPlmnPerCellCount
log.Printf("SlicePerPlmnPerCellCount: %d", slicePerPlmnPerCellCount)
for l := 0; l < slicePerPlmnPerCellCount; l++ {
log.Printf("SlicePerPlmnPerCell[%d]: ", l)
slicePerPlmnPerCell := servedPlmnPerCell.DUPM5GC.SlicePerPlmnPerCells[l]
log.Printf("SliceID.sST: %x", slicePerPlmnPerCell.SliceID.SST.Buf)
if slicePerPlmnPerCell.SliceID.SD != nil {
log.Printf("SliceID.sD: %x", slicePerPlmnPerCell.SliceID.SD.Buf)
}
fQIPERSlicesPerPlmnPerCellCount := slicePerPlmnPerCell.FQIPERSlicesPerPlmnPerCellCount
log.Printf("5QIPerSlicesPerPlmnPerCellCount: %d", fQIPERSlicesPerPlmnPerCellCount)
for m := 0; m < fQIPERSlicesPerPlmnPerCellCount; m++ {
log.Printf("5QIPerSlicesPerPlmnPerCell[%d]: ", m)
fQIPERSlicesPerPlmnPerCell := slicePerPlmnPerCell.FQIPERSlicesPerPlmnPerCells[m]
log.Printf("5QI: %d", fQIPERSlicesPerPlmnPerCell.FiveQI)
log.Printf("PrbUsageDL: %d", fQIPERSlicesPerPlmnPerCell.PrbUsage.DL)
log.Printf("PrbUsageUL: %d", fQIPERSlicesPerPlmnPerCell.PrbUsage.UL)
}
}
}
if servedPlmnPerCell.DUPMEPC != nil {
perQCIReportCount := servedPlmnPerCell.DUPMEPC.PerQCIReportCount
log.Printf("PerQCIReportCount: %d", perQCIReportCount)
for l := 0; l < perQCIReportCount; l++ {
log.Printf("PerQCIReports[%d]: ", l)
perQCIReport := servedPlmnPerCell.DUPMEPC.PerQCIReports[l]
log.Printf("QCI: %d", perQCIReport.QCI)
log.Printf("PrbUsageDL: %d", perQCIReport.PrbUsage.DL)
log.Printf("PrbUsageUL: %d", perQCIReport.PrbUsage.UL)
}
}
}
}
} else if containerType == 2 {
log.Printf("oCU-CP PF Container: ")
oCUCP := pmContainer.PFContainer.Container.(*OCUCPPFContainerType)
if oCUCP.GNBCUCPName != nil {
log.Printf("gNB-CU-CP Name: %x", oCUCP.GNBCUCPName.Buf)
}
log.Printf("NumberOfActiveUEs: %d", oCUCP.CUCPResourceStatus.NumberOfActiveUEs)
} else if containerType == 3 {
log.Printf("oCU-UP PF Container: ")
oCUUP := pmContainer.PFContainer.Container.(*OCUUPPFContainerType)
if oCUUP.GNBCUUPName != nil {
log.Printf("gNB-CU-UP Name: %x", oCUUP.GNBCUUPName.Buf)
}
cuUPPFContainerItemCount := oCUUP.CUUPPFContainerItemCount
log.Printf("CU-UP PF Container Item Count: %d", cuUPPFContainerItemCount)
for j := 0; j < cuUPPFContainerItemCount; j++ {
log.Printf("CU-UP PF Container Item [%d]: ", j)
cuUPPFContainerItem := oCUUP.CUUPPFContainerItems[j]
log.Printf("InterfaceType: %d", cuUPPFContainerItem.InterfaceType)
cuUPPlmnCount := cuUPPFContainerItem.OCUUPPMContainer.CUUPPlmnCount
log.Printf("CU-UP Plmn Count: %d", cuUPPlmnCount)
for k := 0; k < cuUPPlmnCount; k++ {
log.Printf("CU-UP Plmn [%d]: ", k)
cuUPPlmn := cuUPPFContainerItem.OCUUPPMContainer.CUUPPlmns[k]
log.Printf("PlmnID: %x", cuUPPlmn.PlmnID.Buf)
plmnID, err := e2sm.ParsePLMNIdentity(cuUPPlmn.PlmnID.Buf, cuUPPlmn.PlmnID.Size)
if err != nil {
xapp.Logger.Error("Failed to parse PlmnID in CU-UP PF Container: %v", err)
log.Printf("Failed to parse PlmnID in CU-UP PF Container: %v", err)
continue
}
if cuUPPlmn.CUUPPM5GC != nil {
sliceToReportCount := cuUPPlmn.CUUPPM5GC.SliceToReportCount
log.Printf("SliceToReportCount: %d", sliceToReportCount)
for l := 0; l < sliceToReportCount; l++ {
log.Printf("SliceToReport[%d]: ", l)
sliceToReport := cuUPPlmn.CUUPPM5GC.SliceToReports[l]
log.Printf("SliceID.sST: %x", sliceToReport.SliceID.SST.Buf)
if sliceToReport.SliceID.SD != nil {
log.Printf("SliceID.sD: %x", sliceToReport.SliceID.SD.Buf)
}
sliceID, err := e2sm.ParseSliceID(sliceToReport.SliceID)
if err != nil {
xapp.Logger.Error("Failed to parse sliceID in CU-UP PF Container with PlmnID [%s]: %v", plmnID, err)
log.Printf("Failed to parse sliceID in CU-UP PF Container with PlmnID [%s]: %v", plmnID, err)
continue
}
fQIPERSlicesPerPlmnCount := sliceToReport.FQIPERSlicesPerPlmnCount
log.Printf("5QIPerSlicesPerPlmnCount: %d", fQIPERSlicesPerPlmnCount)
for m := 0; m < fQIPERSlicesPerPlmnCount; m++ {
log.Printf("5QIPerSlicesPerPlmn[%d]: ", m)
fQIPERSlicesPerPlmn := sliceToReport.FQIPERSlicesPerPlmns[m]
fiveQI := fQIPERSlicesPerPlmn.FiveQI
log.Printf("5QI: %d", fiveQI)
if plmnID == plmnIDHdr && sliceID == sliceIDHdr && fiveQI == fiveQIHdr {
flag = true
}
if fQIPERSlicesPerPlmn.PDCPBytesDL != nil {
log.Printf("PDCPBytesDL: %x", fQIPERSlicesPerPlmn.PDCPBytesDL.Buf)
if flag {
dlPDCPBytes, err = e2sm.ParseInteger(fQIPERSlicesPerPlmn.PDCPBytesDL.Buf, fQIPERSlicesPerPlmn.PDCPBytesDL.Size)
if err != nil {
xapp.Logger.Error("Failed to parse PDCPBytesDL in CU-UP PF Container with PlmnID [%s], SliceID [%d], 5QI [%d]: %v", plmnID, sliceID, fiveQI, err)
log.Printf("Failed to parse PDCPBytesDL in CU-UP PF Container with PlmnID [%s], SliceID [%d], 5QI [%d]: %v", plmnID, sliceID, fiveQI, err)
continue
}
}
}
if fQIPERSlicesPerPlmn.PDCPBytesUL != nil {
log.Printf("PDCPBytesUL: %x", fQIPERSlicesPerPlmn.PDCPBytesUL.Buf)
if flag {
ulPDCPBytes, err = e2sm.ParseInteger(fQIPERSlicesPerPlmn.PDCPBytesUL.Buf, fQIPERSlicesPerPlmn.PDCPBytesUL.Size)
if err != nil {
xapp.Logger.Error("Failed to parse PDCPBytesUL in CU-UP PF Container with PlmnID [%s], SliceID [%d], 5QI [%d]: %v", plmnID, sliceID, fiveQI, err)
log.Printf("Failed to parse PDCPBytesUL in CU-UP PF Container with PlmnID [%s], SliceID [%d], 5QI [%d]: %v", plmnID, sliceID, fiveQI, err)
continue
}
}
}
}
}
}
if cuUPPlmn.CUUPPMEPC != nil {
cuUPPMEPCPerQCIReportCount := cuUPPlmn.CUUPPMEPC.CUUPPMEPCPerQCIReportCount
log.Printf("PerQCIReportCount: %d", cuUPPMEPCPerQCIReportCount)
for l := 0; l < cuUPPMEPCPerQCIReportCount; l++ {
log.Printf("PerQCIReport[%d]: ", l)
cuUPPMEPCPerQCIReport := cuUPPlmn.CUUPPMEPC.CUUPPMEPCPerQCIReports[l]
log.Printf("QCI: %d", cuUPPMEPCPerQCIReport.QCI)
if cuUPPMEPCPerQCIReport.PDCPBytesDL != nil {
log.Printf("PDCPBytesDL: %x", cuUPPMEPCPerQCIReport.PDCPBytesDL.Buf)
}
if cuUPPMEPCPerQCIReport.PDCPBytesUL != nil {
log.Printf("PDCPBytesUL: %x", cuUPPMEPCPerQCIReport.PDCPBytesUL.Buf)
}
}
}
}
}
} else {
xapp.Logger.Error("Unknown PF Container type: %d", containerType)
log.Printf("Unknown PF Container type: %d", containerType)
continue
}
}
if pmContainer.RANContainer != nil {
log.Printf("RANContainer: %x", pmContainer.RANContainer.Timestamp.Buf)
timestamp, _ := e2sm.ParseTimestamp(pmContainer.RANContainer.Timestamp.Buf, pmContainer.RANContainer.Timestamp.Size)
log.Printf("Timestamp=[sec: %d, nsec: %d]", timestamp.TVsec, timestamp.TVnsec)
containerType = pmContainer.RANContainer.ContainerType
if containerType == 1 {
log.Printf("DU Usage Report: ")
oDUUE := pmContainer.RANContainer.Container.(*DUUsageReportType)
for j := 0; j < oDUUE.CellResourceReportItemCount; j++ {
cellResourceReportItem := oDUUE.CellResourceReportItems[j]
log.Printf("nRCGI.PlmnID: %x", cellResourceReportItem.NRCGI.PlmnID.Buf)
log.Printf("nRCGI.NRCellID: %x, Unused: %d", cellResourceReportItem.NRCGI.NRCellID.Buf, cellResourceReportItem.NRCGI.NRCellID.BitsUnused)
servingCellID, err := e2sm.ParseNRCGI(cellResourceReportItem.NRCGI)
if err != nil {
xapp.Logger.Error("Failed to parse NRCGI in DU Usage Report: %v", err)
log.Printf("Failed to parse NRCGI in DU Usage Report: %v", err)
continue
}
for k := 0; k < cellResourceReportItem.UeResourceReportItemCount; k++ {
ueResourceReportItem := cellResourceReportItem.UeResourceReportItems[k]
log.Printf("C-RNTI: %x", ueResourceReportItem.CRNTI.Buf)
ueID, err := e2sm.ParseInteger(ueResourceReportItem.CRNTI.Buf, ueResourceReportItem.CRNTI.Size)
if err != nil {
xapp.Logger.Error("Failed to parse C-RNTI in DU Usage Report with Serving Cell ID [%s]: %v", servingCellID, err)
log.Printf("Failed to parse C-RNTI in DU Usage Report with Serving Cell ID [%s]: %v", servingCellID, err)
continue
}
var ueMetrics UeMetricsEntry
retStr, err := c.sdl.Get([]string{"{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)})
if err != nil {
panic(err)
xapp.Logger.Error("Failed to get ueMetrics from Redis!")
log.Printf("Failed to get ueMetrics from Redis!")
} else {
if retStr["{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)] != nil {
ueJsonStr := retStr["{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)].(string)
json.Unmarshal([]byte(ueJsonStr), &ueMetrics)
}
}
//if isUeExist, _ := c.client.Exists("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)).Result(); isUeExist == 1 {
// ueJsonStr, _ := c.client.Get("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)).Result()
// json.Unmarshal([]byte(ueJsonStr), &ueMetrics)
//}
ueMetrics.UeID = ueID
log.Printf("UeID: %d", ueMetrics.UeID)
ueMetrics.ServingCellID = servingCellID
log.Printf("ServingCellID: %s", ueMetrics.ServingCellID)
ueMetrics.MeasPeriodRF = 20
if flag {
timestampPRB = timestamp
}
ueMetrics.MeasTimestampPRB.TVsec = timestamp.TVsec
ueMetrics.MeasTimestampPRB.TVnsec = timestamp.TVnsec
if ueResourceReportItem.PRBUsageDL != -1 {
ueMetrics.PRBUsageDL = ueResourceReportItem.PRBUsageDL
log.Printf("PRBUsageDL: %d", ueMetrics.PRBUsageDL)
}
if ueResourceReportItem.PRBUsageUL != -1 {
ueMetrics.PRBUsageUL = ueResourceReportItem.PRBUsageUL
log.Printf("PRBUsageUL: %d", ueMetrics.PRBUsageUL)
}
newUeJsonStr, err := json.Marshal(&ueMetrics)
if err != nil {
xapp.Logger.Error("Failed to marshal UeMetrics with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to marshal UeMetrics with UE ID [%d]: %v", ueID, err)
continue
}
err = c.sdl.Set("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10), newUeJsonStr)
if err != nil {
xapp.Logger.Error("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
continue
}
//err = c.client.Set("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10), newUeJsonStr, 0).Err()
//if err != nil {
// xapp.Logger.Error("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
// log.Printf("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
// continue
//}
}
}
} else if containerType == 2 {
log.Printf("CU-CP Usage Report: ")
oCUCPUE := pmContainer.RANContainer.Container.(*CUCPUsageReportType)
for j := 0; j < oCUCPUE.CellResourceReportItemCount; j++ {
cellResourceReportItem := oCUCPUE.CellResourceReportItems[j]
log.Printf("nRCGI.PlmnID: %x", cellResourceReportItem.NRCGI.PlmnID.Buf)
log.Printf("nRCGI.NRCellID: %x, Unused: %d", cellResourceReportItem.NRCGI.NRCellID.Buf, cellResourceReportItem.NRCGI.NRCellID.BitsUnused)
servingCellID, err := e2sm.ParseNRCGI(cellResourceReportItem.NRCGI)
if err != nil {
xapp.Logger.Error("Failed to parse NRCGI in CU-CP Usage Report: %v", err)
log.Printf("Failed to parse NRCGI in CU-CP Usage Report: %v", err)
continue
}
for k := 0; k < cellResourceReportItem.UeResourceReportItemCount; k++ {
ueResourceReportItem := cellResourceReportItem.UeResourceReportItems[k]
log.Printf("C-RNTI: %x", ueResourceReportItem.CRNTI.Buf)
ueID, err := e2sm.ParseInteger(ueResourceReportItem.CRNTI.Buf, ueResourceReportItem.CRNTI.Size)
if err != nil {
xapp.Logger.Error("Failed to parse C-RNTI in CU-CP Usage Report with Serving Cell ID [%s]: %v", err)
log.Printf("Failed to parse C-RNTI in CU-CP Usage Report with Serving Cell ID [%s]: %v", err)
continue
}
var ueMetrics UeMetricsEntry
retStr, err := c.sdl.Get([]string{"{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)})
if err != nil {
panic(err)
xapp.Logger.Error("Failed to get ueMetrics from Redis!")
log.Printf("Failed to get ueMetrics from Redis!")
} else {
if retStr["{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)] != nil {
ueJsonStr := retStr["{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)].(string)
json.Unmarshal([]byte(ueJsonStr), &ueMetrics)
}
}
//if isUeExist, _ := c.client.Exists("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)).Result(); isUeExist == 1 {
// ueJsonStr, _ := c.client.Get("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)).Result()
// json.Unmarshal([]byte(ueJsonStr), &ueMetrics)
//}
ueMetrics.UeID = ueID
log.Printf("UeID: %d", ueMetrics.UeID)
ueMetrics.ServingCellID = servingCellID
log.Printf("ServingCellID: %s", ueMetrics.ServingCellID)
ueMetrics.MeasTimeRF.TVsec = timestamp.TVsec
ueMetrics.MeasTimeRF.TVnsec = timestamp.TVnsec
ueMetrics.MeasPeriodPDCP = 20
ueMetrics.MeasPeriodPRB = 20
if ueResourceReportItem.ServingCellRF != nil {
err = json.Unmarshal(ueResourceReportItem.ServingCellRF.Buf, &ueMetrics.ServingCellRF)
log.Printf("ueMetrics.ServingCellRF: %+v", ueMetrics.ServingCellRF)
if err != nil {
xapp.Logger.Error("Failed to Unmarshal ServingCellRF in CU-CP Usage Report with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to Unmarshal ServingCellRF in CU-CP Usage Report with UE ID [%d]: %v", ueID, err)
log.Printf("ServingCellRF raw data: %x", ueResourceReportItem.ServingCellRF.Buf)
continue
}
}
if ueResourceReportItem.NeighborCellRF != nil {
err = json.Unmarshal(ueResourceReportItem.NeighborCellRF.Buf, &ueMetrics.NeighborCellsRF)
log.Printf("ueMetrics.NeighborCellsRF: %+v", ueMetrics.NeighborCellsRF)
if err != nil {
xapp.Logger.Error("Failed to Unmarshal NeighborCellRF in CU-CP Usage Report with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to Unmarshal NeighborCellRF in CU-CP Usage Report with UE ID [%d]: %v", ueID, err)
log.Printf("NeighborCellRF raw data: %x", ueResourceReportItem.NeighborCellRF.Buf)
continue
}
}
newUeJsonStr, err := json.Marshal(&ueMetrics)
if err != nil {
xapp.Logger.Error("Failed to marshal UeMetrics with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to marshal UeMetrics with UE ID [%d]: %v", ueID, err)
continue
}
err = c.sdl.Set("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10), newUeJsonStr)
if err != nil {
xapp.Logger.Error("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
continue
}
//err = c.client.Set("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10), newUeJsonStr, 0).Err()
//if err != nil {
// xapp.Logger.Error("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
// log.Printf("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
// continue
//}
}
}
} else if containerType == 3 {
log.Printf("CU-UP Usage Report: ")
oCUUPUE := pmContainer.RANContainer.Container.(*CUUPUsageReportType)
for j := 0; j < oCUUPUE.CellResourceReportItemCount; j++ {
cellResourceReportItem := oCUUPUE.CellResourceReportItems[j]
log.Printf("nRCGI.PlmnID: %x", cellResourceReportItem.NRCGI.PlmnID.Buf)
log.Printf("nRCGI.NRCellID: %x, Unused: %d", cellResourceReportItem.NRCGI.NRCellID.Buf, cellResourceReportItem.NRCGI.NRCellID.BitsUnused)
servingCellID, err := e2sm.ParseNRCGI(cellResourceReportItem.NRCGI)
if err != nil {
xapp.Logger.Error("Failed to parse NRCGI in CU-UP Usage Report: %v", err)
log.Printf("Failed to parse NRCGI in CU-UP Usage Report: %v", err)
continue
}
for k := 0; k < cellResourceReportItem.UeResourceReportItemCount; k++ {
ueResourceReportItem := cellResourceReportItem.UeResourceReportItems[k]
log.Printf("C-RNTI: %x", ueResourceReportItem.CRNTI.Buf)
ueID, err := e2sm.ParseInteger(ueResourceReportItem.CRNTI.Buf, ueResourceReportItem.CRNTI.Size)
if err != nil {
xapp.Logger.Error("Failed to parse C-RNTI in CU-UP Usage Report Serving Cell ID [%s]: %v", servingCellID, err)
log.Printf("Failed to parse C-RNTI in CU-UP Usage Report Serving Cell ID [%s]: %v", servingCellID, err)
continue
}
var ueMetrics UeMetricsEntry
retStr, err := c.sdl.Get([]string{"{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)})
if err != nil {
panic(err)
xapp.Logger.Error("Failed to get ueMetrics from Redis!")
log.Printf("Failed to get ueMetrics from Redis!")
} else {
if retStr["{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)] != nil {
ueJsonStr := retStr["{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)].(string)
json.Unmarshal([]byte(ueJsonStr), &ueMetrics)
}
}
//if isUeExist, _ := c.client.Exists("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)).Result(); isUeExist == 1 {
// ueJsonStr, _ := c.client.Get("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10)).Result()
// json.Unmarshal([]byte(ueJsonStr), &ueMetrics)
//}
ueMetrics.UeID = ueID
log.Printf("UeID: %d", ueMetrics.UeID)
ueMetrics.ServingCellID = servingCellID
log.Printf("ServingCellID: %s", ueMetrics.ServingCellID)
if flag {
timestampPDCPBytes = timestamp
}
ueMetrics.MeasTimestampPDCPBytes.TVsec = timestamp.TVsec
ueMetrics.MeasTimestampPDCPBytes.TVnsec = timestamp.TVnsec
if ueResourceReportItem.PDCPBytesDL != nil {
ueMetrics.PDCPBytesDL, err = e2sm.ParseInteger(ueResourceReportItem.PDCPBytesDL.Buf, ueResourceReportItem.PDCPBytesDL.Size)
if err != nil {
xapp.Logger.Error("Failed to parse PDCPBytesDL in CU-UP Usage Report with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to parse PDCPBytesDL in CU-UP Usage Report with UE ID [%d]: %v", ueID, err)
continue
}
}
if ueResourceReportItem.PDCPBytesUL != nil {
ueMetrics.PDCPBytesUL, err = e2sm.ParseInteger(ueResourceReportItem.PDCPBytesUL.Buf, ueResourceReportItem.PDCPBytesUL.Size)
if err != nil {
xapp.Logger.Error("Failed to parse PDCPBytesUL in CU-UP Usage Report with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to parse PDCPBytesUL in CU-UP Usage Report with UE ID [%d]: %v", ueID, err)
continue
}
}
newUeJsonStr, err := json.Marshal(&ueMetrics)
if err != nil {
xapp.Logger.Error("Failed to marshal UeMetrics with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to marshal UeMetrics with UE ID [%d]: %v", ueID, err)
continue
}
err = c.sdl.Set("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10), newUeJsonStr)
if err != nil {
xapp.Logger.Error("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
log.Printf("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
continue
}
//err = c.client.Set("{TS-UE-metrics}," + strconv.FormatInt(ueID, 10), newUeJsonStr, 0).Err()
//if err != nil {
// xapp.Logger.Error("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
// log.Printf("Failed to set UeMetrics into redis with UE ID [%d]: %v", ueID, err)
// continue
//}
}
}
} else {
xapp.Logger.Error("Unknown PF Container Type: %d", containerType)
log.Printf("Unknown PF Container Type: %d", containerType)
continue
}
}
if flag {
var cellMetrics CellMetricsEntry
retStr, err := c.sdl.Get([]string{"{TS-cell-metrics}," + cellIDHdr})
if err != nil {
panic(err)
xapp.Logger.Error("Failed to get cellMetrics from Redis!")
log.Printf("Failed to get cellMetrics from Redis!")
} else {
if retStr["{TS-cell-metrics}," + cellIDHdr] != nil {
cellJsonStr := retStr["{TS-cell-metrics}," + cellIDHdr].(string)
json.Unmarshal([]byte(cellJsonStr), &cellMetrics)
}
}
//if isCellExist, _ := c.client.Exists("{TS-cell-metrics}," + cellIDHdr).Result(); isCellExist == 1 {
// cellJsonStr, _ := c.client.Get("{TS-cell-metrics}," + cellIDHdr).Result()
// json.Unmarshal([]byte(cellJsonStr), &cellMetrics)
//}
cellMetrics.MeasPeriodPDCP = 20
cellMetrics.MeasPeriodPRB = 20
cellMetrics.CellID = cellIDHdr
if timestampPDCPBytes != nil {
cellMetrics.MeasTimestampPDCPBytes.TVsec = timestampPDCPBytes.TVsec
cellMetrics.MeasTimestampPDCPBytes.TVnsec = timestampPDCPBytes.TVnsec
}
if dlPDCPBytes != -1 {
cellMetrics.PDCPBytesDL = dlPDCPBytes
}
if ulPDCPBytes != -1 {
cellMetrics.PDCPBytesUL = ulPDCPBytes
}
if timestampPRB != nil {
cellMetrics.MeasTimestampPRB.TVsec = timestampPRB.TVsec
cellMetrics.MeasTimestampPRB.TVnsec = timestampPRB.TVnsec
}
if availPRBDL != -1 {
cellMetrics.AvailPRBDL = availPRBDL
}
if availPRBUL != -1 {
cellMetrics.AvailPRBUL = availPRBUL
}
newCellJsonStr, err := json.Marshal(&cellMetrics)
if err != nil {
xapp.Logger.Error("Failed to marshal CellMetrics with CellID [%s]: %v", cellIDHdr, err)
log.Printf("Failed to marshal CellMetrics with CellID [%s]: %v", cellIDHdr, err)
continue
}
err = c.sdl.Set("{TS-cell-metrics}," + cellIDHdr, newCellJsonStr)
if err != nil {
xapp.Logger.Error("Failed to set CellMetrics into redis with CellID [%s]: %v", cellIDHdr, err)
log.Printf("Failed to set CellMetrics into redis with CellID [%s]: %v", cellIDHdr, err)
continue
}
//err = c.client.Set("{TS-cell-metrics}," + cellIDHdr, newCellJsonStr, 0).Err()
//if err != nil {
// xapp.Logger.Error("Failed to set CellMetrics into redis with CellID [%s]: %v", cellIDHdr, err)
// log.Printf("Failed to set CellMetrics into redis with CellID [%s]: %v", cellIDHdr, err)
// continue
//}
}
}
} else {
xapp.Logger.Error("Unknown RIC Indication Message Format: %d", indMsg.IndMsgType)
log.Printf("Unkonw RIC Indication Message Format: %d", indMsg.IndMsgType)
return
}
return nil
}
func (c *Control) handleSubscriptionResponse(params *xapp.RMRParams) (err error) {
xapp.Logger.Debug("The SubId in RIC_SUB_RESP is %d", params.SubId)
log.Printf("The SubId in RIC_SUB_RESP is %d", params.SubId)
ranName := params.Meid.RanName
c.eventCreateExpiredMu.Lock()
_, ok := c.eventCreateExpiredMap[ranName]
if !ok {
c.eventCreateExpiredMu.Unlock()
xapp.Logger.Debug("RIC_SUB_REQ has been deleted!")
log.Printf("RIC_SUB_REQ has been deleted!")
return nil
} else {
c.eventCreateExpiredMap[ranName] = true
c.eventCreateExpiredMu.Unlock()
}
var cep *E2ap
subscriptionResp, err := cep.GetSubscriptionResponseMessage(params.Payload)
if err != nil {
xapp.Logger.Error("Failed to decode RIC Subscription Response message: %v", err)
log.Printf("Failed to decode RIC Subscription Response message: %v", err)
return
}
log.Printf("RIC Subscription Response message from {%s} received", params.Meid.RanName)
log.Printf("SubscriptionID: %d", params.SubId)
log.Printf("RequestID: %d", subscriptionResp.RequestID)
log.Printf("RequestSequenceNumber: %d", subscriptionResp.RequestSequenceNumber)
log.Printf("FunctionID: %d", subscriptionResp.FuncID)
log.Printf("ActionAdmittedList:")
for index := 0; index < subscriptionResp.ActionAdmittedList.Count; index++ {
log.Printf("[%d]ActionID: %d", index, subscriptionResp.ActionAdmittedList.ActionID[index])
}
log.Printf("ActionNotAdmittedList:")
for index := 0; index < subscriptionResp.ActionNotAdmittedList.Count; index++ {
log.Printf("[%d]ActionID: %d", index, subscriptionResp.ActionNotAdmittedList.ActionID[index])
log.Printf("[%d]CauseType: %d CauseID: %d", index, subscriptionResp.ActionNotAdmittedList.Cause[index].CauseType, subscriptionResp.ActionNotAdmittedList.Cause[index].CauseID)
}
return nil
}
func (c *Control) handleSubscriptionFailure(params *xapp.RMRParams) (err error) {
xapp.Logger.Debug("The SubId in RIC_SUB_FAILURE is %d", params.SubId)
log.Printf("The SubId in RIC_SUB_FAILURE is %d", params.SubId)
ranName := params.Meid.RanName
c.eventCreateExpiredMu.Lock()
_, ok := c.eventCreateExpiredMap[ranName]
if !ok {
c.eventCreateExpiredMu.Unlock()
xapp.Logger.Debug("RIC_SUB_REQ has been deleted!")
log.Printf("RIC_SUB_REQ has been deleted!")
return nil
} else {
c.eventCreateExpiredMap[ranName] = true
c.eventCreateExpiredMu.Unlock()
}
return nil
}
func (c *Control) handleSubscriptionDeleteResponse(params *xapp.RMRParams) (err error) {
xapp.Logger.Debug("The SubId in RIC_SUB_DEL_RESP is %d", params.SubId)
log.Printf("The SubId in RIC_SUB_DEL_RESP is %d", params.SubId)
ranName := params.Meid.RanName
c.eventDeleteExpiredMu.Lock()
_, ok := c.eventDeleteExpiredMap[ranName]
if !ok {
c.eventDeleteExpiredMu.Unlock()
xapp.Logger.Debug("RIC_SUB_DEL_REQ has been deleted!")
log.Printf("RIC_SUB_DEL_REQ has been deleted!")
return nil
} else {
c.eventDeleteExpiredMap[ranName] = true
c.eventDeleteExpiredMu.Unlock()
}
return nil
}
func (c *Control) handleSubscriptionDeleteFailure(params *xapp.RMRParams) (err error) {
xapp.Logger.Debug("The SubId in RIC_SUB_DEL_FAILURE is %d", params.SubId)
log.Printf("The SubId in RIC_SUB_DEL_FAILURE is %d", params.SubId)
ranName := params.Meid.RanName
c.eventDeleteExpiredMu.Lock()
_, ok := c.eventDeleteExpiredMap[ranName]
if !ok {
c.eventDeleteExpiredMu.Unlock()
xapp.Logger.Debug("RIC_SUB_DEL_REQ has been deleted!")
log.Printf("RIC_SUB_DEL_REQ has been deleted!")
return nil
} else {
c.eventDeleteExpiredMap[ranName] = true
c.eventDeleteExpiredMu.Unlock()
}
return nil
}
func (c *Control) setEventCreateExpiredTimer(ranName string) {
c.eventCreateExpiredMu.Lock()
c.eventCreateExpiredMap[ranName] = false
c.eventCreateExpiredMu.Unlock()
timer := time.NewTimer(time.Duration(c.eventCreateExpired) * time.Second)
go func(t *time.Timer) {
defer t.Stop()
xapp.Logger.Debug("RIC_SUB_REQ[%s]: Waiting for RIC_SUB_RESP...", ranName)
log.Printf("RIC_SUB_REQ[%s]: Waiting for RIC_SUB_RESP...", ranName)
for {
select {
case <-t.C:
c.eventCreateExpiredMu.Lock()
isResponsed := c.eventCreateExpiredMap[ranName]
delete(c.eventCreateExpiredMap, ranName)
c.eventCreateExpiredMu.Unlock()
if !isResponsed {
xapp.Logger.Debug("RIC_SUB_REQ[%s]: RIC Event Create Timer experied!", ranName)
log.Printf("RIC_SUB_REQ[%s]: RIC Event Create Timer experied!", ranName)
// c.sendRicSubDelRequest(subID, requestSN, funcID)
return
}
default:
c.eventCreateExpiredMu.Lock()
flag := c.eventCreateExpiredMap[ranName]
if flag {
delete(c.eventCreateExpiredMap, ranName)
c.eventCreateExpiredMu.Unlock()
xapp.Logger.Debug("RIC_SUB_REQ[%s]: RIC Event Create Timer canceled!", ranName)
log.Printf("RIC_SUB_REQ[%s]: RIC Event Create Timer canceled!", ranName)
return
} else {
c.eventCreateExpiredMu.Unlock()
}
}
time.Sleep(100 * time.Millisecond)
}
}(timer)
}
func (c *Control) setEventDeleteExpiredTimer(ranName string) {
c.eventDeleteExpiredMu.Lock()
c.eventDeleteExpiredMap[ranName] = false
c.eventDeleteExpiredMu.Unlock()
timer := time.NewTimer(time.Duration(c.eventDeleteExpired) * time.Second)
go func(t *time.Timer) {
defer t.Stop()
xapp.Logger.Debug("RIC_SUB_DEL_REQ[%s]: Waiting for RIC_SUB_DEL_RESP...", ranName)
log.Printf("RIC_SUB_DEL_REQ[%s]: Waiting for RIC_SUB_DEL_RESP...", ranName)
for {
select {
case <-t.C:
c.eventDeleteExpiredMu.Lock()
isResponsed := c.eventDeleteExpiredMap[ranName]
delete(c.eventDeleteExpiredMap, ranName)
c.eventDeleteExpiredMu.Unlock()
if !isResponsed {
xapp.Logger.Debug("RIC_SUB_DEL_REQ[%s]: RIC Event Delete Timer experied!", ranName)
log.Printf("RIC_SUB_DEL_REQ[%s]: RIC Event Delete Timer experied!", ranName)
return
}
default:
c.eventDeleteExpiredMu.Lock()
flag := c.eventDeleteExpiredMap[ranName]
if flag {
delete(c.eventDeleteExpiredMap, ranName)
c.eventDeleteExpiredMu.Unlock()
xapp.Logger.Debug("RIC_SUB_DEL_REQ[%s]: RIC Event Delete Timer canceled!", ranName)
log.Printf("RIC_SUB_DEL_REQ[%s]: RIC Event Delete Timer canceled!", ranName)
return
} else {
c.eventDeleteExpiredMu.Unlock()
}
}
time.Sleep(100 * time.Millisecond)
}
}(timer)
}
func (c *Control) sendRicSubRequest(subID int, requestSN int, funcID int) (err error) {
var e2ap *E2ap
var e2sm *E2sm
var eventTriggerCount int = 1
var periods []int64 = []int64{13}
var eventTriggerDefinition []byte = make([]byte, 8)
_, err = e2sm.SetEventTriggerDefinition(eventTriggerDefinition, eventTriggerCount, periods)
if err != nil {
xapp.Logger.Error("Failed to send RIC_SUB_REQ: %v", err)
log.Printf("Failed to send RIC_SUB_REQ: %v", err)
return err
}
log.Printf("Set EventTriggerDefinition: %x", eventTriggerDefinition)
var actionCount int = 1
var ricStyleType []int64 = []int64{0}
var actionIds []int64 = []int64{0}
var actionTypes []int64 = []int64{0}
var actionDefinitions []ActionDefinition = make([]ActionDefinition, actionCount)
var subsequentActions []SubsequentAction = []SubsequentAction{SubsequentAction{0, 0, 0}}
for index := 0; index < actionCount; index++ {
if ricStyleType[index] == 0 {
actionDefinitions[index].Buf = nil
actionDefinitions[index].Size = 0
} else {
actionDefinitions[index].Buf = make([]byte, 8)
_, err = e2sm.SetActionDefinition(actionDefinitions[index].Buf, ricStyleType[index])
if err != nil {
xapp.Logger.Error("Failed to send RIC_SUB_REQ: %v", err)
log.Printf("Failed to send RIC_SUB_REQ: %v", err)
return err
}
actionDefinitions[index].Size = len(actionDefinitions[index].Buf)
log.Printf("Set ActionDefinition[%d]: %x", index, actionDefinitions[index].Buf)
}
}
for index := 0; index < 1; index++ { //len(c.ranList)
params := &xapp.RMRParams{}
params.Mtype = 12010
params.SubId = subID
//xapp.Logger.Debug("Send RIC_SUB_REQ to {%s}", c.ranList[index])
//log.Printf("Send RIC_SUB_REQ to {%s}", c.ranList[index])
params.Payload = make([]byte, 1024)
params.Payload, err = e2ap.SetSubscriptionRequestPayload(params.Payload, 1001, uint16(requestSN), uint16(funcID), eventTriggerDefinition, len(eventTriggerDefinition), actionCount, actionIds, actionTypes, actionDefinitions, subsequentActions)
if err != nil {
xapp.Logger.Error("Failed to send RIC_SUB_REQ: %v", err)
log.Printf("Failed to send RIC_SUB_REQ: %v", err)
return err
}
log.Printf("Set Payload: %x", params.Payload)
//params.Meid = &xapp.RMRMeid{RanName: c.ranList[index]}
params.Meid = &xapp.RMRMeid{PlmnID: "373437", EnbID: "10110101110001100111011110001", RanName: "gnb_734_733_b5c67788"}
xapp.Logger.Debug("The RMR message to be sent is %d with SubId=%d", params.Mtype, params.SubId)
log.Printf("The RMR message to be sent is %d with SubId=%d", params.Mtype, params.SubId)
err = c.rmrSend(params)
if err != nil {
xapp.Logger.Error("Failed to send RIC_SUB_REQ: %v", err)
log.Printf("Failed to send RIC_SUB_REQ: %v", err)
return err
}
c.setEventCreateExpiredTimer(params.Meid.RanName)
//c.ranList = append(c.ranList[:index], c.ranList[index+1:]...)
//index--
}
return nil
}
func (c *Control) sendRicSubDelRequest(subID int, requestSN int, funcID int) (err error) {
params := &xapp.RMRParams{}
params.Mtype = 12020
params.SubId = subID
var e2ap *E2ap
params.Payload = make([]byte, 1024)
params.Payload, err = e2ap.SetSubscriptionDeleteRequestPayload(params.Payload, 100, uint16(requestSN), uint16(funcID))
if err != nil {
xapp.Logger.Error("Failed to send RIC_SUB_DEL_REQ: %v", err)
return err
}
log.Printf("Set Payload: %x", params.Payload)
if funcID == 0 {
//params.Meid = &xapp.RMRMeid{PlmnID: "::", EnbID: "::", RanName: "0"}
params.Meid = &xapp.RMRMeid{PlmnID: "373437", EnbID: "10110101110001100111011110001", RanName: "gnb_734_733_b5c67788"}
} else {
//params.Meid = &xapp.RMRMeid{PlmnID: "::", EnbID: "::", RanName: "3"}
params.Meid = &xapp.RMRMeid{PlmnID: "373437", EnbID: "10110101110001100111011110001", RanName: "gnb_734_733_b5c67788"}
}
xapp.Logger.Debug("The RMR message to be sent is %d with SubId=%d", params.Mtype, params.SubId)
log.Printf("The RMR message to be sent is %d with SubId=%d", params.Mtype, params.SubId)
err = c.rmrSend(params)
if err != nil {
xapp.Logger.Error("Failed to send RIC_SUB_DEL_REQ: %v", err)
log.Printf("Failed to send RIC_SUB_DEL_REQ: %v", err)
return err
}
c.setEventDeleteExpiredTimer(params.Meid.RanName)
return nil
}
|
package bertymessenger
import (
"context"
"io"
"strconv"
"testing"
"time"
"berty.tech/berty/v2/go/internal/testutil"
"berty.tech/berty/v2/go/pkg/bertyprotocol"
"github.com/gogo/protobuf/proto"
libp2p_mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
"google.golang.org/grpc"
"google.golang.org/grpc/test/bufconn"
"moul.io/u"
)
const timeout = time.Second * 5
func TestStreamThenCreateConv(t *testing.T) {
ctx, cancelCtx := context.WithTimeout(context.Background(), timeout)
defer cancelCtx()
l := testutil.Logger(t)
svc, cleanup := TestingService(ctx, t, &TestingServiceOpts{Logger: l})
defer cleanup()
// new client
lis := bufconn.Listen(1024 * 1024)
s := grpc.NewServer()
RegisterMessengerServiceServer(s, svc)
go func() {
err := s.Serve(lis)
require.NoError(t, err)
}()
conn, err := grpc.DialContext(ctx, "bufnet", grpc.WithContextDialer(mkBufDialer(lis)), grpc.WithInsecure())
require.NoError(t, err)
defer conn.Close()
client := NewMessengerServiceClient(conn)
res, err := client.EventStream(ctx, &EventStream_Request{})
require.NoError(t, err)
dn := "Tasty"
ccrep, err := client.ConversationCreate(ctx, &ConversationCreate_Request{DisplayName: dn})
require.NoError(t, err)
require.NotEmpty(t, ccrep.GetPublicKey())
var c *Conversation
for {
rep, err := res.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for conversation update after creating it")
require.NoError(t, err)
ev := rep.GetEvent()
if ev.GetType() == StreamEvent_TypeConversationUpdated {
var p StreamEvent_ConversationUpdated
err := proto.Unmarshal(ev.GetPayload(), &p)
require.NoError(t, err)
nc := p.GetConversation()
l.Debug("got conv", zap.String("display_name", nc.GetDisplayName()))
require.NotNil(t, nc)
require.Equal(t, nc.GetPublicKey(), ccrep.GetPublicKey())
if nc.GetDisplayName() != "" {
c = nc
break
}
}
}
require.NotNil(t, c)
require.Equal(t, ccrep.GetPublicKey(), c.GetPublicKey())
require.Equal(t, dn, c.GetDisplayName())
cancelCtx()
for err = nil; err == nil; {
_, err = res.Recv()
}
require.True(t, isGRPCCanceledError(err))
}
func TestContactRequest(t *testing.T) {
ctx, cancelCtx := context.WithTimeout(context.Background(), timeout)
defer cancelCtx()
l := testutil.Logger(t)
svc, cleanup := TestingService(ctx, t, &TestingServiceOpts{Logger: l})
defer cleanup()
// new client
lis := bufconn.Listen(1024 * 1024)
s := grpc.NewServer()
RegisterMessengerServiceServer(s, svc)
go func() {
err := s.Serve(lis)
require.NoError(t, err)
}()
conn, err := grpc.DialContext(ctx, "bufnet", grpc.WithContextDialer(mkBufDialer(lis)), grpc.WithInsecure())
require.NoError(t, err)
defer conn.Close()
client := NewMessengerServiceClient(conn)
stream, err := client.EventStream(ctx, &EventStream_Request{})
require.NoError(t, err)
contactName := "zxxma-iphone"
link := "https://berty.tech/id#key=CiDXcXUOl1rpm2FcbOf3TFtn-FYkl_sOwA5run1LGXHOPRIg4xCLGP-BWzgIWRH0Vz9D8aGAq1kyno5Oqv6ysAljZmA&name=" + contactName
ownMetadata := []byte("bar")
metadata, err := proto.Marshal(&ContactMetadata{contactName})
require.NoError(t, err)
pdlRep, err := client.ParseDeepLink(ctx, &ParseDeepLink_Request{Link: link})
require.NoError(t, err)
_, err = client.SendContactRequest(ctx, &SendContactRequest_Request{BertyID: pdlRep.BertyID, Metadata: metadata, OwnMetadata: ownMetadata})
require.NoError(t, err)
var c *Contact
for {
rep, err := stream.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for contact update after sending a request")
require.NoError(t, err)
ev := rep.GetEvent()
if ev.GetType() == StreamEvent_TypeContactUpdated {
var p StreamEvent_ContactUpdated
err := proto.Unmarshal(ev.GetPayload(), &p)
require.NoError(t, err)
c = p.GetContact()
break
}
}
require.NotNil(t, c)
require.Equal(t, contactName, c.GetDisplayName())
require.Equal(t, c.GetState(), Contact_OutgoingRequestEnqueued)
cancelCtx()
for err = nil; err == nil; {
_, err = stream.Recv()
}
require.True(t, isGRPCCanceledError(err))
}
func testingInfra(ctx context.Context, t *testing.T, amount int, l *zap.Logger) ([]MessengerServiceClient, func()) {
if l == nil {
l = testutil.Logger(t)
}
mocknet := libp2p_mocknet.New(ctx)
protocols, cleanup := bertyprotocol.NewTestingProtocolWithMockedPeers(ctx, t, &bertyprotocol.TestingOpts{Logger: l, Mocknet: mocknet}, amount)
clients := make([]MessengerServiceClient, amount)
for i, p := range protocols {
// new messenger service
svc, cleanupMessengerService := TestingService(ctx, t, &TestingServiceOpts{Logger: l, Client: p.Client, Index: i})
// new messenger client
lis := bufconn.Listen(1024 * 1024)
s := grpc.NewServer()
RegisterMessengerServiceServer(s, svc)
go func() {
err := s.Serve(lis)
require.NoError(t, err)
}()
conn, err := grpc.DialContext(ctx, "bufnet", grpc.WithContextDialer(mkBufDialer(lis)), grpc.WithInsecure())
require.NoError(t, err)
cleanup = u.CombineFuncs(func() {
require.NoError(t, conn.Close())
cleanupMessengerService()
}, cleanup)
clients[i] = NewMessengerServiceClient(conn)
}
require.NoError(t, mocknet.ConnectAllButSelf())
return clients, cleanup
}
func TestCreateConvThenStream(t *testing.T) {
ctx, cancelCtx := context.WithTimeout(context.Background(), timeout)
defer cancelCtx()
l := testutil.Logger(t)
svc, cleanup := TestingService(ctx, t, &TestingServiceOpts{Logger: l})
defer cleanup()
// new client
lis := bufconn.Listen(1024 * 1024)
s := grpc.NewServer()
RegisterMessengerServiceServer(s, svc)
go func() {
err := s.Serve(lis)
require.NoError(t, err)
}()
conn, err := grpc.DialContext(ctx, "bufnet", grpc.WithContextDialer(mkBufDialer(lis)), grpc.WithInsecure())
require.NoError(t, err)
defer conn.Close()
client := NewMessengerServiceClient(conn)
dn := "Tasty"
ccrep, err := client.ConversationCreate(ctx, &ConversationCreate_Request{DisplayName: dn})
require.NoError(t, err)
require.NotEmpty(t, ccrep.GetPublicKey())
strm, err := client.EventStream(ctx, &EventStream_Request{})
require.NoError(t, err)
var c *Conversation
for {
rep, err := strm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for conversation update after creating it")
require.NoError(t, err)
ev := rep.GetEvent()
if ev.GetType() == StreamEvent_TypeConversationUpdated {
var p StreamEvent_ConversationUpdated
err := proto.Unmarshal(ev.GetPayload(), &p)
require.NoError(t, err)
nc := p.GetConversation()
require.NotNil(t, nc)
require.Equal(t, nc.GetPublicKey(), ccrep.GetPublicKey())
if nc.GetDisplayName() != "" {
c = nc
break
}
}
}
require.NotNil(t, c)
require.Equal(t, ccrep.GetPublicKey(), c.GetPublicKey())
require.Equal(t, dn, c.GetDisplayName())
cancelCtx()
for err = nil; err == nil; {
_, err = strm.Recv()
}
require.True(t, isGRPCCanceledError(err))
}
func Test1To1Exchange(t *testing.T) {
testutil.SkipSlow(t)
testutil.SkipUnstable(t)
l := testutil.Logger(t)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
clients, cleanup := testingInfra(ctx, t, 2, l)
defer cleanup()
// Init accounts
aname := "Alice"
alice := clients[0]
_, err := alice.AccountUpdate(ctx, &AccountUpdate_Request{DisplayName: aname})
require.NoError(t, err)
astrm, err := alice.EventStream(ctx, &EventStream_Request{})
require.NoError(t, err)
var alink string
for alink == "" {
esr, err := astrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for account update after starting alice's events stream")
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeAccountUpdated {
var cu StreamEvent_AccountUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
acc := cu.GetAccount()
require.Equal(t, aname, acc.GetDisplayName())
alink = acc.GetLink()
}
}
bname := "Bob"
bob := clients[1]
_, err = bob.AccountUpdate(ctx, &AccountUpdate_Request{DisplayName: bname})
require.NoError(t, err)
bstrm, err := bob.EventStream(ctx, &EventStream_Request{})
require.NoError(t, err)
for {
esr, err := bstrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for account update after starting bob's events stream")
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeAccountUpdated {
var cu StreamEvent_AccountUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
acc := cu.GetAccount()
require.Equal(t, bname, acc.GetDisplayName())
break
}
}
// Request contact
_, err = bob.ContactRequest(ctx, &ContactRequest_Request{Link: alink})
require.NoError(t, err)
enqueued := false
for {
esr, err := bstrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for outgoing contact request updates (enqueued: %t)", enqueued)
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeContactUpdated {
var cu StreamEvent_ContactUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
c := cu.GetContact()
require.Equal(t, aname, c.GetDisplayName())
if !enqueued && c.GetState() == Contact_OutgoingRequestEnqueued {
enqueued = true
} else if enqueued && c.GetState() == Contact_OutgoingRequestSent {
break
}
}
}
var bc *Contact
for bc == nil {
esr, err := astrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for incoming contact request update")
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeContactUpdated {
var cu StreamEvent_ContactUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
c := cu.GetContact()
require.Equal(t, bname, c.GetDisplayName())
if c.GetState() == Contact_IncomingRequest {
bc = c
}
}
}
bpk := bc.GetPublicKey()
alice.ContactAccept(ctx, &ContactAccept_Request{PublicKey: bpk})
var gpk string
for {
esr, err := astrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for contact established in requested node")
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeContactUpdated {
var cu StreamEvent_ContactUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
c := cu.GetContact()
require.Equal(t, bname, c.GetDisplayName())
if c.GetState() == Contact_Established {
gpk = c.GetConversationPublicKey()
require.NotEmpty(t, gpk)
break
}
}
}
for {
esr, err := bstrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for contact established in requester node")
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeContactUpdated {
var cu StreamEvent_ContactUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
c := cu.GetContact()
require.Equal(t, aname, c.GetDisplayName())
if c.GetState() == Contact_Established {
require.Equal(t, c.GetConversationPublicKey(), gpk)
break
}
}
}
// Exchange messages
testMessage(ctx, t, l, "Hello Bob!", gpk, alice, astrm, bstrm)
testMessage(ctx, t, l, "Hello Alice!", gpk, bob, bstrm, astrm)
}
func testMessage(ctx context.Context, t *testing.T, l *zap.Logger, msg string, gpk string, sender MessengerServiceClient, senderStream MessengerService_EventStreamClient, receiverStream MessengerService_EventStreamClient) {
t.Helper()
beforeSend := jsNow()
um, err := proto.Marshal(&AppMessage_UserMessage{Body: msg})
require.NoError(t, err)
ir := Interact_Request{Type: AppMessage_TypeUserMessage, Payload: um, ConversationPublicKey: gpk}
_, err = sender.Interact(ctx, &ir)
require.NoError(t, err)
afterSend := jsNow()
var cid string
var gotMsg, gotAck bool
var sentDate int64
for !(gotAck && gotMsg) {
esr, err := receiverStream.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for msg or ack in receiver node (gotMsg: %t, gotAck: %t)", gotMsg, gotAck)
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeInteractionUpdated {
var cu StreamEvent_InteractionUpdated
err := proto.Unmarshal(evt.GetPayload(), &cu)
require.NoError(t, err)
inte := cu.GetInteraction()
if inte.GetType() == AppMessage_TypeUserMessage && inte.GetConversationPublicKey() == gpk {
var um AppMessage_UserMessage
err := proto.Unmarshal(inte.GetPayload(), &um)
require.NoError(t, err)
if um.GetBody() == msg {
require.False(t, gotAck)
require.False(t, inte.GetIsMe())
sentDate = um.GetSentDate()
require.LessOrEqual(t, beforeSend, sentDate)
require.GreaterOrEqual(t, afterSend, sentDate)
cid = inte.GetCid()
gotMsg = true
}
} else if inte.GetType() == AppMessage_TypeAcknowledge && inte.GetConversationPublicKey() == gpk {
var ack AppMessage_Acknowledge
err := proto.Unmarshal(inte.GetPayload(), &ack)
require.NoError(t, err)
if ack.GetTarget() == cid {
require.True(t, gotMsg)
require.True(t, inte.GetIsMe())
gotAck = true
}
}
}
}
gotAck = false
gotMsg = false
for !(gotAck && gotMsg) {
esr, err := senderStream.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for msg or ack in sender node (gotMsg: %t, gotAck: %t)", gotMsg, gotAck)
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeInteractionUpdated {
var cu StreamEvent_InteractionUpdated
err := proto.Unmarshal(evt.GetPayload(), &cu)
require.NoError(t, err)
inte := cu.GetInteraction()
if inte.GetType() == AppMessage_TypeUserMessage && inte.GetConversationPublicKey() == gpk {
var um AppMessage_UserMessage
err := proto.Unmarshal(inte.GetPayload(), &um)
require.NoError(t, err)
if inte.GetCid() == cid {
require.False(t, gotAck)
require.Equal(t, msg, um.GetBody())
require.True(t, inte.GetIsMe())
require.Equal(t, sentDate, um.GetSentDate())
gotMsg = true
}
} else if inte.GetType() == AppMessage_TypeAcknowledge && inte.GetConversationPublicKey() == gpk {
var ack AppMessage_Acknowledge
err := proto.Unmarshal(inte.GetPayload(), &ack)
require.NoError(t, err)
if ack.GetTarget() == cid {
require.True(t, gotMsg)
require.False(t, inte.GetIsMe())
gotAck = true
}
}
}
}
}
func Test3PeersExchange(t *testing.T) {
testutil.SkipSlow(t)
testutil.SkipUnstable(t)
amount := 3
require.Greater(t, amount, 1)
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
l := testutil.Logger(t)
clients, cleanup := testingInfra(ctx, t, amount, l)
defer cleanup()
creator := clients[0]
name := "My Group"
ccr, err := creator.ConversationCreate(ctx, &ConversationCreate_Request{DisplayName: name})
require.NoError(t, err)
creatorStrm, err := creator.EventStream(ctx, &EventStream_Request{})
require.NoError(t, err)
gpk := ccr.GetPublicKey()
// Create conv
var link string
for link == "" {
esr, err := creatorStrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for conversation update after creating it")
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeConversationUpdated {
var cu StreamEvent_ConversationUpdated
err := proto.Unmarshal(evt.GetPayload(), &cu)
require.NoError(t, err)
conv := cu.GetConversation()
if conv.GetPublicKey() == gpk {
require.Equal(t, name, conv.GetDisplayName())
link = conv.GetLink()
}
}
}
l.Debug("created conv", zap.String("pk", gpk))
// Join conv in other nodes
streams := make([]MessengerService_EventStreamClient, amount)
streams[0] = creatorStrm
for i := 1; i < amount; i++ {
cl := clients[i]
// also test while opening stream after
streams[i], err = cl.EventStream(ctx, &EventStream_Request{})
require.NoError(t, err)
_, err := cl.ConversationJoin(ctx, &ConversationJoin_Request{Link: link})
require.NoError(t, err)
for {
esr, err := streams[i].Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for conversation in member node %d", i)
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeConversationUpdated {
var cu StreamEvent_ConversationUpdated
err := proto.Unmarshal(evt.GetPayload(), &cu)
require.NoError(t, err)
conv := cu.GetConversation()
pk := conv.GetPublicKey()
l.Debug("received conv", zap.String("pk", pk), zap.Int("index", i))
if pk == gpk {
require.Equal(t, name, conv.GetDisplayName())
require.Equal(t, link, conv.GetLink())
l.Debug("found correct conv", zap.String("pk", pk), zap.Int("index", i))
break
}
}
}
}
// FIXME: really wait for everyone to know everyone (via MemberUpdated)
time.Sleep(time.Second * 20)
// TODO: check that members names are propagated
// Exchange messages
for i := 0; i < amount; i++ {
sender := clients[i]
senderStrm := streams[i]
strms := append(streams[0:i:i], streams[i+1:]...)
testMultiMessage(ctx, t, l, "Hello Group! "+strconv.Itoa(i), gpk, sender, senderStrm, strms)
}
}
func testMultiMessage(ctx context.Context, t *testing.T, l *zap.Logger, msg string, gpk string, sender MessengerServiceClient, senderStream MessengerService_EventStreamClient, receivers []MessengerService_EventStreamClient) {
beforeSend := jsNow()
um, err := proto.Marshal(&AppMessage_UserMessage{Body: msg})
require.NoError(t, err)
ir := Interact_Request{Type: AppMessage_TypeUserMessage, Payload: um, ConversationPublicKey: gpk}
_, err = sender.Interact(ctx, &ir)
require.NoError(t, err)
afterSend := jsNow()
var cid string
var sentDate int64
var gotMsg, gotAck bool
for !(gotAck && gotMsg) {
esr, err := senderStream.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for msg or ack in sender node (gotMsg: %t, gotAck: %t)", gotMsg, gotAck)
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeInteractionUpdated {
var cu StreamEvent_InteractionUpdated
err := proto.Unmarshal(evt.GetPayload(), &cu)
require.NoError(t, err)
inte := cu.GetInteraction()
l.Debug("sender received interaction", zap.String("cid", inte.GetCid()), zap.String("type", inte.GetType().String()))
if inte.GetType() == AppMessage_TypeUserMessage && inte.GetConversationPublicKey() == gpk {
var um AppMessage_UserMessage
err := proto.Unmarshal(inte.GetPayload(), &um)
require.NoError(t, err)
l.Debug("sender received message", zap.String("cid", inte.GetCid()), zap.String("body", um.GetBody()))
if msg == um.GetBody() {
l.Debug("sender found correct message", zap.String("cid", inte.GetCid()))
require.False(t, gotAck)
require.Equal(t, msg, um.GetBody())
require.True(t, inte.GetIsMe())
sentDate = um.GetSentDate()
require.LessOrEqual(t, beforeSend, sentDate)
require.GreaterOrEqual(t, afterSend, sentDate)
cid = inte.GetCid()
require.NotEmpty(t, cid)
gotMsg = true
}
} else if inte.GetType() == AppMessage_TypeAcknowledge && inte.GetConversationPublicKey() == gpk {
var ack AppMessage_Acknowledge
err := proto.Unmarshal(inte.GetPayload(), &ack)
require.NoError(t, err)
l.Debug("sender received ack", zap.String("target", ack.GetTarget()))
if ack.GetTarget() == cid {
l.Debug("sender found correct ack", zap.String("target", ack.GetTarget()))
require.True(t, gotMsg)
require.False(t, inte.GetIsMe())
gotAck = true
}
}
}
}
for i, receiverStream := range receivers {
gotMsg := false
gotAck := false
for !(gotAck && gotMsg) {
esr, err := receiverStream.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for msg or ack in receiver node (gotMsg: %t, gotAck: %t)", gotMsg, gotAck)
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeInteractionUpdated {
var iu StreamEvent_InteractionUpdated
err := proto.Unmarshal(evt.GetPayload(), &iu)
require.NoError(t, err)
inte := iu.GetInteraction()
l.Debug("received interaction", zap.String("cid", inte.GetCid()), zap.String("type", inte.GetType().String()), zap.Int("index", i))
if inte.GetType() == AppMessage_TypeUserMessage && inte.GetConversationPublicKey() == gpk {
var um AppMessage_UserMessage
err := proto.Unmarshal(inte.GetPayload(), &um)
require.NoError(t, err)
l.Debug("received message", zap.String("cid", inte.GetCid()), zap.String("body", um.GetBody()), zap.Int("index", i))
if inte.GetCid() == cid {
l.Debug("found correct cid", zap.String("cid", inte.GetCid()), zap.Int("index", i))
//require.False(t, gotAck) // Maybe FIXME otherwise we have to keep an ack backlog
require.False(t, inte.GetIsMe())
require.Equal(t, msg, um.GetBody())
require.Equal(t, sentDate, um.GetSentDate())
gotMsg = true
}
} else if inte.GetType() == AppMessage_TypeAcknowledge && inte.GetConversationPublicKey() == gpk {
var ack AppMessage_Acknowledge
err := proto.Unmarshal(inte.GetPayload(), &ack)
require.NoError(t, err)
target := ack.GetTarget()
require.NotEmpty(t, target)
l.Debug("received ack", zap.String("target", target), zap.Int("index", i))
if target == cid {
l.Debug("found correct ack", zap.Int("index", i))
//require.True(t, gotMsg) // Maybe FIXME
gotAck = true
}
}
}
}
}
}
func TestConversationInvitation2Contacts(t *testing.T) {
testutil.SkipSlow(t)
testutil.SkipUnstable(t)
amount := 3
require.Greater(t, amount, 2)
names := []string{"alice", "bob", "john"}
require.Equal(t, amount, len(names))
ctx, cancel := context.WithTimeout(context.Background(), 80*time.Second)
defer cancel()
l := testutil.Logger(t)
clients, cleanup := testingInfra(ctx, t, amount, l)
defer cleanup()
streams := make([]MessengerService_EventStreamClient, amount)
links := make([]string, amount)
publicKeys := make([]string, amount)
for i, client := range clients {
name := names[i]
_, err := client.AccountUpdate(ctx, &AccountUpdate_Request{DisplayName: name})
require.NoError(t, err)
stream, err := client.EventStream(ctx, &EventStream_Request{})
require.NoError(t, err)
streams[i] = stream
for {
esr, err := stream.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for account update after starting events stream in node %d", i)
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeAccountUpdated {
var cu StreamEvent_AccountUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
acc := cu.GetAccount()
require.Equal(t, name, acc.GetDisplayName())
links[i] = acc.GetLink()
publicKeys[i] = acc.GetPublicKey()
break
}
}
}
for i, client := range clients {
bstrm := streams[i]
bname := names[i]
for j := i + 1; j < amount; j++ {
otherClient := clients[j]
astrm := streams[j]
aname := names[j]
l.Debug("adding contacts", zap.String("aname", aname), zap.String("bname", bname))
_, err := client.ContactRequest(ctx, &ContactRequest_Request{Link: links[j]})
require.NoError(t, err)
enqueued := false
for {
esr, err := bstrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for outgoing contact request updates (%d to %d, enqueued: %t)", i, j, enqueued)
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeContactUpdated {
var cu StreamEvent_ContactUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
c := cu.GetContact()
if c.GetPublicKey() != publicKeys[j] {
continue
}
require.Equal(t, aname, c.GetDisplayName())
if !enqueued && c.GetState() == Contact_OutgoingRequestEnqueued {
enqueued = true
} else if enqueued && c.GetState() == Contact_OutgoingRequestSent {
break
}
}
}
var bc *Contact
for bc == nil {
esr, err := astrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for incoming contact request (%d to %d)", i, j)
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeContactUpdated {
var cu StreamEvent_ContactUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
c := cu.GetContact()
if c.GetPublicKey() != publicKeys[i] {
continue
}
require.Equal(t, bname, c.GetDisplayName())
if c.GetState() == Contact_IncomingRequest {
bc = c
}
}
}
bpk := bc.GetPublicKey()
otherClient.ContactAccept(ctx, &ContactAccept_Request{PublicKey: bpk})
var gpk string
for {
esr, err := astrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for contact established in requested node (%d to %d)", i, j)
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeContactUpdated {
var cu StreamEvent_ContactUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
c := cu.GetContact()
if c.GetPublicKey() != publicKeys[i] {
continue
}
require.Equal(t, bname, c.GetDisplayName())
if c.GetState() == Contact_Established {
gpk = c.GetConversationPublicKey()
require.NotEmpty(t, gpk)
break
}
}
}
for {
esr, err := bstrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for contact established in requester node (%d to %d)", i, j)
require.NoError(t, err)
if esr.GetEvent().GetType() == StreamEvent_TypeContactUpdated {
var cu StreamEvent_ContactUpdated
err := proto.Unmarshal(esr.GetEvent().GetPayload(), &cu)
require.NoError(t, err)
c := cu.GetContact()
if c.GetPublicKey() != publicKeys[j] {
continue
}
require.Equal(t, aname, c.GetDisplayName())
if c.GetState() == Contact_Established {
require.Equal(t, gpk, c.GetConversationPublicKey())
break
}
}
}
}
}
creator := clients[0]
name := "My Group"
ccr, err := creator.ConversationCreate(ctx, &ConversationCreate_Request{DisplayName: name, ContactsToInvite: publicKeys[1:]})
require.NoError(t, err)
creatorStrm := streams[0]
gpk := ccr.GetPublicKey()
var link string
for link == "" {
esr, err := creatorStrm.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for conversation update after creating it")
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeConversationUpdated {
var cu StreamEvent_ConversationUpdated
err := proto.Unmarshal(evt.GetPayload(), &cu)
require.NoError(t, err)
conv := cu.GetConversation()
if conv.GetPublicKey() == gpk && name == conv.GetDisplayName() {
// require.Equal(t, name, conv.GetDisplayName())
link = conv.GetLink()
}
}
}
l.Debug("created conv", zap.String("pk", gpk))
var inviteLink string
for i := 1; i < amount; i++ {
stream := streams[i]
for inviteLink == "" {
esr, err := stream.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for group invitation in node %d", i)
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeInteractionUpdated {
var iu StreamEvent_InteractionUpdated
err := proto.Unmarshal(evt.GetPayload(), &iu)
require.NoError(t, err)
inte := iu.GetInteraction()
if inte.GetType() == AppMessage_TypeGroupInvitation {
var ginv AppMessage_GroupInvitation
err := proto.Unmarshal(inte.GetPayload(), &ginv)
require.NoError(t, err)
inviteLink = ginv.GetLink()
require.Equal(t, inviteLink, link)
_, err = clients[i].ConversationJoin(ctx, &ConversationJoin_Request{Link: inviteLink})
require.NoError(t, err)
for {
esr, err := stream.Recv()
require.NotEqual(t, err, io.EOF, "EOF while waiting for conversation update after joining one in node %d", i)
require.NoError(t, err)
evt := esr.GetEvent()
if evt.GetType() == StreamEvent_TypeConversationUpdated {
var cu StreamEvent_ConversationUpdated
err := proto.Unmarshal(evt.GetPayload(), &cu)
require.NoError(t, err)
conv := cu.GetConversation()
if conv.GetPublicKey() == gpk && name == conv.GetDisplayName() {
// require.Equal(t, name, conv.GetDisplayName())
require.Equal(t, link, conv.GetLink())
break
}
}
}
}
}
}
}
// FIXME: really wait for everyone to know everyone (via MemberUpdated)
// time.Sleep(time.Second * 20)
// TODO: check that members names are propagated
// Exchange messages
// NOTE: Uncomment when messages exchange is stable
/*for i := 0; i < amount; i++ {
sender := clients[i]
senderStrm := streams[i]
strms := append(streams[0:i:i], streams[i+1:]...)
testMultiMessage(ctx, t, l, "Hello Group! "+strconv.Itoa(i), gpk, sender, senderStrm, strms)
}*/
}
// TODO: implem and test "read" logic
|
package x448
import (
"crypto/rand"
"testing"
"github.com/awnumar/memguard"
"github.com/cloudflare/circl/dh/x448"
"github.com/stretchr/testify/require"
)
func TestX448(t *testing.T) {
alicePrivate, err := memguard.NewBufferFromReader(rand.Reader, x448.Size)
require.NoError(t, err)
var aliceSecret x448.Key
copy(aliceSecret[:], alicePrivate.Bytes())
var alicePublic x448.Key
x448.KeyGen(&alicePublic, &aliceSecret)
bobPrivate, err := memguard.NewBufferFromReader(rand.Reader, x448.Size)
require.NoError(t, err)
var bobSecret x448.Key
copy(bobSecret[:], bobPrivate.Bytes())
var bobPublic x448.Key
x448.KeyGen(&bobPublic, &bobSecret)
// Deriving Alice's shared key
var aliceSharedSecret x448.Key
ok := x448.Shared(&aliceSharedSecret, &aliceSecret, &bobPublic)
require.True(t, ok)
// Deriving Bob's shared key
var bobSharedSecret x448.Key
ok = x448.Shared(&bobSharedSecret, &bobSecret, &alicePublic)
require.True(t, ok)
// Shared secrets are equal, of course.
require.Equal(t, bobSharedSecret, aliceSharedSecret)
}
|
package main
import (
"context"
"fmt"
global "github.com/psinthorn/gostore/global/database"
"go.mongodb.org/mongo-driver/bson"
)
func main() {
fmt.Println("Implement data generator")
// Test connect to MongoDB database
global.DB.Collection("laptop").InsertOne(context.Background(), bson.M{"name": "Dell"})
}
|
package e2e
import (
"bytes"
"context"
"errors"
"fmt"
"net/http"
"os"
"os/exec"
"regexp"
"runtime"
"strings"
"syscall"
"testing"
"time"
)
func AsyncCmdStart(cmd string, timeout time.Duration) (command *exec.Cmd, buffer *bytes.Buffer, ctx context.Context, cancel context.CancelFunc, err error) {
if timeout == 0 {
timeout = 10 * time.Minute
}
ctx, cancel = context.WithTimeout(context.Background(), timeout)
command = exec.CommandContext(ctx, "/bin/bash", "-c", cmd)
buffer = &bytes.Buffer{}
command.Stdout = buffer
command.Stderr = buffer
command.SysProcAttr = &syscall.SysProcAttr{}
command.SysProcAttr.Setsid = true
command.Cancel = func() error {
pgid, err := syscall.Getpgid(command.Process.Pid)
if err == nil {
err = syscall.Kill(-pgid, syscall.SIGKILL)
}
return err
}
err = command.Start()
if err != nil {
return command, buffer, ctx, cancel, err
}
return command, buffer, ctx, cancel, nil
}
func goPrebuild(t *testing.T) {
effect, err := exec.Command("/bin/bash", "-c", "GOOS=linux GOARCH=amd64 go build main.go").CombinedOutput()
if err != nil {
t.Log(effect)
t.Fatal(err)
}
}
func stresstestPrebuild(t *testing.T) {
goPrebuild(t)
effect, err := exec.Command("/bin/bash", "-c", "ops volume create stressdisk -s 32M").CombinedOutput()
if err != nil {
t.Log(effect)
t.Fatal(err)
}
}
func stresstestPostrun(t *testing.T) {
effect, err := exec.Command("/bin/bash", "-c", "ops volume delete stressdisk").CombinedOutput()
if err != nil {
t.Log(effect)
t.Fatal(err)
}
}
func cloudPrebuild(t *testing.T) {
goPrebuild(t)
go func() {
srv := &http.Server{Addr: ":8080"}
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "{ \"VAR1\":\"Hello world!\" }")
srv.Shutdown(context.Background())
})
err := http.ListenAndServe(":8080", nil)
if err != nil {
fmt.Println("Error starting cloud_init server", err)
}
}()
}
func rubyPrebuild(t *testing.T) {
effect, err := exec.Command("/bin/bash", "-c", "mkdir -p .ruby && export GEM_HOME=.ruby && if (gem install --help | grep -q -- \"--no-document\"); then gem install sinatra --no-document; else gem install sinatra --no-rdoc --no-ri; fi").CombinedOutput()
if err != nil {
t.Log(effect)
t.Fatal(err)
}
}
func rustPrebuild(t *testing.T) {
effect, err := exec.Command("/bin/bash", "-c", "rustc http_server.rs -o main").CombinedOutput()
if err != nil {
t.Log(effect)
t.Fatal(err)
}
}
func retryRequest(t *testing.T, request string, attempts int, delay time.Duration) (*http.Response, error) {
resp, err := http.Get(request)
if err == nil {
return resp, nil
}
if !(strings.Contains(err.Error(), "connection reset by peer") ||
strings.Contains(err.Error(), "connection refused") ||
strings.Contains(err.Error(), "EOF")) {
return resp, err
}
if attempts--; attempts > 0 {
time.Sleep(delay)
return retryRequest(t, request, attempts, delay*2)
}
return resp, errors.New("unable to reach server after multiple attempts")
}
func testPackages(t *testing.T) {
var tests = []struct {
name string
pkg string
dir string
request string
elf string
prebuild func(t *testing.T)
postrun func(t *testing.T)
skip bool
nocross bool
data interface{}
}{
{name: "stressdisk", dir: "stressdisk", elf: "main", prebuild: stresstestPrebuild},
{name: "stressdisk_2", dir: "stressdisk", elf: "main", postrun: stresstestPostrun},
{name: "node_alloc", pkg: "eyberg/node:20.5.0", dir: "node_alloc"},
{name: "ruby_alloc", pkg: "eyberg/ruby:3.0.0", dir: "ruby_alloc"},
{name: "python_alloc", pkg: "eyberg/python:3.10.6", dir: "python_alloc"},
{name: "cloud_init", dir: "cloud_init", elf: "main", prebuild: cloudPrebuild},
{name: "python_3.6.7", pkg: "eyberg/python:3.6.7", dir: "python_3.6.7", request: "http://0.0.0.0:8000"},
{name: "node_v11.5.0", pkg: "eyberg/node:v11.5.0", dir: "node_v11.5.0", request: "http://0.0.0.0:8083"},
{name: "nginx_1.15.6", pkg: "eyberg/nginx:1.15.6", dir: "nginx_1.15.6", request: "http://0.0.0.0:8084"},
{name: "php_7.3.5", pkg: "eyberg/php:7.3.5", dir: "php_7.3.5", request: "http://0.0.0.0:9501"},
{name: "ruby_2.5.1", pkg: "eyberg/ruby:2.5.1", dir: "ruby_2.5.1", request: "http://0.0.0.0:4567", prebuild: rubyPrebuild},
{name: "go", dir: "go", request: "http://0.0.0.0:8080", elf: "main", prebuild: goPrebuild},
{name: "rust", dir: "rust", request: "http://0.0.0.0:8080", elf: "main", prebuild: rustPrebuild, nocross: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.skip {
t.Log("Skipping test")
return
}
if tt.nocross {
if runtime.GOOS != "linux" {
t.Log(tt.name, ": no cross compile for", runtime.GOOS, "platform, skipping test")
return
}
}
var execcmd string
dir, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
defer os.Chdir(dir)
err = os.Chdir(dir + "/" + tt.dir)
if err != nil {
t.Fatal(err)
}
if tt.prebuild != nil {
t.Log("Calling prebuild", tt.name)
tt.prebuild(t)
}
if tt.elf != "" {
execcmd = fmt.Sprintf("ops run %s -c config.json --smp %d", tt.elf, runtime.NumCPU())
} else {
execcmd = fmt.Sprintf("ops pkg load %s -c config.json --smp %d", tt.pkg, runtime.NumCPU())
}
timeout := 120 * time.Second
if tt.request != "" {
timeout = 0
}
p, buffer, ctx, _, err := AsyncCmdStart(execcmd, timeout)
if err != nil {
t.Fatal(err)
}
if tt.request == "" {
var re *regexp.Regexp
var rs string
t.Log("Waiting for command to complete...")
ps, err := p.Process.Wait()
r := ps.ExitCode()
if tt.postrun != nil {
t.Log("Calling postrun", tt.name)
tt.postrun(t)
}
if err != nil {
goto fatalrun
}
if ctx.Err() != nil {
err = ctx.Err()
goto fatalrun
}
if r != 0 {
err = fmt.Errorf("ops exit code %d", r)
goto fatalrun
}
re = regexp.MustCompile("exit status [0-9]+")
rs = re.FindString(buffer.String())
if rs == "" || rs != "exit status 1" {
err = errors.New(rs)
goto fatalrun
}
return
fatalrun:
t.Logf("Output: %v", buffer.String())
t.Fatal(err)
} else {
defer p.Cancel()
for count := 0; count <= 5; count++ {
var resp *http.Response
if count == 0 {
resp, err = retryRequest(t, tt.request, 5, time.Second*2)
} else {
resp, err = http.Get(tt.request)
}
if err != nil {
t.Logf("Output: %v", buffer)
t.Fatal(err)
}
t.Log("Status code", resp.StatusCode)
if resp.StatusCode != 200 {
t.Logf("Output: %v", buffer)
t.Fatalf("Expected 200 but got %v", resp.StatusCode)
}
if resp.ContentLength == 0 {
t.Logf("Output: %v", buffer)
t.Fatalf("Received empty content")
}
}
}
})
}
}
// RunE2ETests runs all end to end tests
func RunE2ETests(t *testing.T) {
t.Log("Running E2E test")
t.Run("packages", testPackages)
}
|
/*
_(underscore) in Golang is known as the Blank Identifier.
Identifiers are the user-defined name of the program components used for
the identification purpose. Golang has a special feature to define and use
the unused variable using Blank Identifier.
The real use of Blank Identifier comes when a function returns multiple values,
but we need only a few values and want to discard some values.
Basically, it tells the compiler that this variable is not needed and ignored it without any error.
It hides the variable’s values and makes the program readable. So whenever you will
assign a value to Bank Identifier it becomes unusable.
*/
/*
This program shows the compiler
throws an error if a variable is
declared but not used.
*/
package main
import "fmt"
// Main function
func main() {
// calling the function
// function returns two values which are
// assigned to mul and div identifier.
mul, div := mul_div(105, 7)
// only using the mul variable
// compiler will give an error
fmt.Println("105 x 7 = ", mul)
}
// function returning two
// values of integer type
func mul_div(n1 int, n2 int) (int, int) {
// returning the values
return n1 * n2, n1 / n2
}
/*
In the above program, the function mul_div is returning two values
and we are storing both the values in mul and div identifier.
But in the whole program, we are using only one variable i.e. mul.
So compiler will throw an error div declared and not used.
*/
/*
Let’s make the use of Blank identifier to correct the above program.
Have a look on the program day9.2 for the same.
*/
|
/*
* @lc app=leetcode id=89 lang=golang
*
* [89] Gray Code
*/
func grayCode(n int) []int {
if n == 0 {
return []int{0}
}
ret := []int{0, 1}
for i := 1; i < n; i++ {
l := len(ret)
for j := l - 1; j >= 0; j-- {
ret = append(ret, ret[j]+1<<uint(i))
}
}
return ret
}
|
/*
Copyright 2018-2020 The Nori 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 meta_test
import (
"testing"
enum "github.com/nori-io/common/v5/pkg/domain/enum/meta"
dommeta "github.com/nori-io/common/v5/pkg/domain/meta"
"github.com/nori-io/common/v5/pkg/meta"
"github.com/stretchr/testify/assert"
)
func TestMeta_Interface(t *testing.T) {
a := assert.New(t)
id := meta.ID{
ID: dommeta.PluginID("nori/common"),
Version: "1.0.0",
}
author := meta.Author{
Name: "Nori Developers",
URL: "https://nori.io",
}
dependencies := []dommeta.Dependency{
dommeta.NewInterface("nori/Any", "0.1.0"),
}
description := meta.Description{
Title: "Nori Common",
Description: "Nori common interfaces and data structures",
}
Interface := dommeta.Interface("core/Dummy@0.1.0")
license := []dommeta.License{
meta.License{
Title: "Apache 2.0 License",
Type: enum.Apache2_0,
URL: "http://www.apache.org/licenses/LICENSE-2.0",
},
}
repo := meta.Repository{
Type: enum.Git,
URL: "github.com/nori-io/common",
}
links := []dommeta.Link{
meta.Link{
Title: "github",
URL: "https://github.com/nori-io/common",
},
}
tags := []string{"nori", "common", "test"}
data := meta.Meta{
ID: id,
Author: author,
Dependencies: dependencies,
Description: description,
Interface: Interface,
License: license,
Links: links,
Repository: repo,
Tags: tags,
}
a.Equal(id, data.GetID(), "incorrect ID")
a.Equal(author, data.GetAuthor(), "incorrect Author")
a.Equal(dependencies, data.GetDependencies(), "incorrect Dependencies")
a.Equal(description, data.GetDescription(), "incorrect Description")
a.Equal(Interface, data.GetInterface(), "incorrect Interface")
a.Equal(license, data.GetLicense(), "incorrect License")
a.Equal(links, data.GetLinks(), "incorrect links")
a.Equal(repo, data.GetRepository(), "incorrect repo")
a.Equal(tags, data.GetTags(), "incorrect tags")
}
func TestID_String(t *testing.T) {
a := assert.New(t)
a.Equal("nori/any:1.2.0", meta.ID{
ID: "nori/any",
Version: "1.2.0",
}.String())
a.Equal("nori/any:", meta.ID{
ID: "nori/any",
Version: "",
}.String())
a.Equal("nori/any:word", meta.ID{
ID: "nori/any",
Version: "word",
}.String())
}
func TestID_GetIDAndVersion(t *testing.T) {
a := assert.New(t)
const (
id = dommeta.PluginID("nori/any")
ver = "1.2.0"
)
v := meta.ID{
ID: id,
Version: ver,
}
a.Equal(id, v.GetID())
a.Equal(ver, v.GetVersion())
}
func TestID_GetEmptyVersion(t *testing.T) {
a := assert.New(t)
const (
id = dommeta.PluginID("nori/any")
)
v := meta.ID{
ID: id,
Version: "",
}
a.Equal(id, v.GetID())
a.Equal("", v.GetVersion())
}
func TestAuthor(t *testing.T) {
a := assert.New(t)
const (
name = "nori authors"
url = "https://nori.io"
)
author := meta.Author{
Name: name,
URL: url,
}
a.Equal(name, author.GetName())
a.Equal(url, author.GetURL())
}
func TestDescription(t *testing.T) {
a := assert.New(t)
const (
title = "lorem ipsum"
description = "lorem ipsum dolor sit amet"
)
desc := meta.Description{
Title: title,
Description: description,
}
a.Equal(title, desc.GetTitle())
a.Equal(description, desc.GetDescription())
}
func TestLicense(t *testing.T) {
a := assert.New(t)
const (
title = "license"
typ = enum.Apache2_0
url = "https://example.com/license"
)
desc := meta.License{
Title: title,
Type: typ,
URL: url,
}
a.Equal(title, desc.GetTitle())
a.Equal(typ, desc.GetType())
a.Equal(url, desc.GetURL())
}
func TestLink(t *testing.T) {
a := assert.New(t)
const (
title = "nori official website"
url = "https://nori.io"
)
author := meta.Link{
Title: title,
URL: url,
}
a.Equal(title, author.GetTitle())
a.Equal(url, author.GetURL())
}
func TestRepository(t *testing.T) {
a := assert.New(t)
const (
typ = enum.Git
url = "https://nori.io"
)
author := meta.Repository{
Type: typ,
URL: url,
}
a.Equal(typ, author.GetType())
a.Equal(url, author.GetURL())
}
|
package middleware
import (
"git.dustess.com/mk-base/gin-ext/extend"
"git.dustess.com/mk-training/mk-blog-svc/pkg/common"
"git.dustess.com/mk-training/mk-blog-svc/pkg/user/dao"
"git.dustess.com/mk-training/mk-blog-svc/pkg/user/model"
"github.com/gin-gonic/gin"
"strings"
)
// Authorization 身份认证
func Authorization(c *gin.Context) {
token := c.GetHeader("Authorization")
if token == "" {
c.Abort()
extend.SendUnauthorized(c)
return
}
cache := common.NewCache(common.SessionKey, int64(common.SessionExpired))
var session model.UserSession
err := cache.FindJSON(strings.TrimSpace(token), &session)
if err != nil {
c.Abort()
extend.SendUnauthorized(c)
return
}
m := dao.NewUserDao(c)
user, err := m.FindByID(session.ID)
if err != nil {
c.Abort()
extend.SendUnauthorized(c)
return
}
if user.LogoutAt > session.LoginAt {
c.Abort()
extend.SendUnauthorized(c)
return
}
c.Set(common.SessionHeaderKey, session)
c.Next()
}
|
package main
import (
"fmt"
"strconv"
)
func inputInt(msg string) (value string) {
fmt.Println(msg)
fmt.Scan(&value)
return
}
func main() {
var g int64
var err error
for {
g, err = strconv.ParseInt(inputInt("Enter integer number"), 10, 32)
if err == nil{
break
}
}
if g % 3 == 0 {
fmt.Println("Divided by 3")
} else {
fmt.Println("Not divisible by 3")
}
}
|
package testdata
import (
"github.com/taktakty/netlabi/models"
)
var DeviceModelTestData = []models.DeviceModel{
{
Name: "test name 1",
Height: 1,
Width: 100,
Note: "test note 1",
},
{
Name: "test name 2",
Height: 2,
Width: 100,
Note: "test note 2",
},
{
Name: "test name 3",
Height: 3,
Width: 80,
Note: "test note 3",
},
{
Name: "test name 4",
Height: 4,
Width: 90,
Note: "test note 4",
},
{
Name: "test name 5",
Height: 5,
Width: 100,
Note: "test note 5",
},
{
Name: "test name 6 for search",
Height: 6,
Width: 100,
Note: "test note 6",
},
{
Name: "test name 7 for search",
Height: 7,
Width: 100,
Note: "test note 7",
},
{
Name: "test name 8 for search",
Height: 8,
Width: 90,
Note: "test note 8",
},
{
Name: "test name 9 for device test",
Height: 1,
Width: 100,
Note: "test note 9",
},
}
type DeviceModelParamStruct struct {
Name string
Height int
Width int
Note string
}
type DeviceModelRespStruct struct {
ID string
CreatedAt string
UpdatedAt string
DeletedAt *string
Name string
Height int
Width int
Note string
}
var DeviceModelResp = `{ id createdAt updatedAt deletedAt name height width note }`
|
// DRUNKWATER TEMPLATE(add description and prototypes)
// Question Title and Description on leetcode.com
// Function Declaration and Function Prototypes on leetcode.com
//657. Judge Route Circle
//Initially, there is a Robot at position (0, 0). Given a sequence of its moves, judge if this robot makes a circle, which means it moves back to the original place.
//The move sequence is represented by a string. And each move is represent by a character. The valid robot moves are R (Right), L (Left), U (Up) and D (down). The output should be true or false representing whether the robot makes a circle.
//Example 1:
//Input: "UD"
//Output: true
//Example 2:
//Input: "LL"
//Output: false
//func judgeCircle(moves string) bool {
//}
// Time Is Money |
package main
import (
"context"
pb "example/communication"
"flag"
"fmt"
"log"
"wtypes"
"google.golang.org/grpc"
)
// Define localhost address infomation
const (
dstaddr = "127.0.0.1:6666"
address = "127.0.0.1"
defaultname = "client1"
port = 8888
)
// set ip
var ip = pb.IP{
Addr: address,
Name: defaultname,
Port: port,
}
// Print greet-reply
func printGreetReply(out *pb.GreetReply) {
fmt.Println("~~~~~~~~~ Receive Greet Reply ~~~~~~~~~")
fmt.Println("Reply from: ", out.Ip.GetAddr(), ":", out.Ip.GetPort(), out.Ip.GetName())
fmt.Println("Message: ", out.GetMessage())
}
// Print login-reply
func printAccessReply(out *pb.AccessReply) {
fmt.Println("~~~~~~~~~ Receive Access Reply ~~~~~~~~~")
fmt.Println("Reply from: ", out.Ip.GetAddr(), ":", out.Ip.GetPort(), out.Ip.GetName())
fmt.Println("Message: ", out.GetMessage())
}
func main() {
// Set up a connection with the server.
conn, err := grpc.Dial(dstaddr, grpc.WithInsecure())
if err != nil {
log.Fatalf("Fail to connect: %v", err)
}
// Avoid memory leak.
defer conn.Close()
// Create a client.
c := pb.NewCommunicationClient(conn)
// User defined request
var sendgreet = flag.Bool("sendgreet", false, "(Optional) Whether send greet request or not. -sendgreet=true") // whether send greet request or not
var sendlogin = flag.Bool("sendlogin", false, "(Optional) Whether send login request or not. -sendlogin=true") // whether send login request or not
/*
// Declare the input greetrequest
var id = flag.Uint64("id", 10000, "ID of client. This is valid only when sendgreet field is set true.")
var greetmessage = flag.String("greetmessage", "", "Greet request message. This is valid only when sendgreet field is set true.")
*/
// Declare the input accessreply
var iscn = flag.Bool("iscn", false, "Whether is China or not. This is valid only when sendlogin field is set true.")
var email = flag.String("email", "userexample@qq.com", "Email address. This is valid only when sendlogin field is set true.")
var pwd = flag.String("pwd", "user", "Email password. This is valid only when sendaccess field is set true.")
var floatv = flag.Bool("floatv", false, "input wtypes.Float.valid")
var floatn = flag.Float64("floatn", 0, "input wtypes.Float.val")
var doublev = flag.Bool("doublev", false, "input wtypes.Double.valid")
var doublen = flag.Float64("doublen", 0, "input wtypes.Double.val")
var int64v = flag.Bool("int64v", false, "input wtypes.Int64.valid")
var int64n = flag.Int64("int64n", 0, "input wtypes.Int64.val")
var uint64v = flag.Bool("uint64v", false, "input wtypes.UInt64.valid")
var uint64n = flag.Uint64("uint64n", 0, "input wtypes.UInt64.val")
var int32v = flag.Bool("int32v", false, "input wtypes.Int32.valid")
var int32n = flag.Int("int32n", 0, "input wtypes.Int32.val")
var uint32v = flag.Bool("uint32v", false, "input wtypes.Uint32.valid")
var uint32n = flag.Uint("uint32n", 0, "input wtypes.Uint32.val")
var strv = flag.Bool("strv", false, "input wtypes.String.valid")
var strn = flag.String("strn", "", "input wtypes.String.val")
var bov = flag.Bool("bov", false, "input wtypes.Bool.valid")
var bon = flag.Bool("bon", false, "input wtypes.Bool.val")
var bytesv = flag.Bool("bytesv", false, "input wtypes.Bytes.valid")
var bytesn = flag.String("bytesn", "", "input wtypes.Bytes.val")
// Parse input
flag.Parse()
fmt.Println("=============== Here is", ip.GetName(), "(", ip.GetAddr(), ":", ip.GetPort(), ") ===============")
// Send greet request.
if *sendgreet {
// Greet with the server.
log.Println("********** Send Greet Request **********")
//greetreply, err := c.Greet(context.Background(), &pb.GreetRequest{Id: *id, Ip: &ip, Message: *greetmessage, Num: &wtypes.Double{Valid: *isvalid, Value: *value}})
greetreply, err := c.Greet(context.Background(), &pb.GreetRequest{Doublenum: &wtypes.Double{Valid: *doublev, Value: *doublen}, Floatnum: &wtypes.Float{Valid: *floatv, Value: float32(*floatn)}, Int64Num: &wtypes.Int64{Valid: *int64v, Value: *int64n}, Uint64Num: &wtypes.UInt64{Valid: *uint64v, Value: *uint64n}, Int32Num: &wtypes.Int32{Valid: *int32v, Value: int32(*int32n)}, Uint32Num: &wtypes.UInt32{Valid: *uint32v, Value: uint32(*uint32n)}, Str: &wtypes.String{Valid: *strv, Value: *strn}, Bo: &wtypes.Bool{Valid: *bov, Value: *bon}, B: &wtypes.Bytes{Valid: *bytesv, Value: []byte(*bytesn)}})
// Request failed
if greetreply == nil && err != nil {
log.Fatalf("Please check if the input is valid!%v", err)
}
// Validate GreetReply
if err = greetreply.Validate(); err != nil {
log.Fatalf("GreetReply validate error: %v", err)
}
// Print out the reply from server.
printGreetReply(greetreply)
}
// Send login request.
if *sendlogin {
// SendMessage to server.
log.Println("********** Send Login Request **********")
accessreply, err := c.Login(context.Background(), &pb.AccessRequest{Ip: &ip, IsCN: *iscn, Email: &pb.AccessRequest_Email{Email: *email, Pwd: *pwd}})
// Request failed
if accessreply == nil && err != nil {
log.Fatalf("Please check if the input is valid!\n%v", err)
}
// Validate AccessReply
if err = accessreply.Validate(); err != nil {
log.Fatalf("AccessReply validate error: %v", err)
}
// Print out the reply from server.
printAccessReply(accessreply)
}
}
|
// Copyright 2021 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 placement
import (
"fmt"
"testing"
"github.com/stretchr/testify/require"
)
func TestNewConstraints(t *testing.T) {
_, err := NewConstraints(nil)
require.NoError(t, err)
_, err = NewConstraints([]string{})
require.NoError(t, err)
_, err = NewConstraints([]string{"+zonesh"})
require.ErrorIs(t, err, ErrInvalidConstraintFormat)
_, err = NewConstraints([]string{"+zone=sh", "-zone=sh"})
require.ErrorIs(t, err, ErrConflictingConstraints)
}
func TestAdd(t *testing.T) {
type TestCase struct {
name string
labels Constraints
label Constraint
err error
}
var tests []TestCase
labels, err := NewConstraints([]string{"+zone=sh"})
require.NoError(t, err)
label, err := NewConstraint("-zone=sh")
require.NoError(t, err)
tests = append(tests, TestCase{
"always false match",
labels, label,
ErrConflictingConstraints,
})
labels, err = NewConstraints([]string{"+zone=sh"})
require.NoError(t, err)
label, err = NewConstraint("+zone=sh")
require.NoError(t, err)
tests = append(tests, TestCase{
"duplicated constraints, skip",
labels, label,
nil,
})
tests = append(tests, TestCase{
"duplicated constraints should not stop conflicting constraints check",
append(labels, Constraint{
Op: NotIn,
Key: "zone",
Values: []string{"sh"},
}), label,
ErrConflictingConstraints,
})
labels, err = NewConstraints([]string{"+zone=sh"})
require.NoError(t, err)
tests = append(tests, TestCase{
"invalid label in operand",
labels, Constraint{Op: "["},
nil,
})
tests = append(tests, TestCase{
"invalid label in operator",
Constraints{{Op: "["}}, label,
nil,
})
tests = append(tests, TestCase{
"invalid label in both, same key",
Constraints{{Op: "[", Key: "dc"}}, Constraint{Op: "]", Key: "dc"},
ErrConflictingConstraints,
})
labels, err = NewConstraints([]string{"+zone=sh"})
require.NoError(t, err)
label, err = NewConstraint("-zone=bj")
require.NoError(t, err)
tests = append(tests, TestCase{
"normal",
labels, label,
nil,
})
for _, test := range tests {
err := test.labels.Add(test.label)
comment := fmt.Sprintf("%s: %v", test.name, err)
if test.err == nil {
require.NoError(t, err, comment)
require.Equal(t, test.label, test.labels[len(test.labels)-1], comment)
} else {
require.ErrorIs(t, err, test.err, comment)
}
}
}
func TestRestoreConstraints(t *testing.T) {
type TestCase struct {
name string
input Constraints
output string
err error
}
var tests []TestCase
tests = append(tests, TestCase{
"normal1",
Constraints{},
"",
nil,
})
input1, err := NewConstraint("+zone=bj")
require.NoError(t, err)
input2, err := NewConstraint("-zone=sh")
require.NoError(t, err)
tests = append(tests, TestCase{
"normal2",
Constraints{input1, input2},
`"+zone=bj","-zone=sh"`,
nil,
})
tests = append(tests, TestCase{
"error",
Constraints{{
Op: "[",
Key: "dc",
Values: []string{"dc1"},
}},
"",
ErrInvalidConstraintFormat,
})
for _, test := range tests {
res, err := test.input.Restore()
comment := fmt.Sprintf("%s: %v", test.name, err)
if test.err == nil {
require.NoError(t, err, comment)
require.Equal(t, test.output, res, comment)
} else {
require.ErrorIs(t, err, test.err, comment)
}
}
}
|
// Copyright (c) 2020 Doc.ai and/or its affiliates.
//
// SPDX-License-Identifier: Apache-2.0
//
// 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 vfio_test
import (
"context"
"fmt"
"os"
"path"
"reflect"
"sync"
"testing"
"time"
"github.com/networkservicemesh/api/pkg/api/networkservice"
"github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/cls"
vfioapi "github.com/networkservicemesh/api/pkg/api/networkservice/mechanisms/vfio"
"github.com/networkservicemesh/sdk/pkg/networkservice/core/chain"
"github.com/stretchr/testify/assert"
"github.com/networkservicemesh/sdk-sriov/pkg/networkservice/mechanisms/vfio"
"github.com/networkservicemesh/sdk-sriov/test/stub"
)
const (
clientCgroupDirKey = "clientCgroupDir"
deviceAllowFile = "devices.allow"
deviceDenyFile = "devices.deny"
deviceStringFormat = "c %d:%d rwm"
vfioMajorKey = "vfioMajor"
vfioMinorKey = "vfioMinor"
deviceMajorKey = "deviceMajor"
deviceMinorKey = "deviceMinor"
)
func testConnection() *networkservice.Connection {
return &networkservice.Connection{
Mechanism: &networkservice.Mechanism{
Cls: cls.LOCAL,
Type: vfioapi.MECHANISM,
},
Context: &networkservice.ConnectionContext{
ExtraContext: map[string]string{
clientCgroupDirKey: "",
},
},
}
}
func testVfioServer(ctx context.Context, t *testing.T, allowedDevices *allowedDevices) (server networkservice.NetworkServiceServer, tmpDir string) {
tmpDir = path.Join(os.TempDir(), t.Name())
err := os.MkdirAll(tmpDir, 0750)
assert.Nil(t, err)
server = chain.NewNetworkServiceServer(
vfio.NewServer(tmpDir, tmpDir),
)
err = stub.InputFileAPI(ctx, path.Join(tmpDir, deviceAllowFile), func(s string) {
var major, minor int
_, _ = fmt.Sscanf(s, deviceStringFormat, &major, &minor)
allowedDevices.Lock()
allowedDevices.devices[fmt.Sprintf("%d:%d", major, minor)] = true
allowedDevices.Unlock()
})
assert.Nil(t, err)
err = stub.InputFileAPI(ctx, path.Join(tmpDir, deviceDenyFile), func(s string) {
var major, minor int
_, _ = fmt.Sscanf(s, deviceStringFormat, &major, &minor)
allowedDevices.Lock()
delete(allowedDevices.devices, fmt.Sprintf("%d:%d", major, minor))
allowedDevices.Unlock()
})
assert.Nil(t, err)
return server, tmpDir
}
func TestVfioServer_Close(t *testing.T) {
ctx, cancel := context.WithCancel(context.TODO())
defer cancel()
allowedDevices := &allowedDevices{
devices: map[string]bool{
"1:2": true,
"3:4": true,
},
}
server, tmpDir := testVfioServer(ctx, t, allowedDevices)
defer func() { _ = os.RemoveAll(tmpDir) }()
conn := testConnection()
conn.Mechanism.Parameters = map[string]string{
vfioMajorKey: "1",
vfioMinorKey: "2",
deviceMajorKey: "3",
deviceMinorKey: "4",
}
_, err := server.Close(ctx, conn)
assert.Nil(t, err)
assert.Eventually(t, func() bool {
allowedDevices.Lock()
defer allowedDevices.Unlock()
return reflect.DeepEqual(map[string]bool{}, allowedDevices.devices)
}, time.Second, 10*time.Millisecond)
}
type allowedDevices struct {
devices map[string]bool
sync.Mutex
}
|
package envoy
import (
"bytes"
"crypto/sha256"
"encoding/hex"
"fmt"
"hash"
"io"
"os"
"path/filepath"
"strings"
"sync"
"github.com/pomerium/pomerium/pkg/envoy/files"
)
const (
ownerRX = os.FileMode(0o500)
maxExpandedEnvoySize = 1 << 30
)
type hashReader struct {
hash.Hash
r io.Reader
}
func (hr *hashReader) Read(p []byte) (n int, err error) {
n, err = hr.r.Read(p)
_, _ = hr.Write(p[:n])
return n, err
}
var (
setupLock sync.Mutex
setupDone bool
setupFullEnvoyPath string
setupErr error
)
// Extract extracts envoy binary and returns its location
func Extract() (fullEnvoyPath string, err error) {
setupLock.Lock()
defer setupLock.Unlock()
// if we've extract at least once, and the file we previously extracted no longer exists, force a new extraction
if setupFullEnvoyPath != "" {
if _, err := os.Stat(setupFullEnvoyPath); os.IsNotExist(err) {
setupDone = false
}
}
if setupDone {
return setupFullEnvoyPath, setupErr
}
dir, err := os.MkdirTemp(os.TempDir(), "pomerium-envoy")
if err != nil {
setupErr = fmt.Errorf("envoy: failed making temporary working dir: %w", err)
return
}
setupFullEnvoyPath = filepath.Join(dir, "envoy")
err = extract(setupFullEnvoyPath)
if err != nil {
setupErr = fmt.Errorf("envoy: failed to extract embedded envoy binary: %w", err)
return
}
setupDone = true
return setupFullEnvoyPath, setupErr
}
func extract(dstName string) (err error) {
checksum, err := hex.DecodeString(strings.Fields(files.Checksum())[0])
if err != nil {
return fmt.Errorf("checksum %s: %w", files.Checksum(), err)
}
hr := &hashReader{
Hash: sha256.New(),
r: bytes.NewReader(files.Binary()),
}
dst, err := os.OpenFile(dstName, os.O_CREATE|os.O_WRONLY, ownerRX)
if err != nil {
return err
}
defer func() { err = dst.Close() }()
if _, err = io.Copy(dst, io.LimitReader(hr, maxExpandedEnvoySize)); err != nil {
return err
}
sum := hr.Sum(nil)
if !bytes.Equal(sum, checksum) {
return fmt.Errorf("expected %x, got %x checksum", checksum, sum)
}
return nil
}
|
package semt
import (
"encoding/xml"
"github.com/thought-machine/finance-messaging/iso20022"
)
type Document00300109 struct {
XMLName xml.Name `xml:"urn:iso:std:iso:20022:tech:xsd:semt.003.001.09 Document"`
Message *SecuritiesBalanceAccountingReportV09 `xml:"SctiesBalAcctgRpt"`
}
func (d *Document00300109) AddMessage() *SecuritiesBalanceAccountingReportV09 {
d.Message = new(SecuritiesBalanceAccountingReportV09)
return d.Message
}
// Scope
// An account servicer sends a SecuritiesBalanceAccountingReport to an account owner to provide, at a moment in time, valuations of the portfolio together with details of each financial instrument holding.
// The account servicer/owner relationship may be:
// - an accounting agent acting on behalf of an account owner, or
// - a transfer agent acting on behalf of a fund manager or an account owner's designated agent.
//
// Usage
// The message should be sent at a frequency agreed bi-laterally between the account servicer and the account owner.
// The message can be sent either audited or un-audited and may be provided on a trade date, contractual or settlement date basis.
// This message can only be used to list the holdings of a single (master) account. However, it is possible to break down these holdings into one or several sub-accounts. Therefore, the message can be used to either specify holdings at
// - the main account level, or,
// - the sub-account level.
// This message can be used to report where the financial instruments are safe-kept, physically or notionally. If a security is held in more than one safekeeping place, this can also be indicated.
// The SecuritiesBalanceAccountingReport message should not be used for trading purposes.
// There may be one or more intermediary parties, for example, an intermediary or a concentrator between the account owner and account servicer.
// The message may also be used to:
// - re-send a message previously sent,
// - provide a third party with a copy of a message for information,
// - re-send to a third party a copy of a message for information
// using the relevant elements in the Business Application Header.
type SecuritiesBalanceAccountingReportV09 struct {
// Page number of the message (within a statement) and continuation indicator to indicate that the statement is to continue or that the message is the last page of the statement.
Pagination *iso20022.Pagination `xml:"Pgntn"`
// Provides general information on the report.
StatementGeneralDetails *iso20022.Statement40 `xml:"StmtGnlDtls"`
// Party that legally owns the account.
AccountOwner *iso20022.PartyIdentification98 `xml:"AcctOwnr,omitempty"`
// Party that manages the account on behalf of the account owner, that is manages the registration and booking of entries on the account, calculates balances on the account and provides information about the account.
AccountServicer *iso20022.PartyIdentification100 `xml:"AcctSvcr,omitempty"`
// Account to or from which a securities entry is made.
SafekeepingAccount *iso20022.SecuritiesAccount26 `xml:"SfkpgAcct"`
// Information about the party that provides services relating to financial products to investors, for example, advice on products and placement of orders for the investment fund.
IntermediaryInformation []*iso20022.Intermediary32 `xml:"IntrmyInf,omitempty"`
// Net position of a segregated holding, in a single security, within the overall position held in a securities account.
BalanceForAccount []*iso20022.AggregateBalanceInformation31 `xml:"BalForAcct,omitempty"`
// Sub-account of the safekeeping or investment account.
SubAccountDetails []*iso20022.SubAccountIdentification43 `xml:"SubAcctDtls,omitempty"`
// Total valuation amounts provided in the base currency of the account.
AccountBaseCurrencyTotalAmounts *iso20022.TotalValueInPageAndStatement2 `xml:"AcctBaseCcyTtlAmts,omitempty"`
// Total valuation amounts provided in another currency than the base currency of the account.
AlternateReportingCurrencyTotalAmounts *iso20022.TotalValueInPageAndStatement2 `xml:"AltrnRptgCcyTtlAmts,omitempty"`
}
func (s *SecuritiesBalanceAccountingReportV09) AddPagination() *iso20022.Pagination {
s.Pagination = new(iso20022.Pagination)
return s.Pagination
}
func (s *SecuritiesBalanceAccountingReportV09) AddStatementGeneralDetails() *iso20022.Statement40 {
s.StatementGeneralDetails = new(iso20022.Statement40)
return s.StatementGeneralDetails
}
func (s *SecuritiesBalanceAccountingReportV09) AddAccountOwner() *iso20022.PartyIdentification98 {
s.AccountOwner = new(iso20022.PartyIdentification98)
return s.AccountOwner
}
func (s *SecuritiesBalanceAccountingReportV09) AddAccountServicer() *iso20022.PartyIdentification100 {
s.AccountServicer = new(iso20022.PartyIdentification100)
return s.AccountServicer
}
func (s *SecuritiesBalanceAccountingReportV09) AddSafekeepingAccount() *iso20022.SecuritiesAccount26 {
s.SafekeepingAccount = new(iso20022.SecuritiesAccount26)
return s.SafekeepingAccount
}
func (s *SecuritiesBalanceAccountingReportV09) AddIntermediaryInformation() *iso20022.Intermediary32 {
newValue := new(iso20022.Intermediary32)
s.IntermediaryInformation = append(s.IntermediaryInformation, newValue)
return newValue
}
func (s *SecuritiesBalanceAccountingReportV09) AddBalanceForAccount() *iso20022.AggregateBalanceInformation31 {
newValue := new(iso20022.AggregateBalanceInformation31)
s.BalanceForAccount = append(s.BalanceForAccount, newValue)
return newValue
}
func (s *SecuritiesBalanceAccountingReportV09) AddSubAccountDetails() *iso20022.SubAccountIdentification43 {
newValue := new(iso20022.SubAccountIdentification43)
s.SubAccountDetails = append(s.SubAccountDetails, newValue)
return newValue
}
func (s *SecuritiesBalanceAccountingReportV09) AddAccountBaseCurrencyTotalAmounts() *iso20022.TotalValueInPageAndStatement2 {
s.AccountBaseCurrencyTotalAmounts = new(iso20022.TotalValueInPageAndStatement2)
return s.AccountBaseCurrencyTotalAmounts
}
func (s *SecuritiesBalanceAccountingReportV09) AddAlternateReportingCurrencyTotalAmounts() *iso20022.TotalValueInPageAndStatement2 {
s.AlternateReportingCurrencyTotalAmounts = new(iso20022.TotalValueInPageAndStatement2)
return s.AlternateReportingCurrencyTotalAmounts
}
|
package basic
import "fmt"
func P1() {
var a = 2
var pa = &a
*pa = 3
fmt.Println(a) // 3
}
func Swap(a, b int) (int, int) {
b, a = a, b
return b, a
}
func Swap2(a, b *int) {
*b, *a = *a, *b
}
|
package bitvector
import (
"fmt"
"math"
)
// Len8 is a 8-bit vector
type Len8 uint8
func (bv Len8) String() string {
return fmt.Sprintf("%08b", bv)
}
// Clear bits from index i (included) to index j (excluded)
func (bv Len8) Clear(i, j uint8) Len8 {
if i > j {
return bv
}
return (math.MaxUint8<<j | ((1 << i) - 1)) & bv
}
// Count the number of bits set to 1
func (bv Len8) Count() uint8 {
var count uint8
var index Len8 = 1
var i uint8
for {
if bv&index != 0 {
count++
}
index <<= 1
i++
if i == 8 {
break
}
}
return count
}
// Toggle ith bit
func (bv Len8) Toggle(i uint8) Len8 {
return bv ^ 1<<i
}
// Get ith bit
func (bv Len8) Get(i uint8) bool {
return (bv & (1 << i)) != 0
}
// Set ith bit
func (bv Len8) Set(i uint8, b bool) Len8 {
var value Len8
if b {
value = 1
}
var mask Len8 = ^(1 << i)
return (bv & mask) | (value << i)
}
// And operator
func (bv Len8) And(bv2 Len8) Len8 {
return bv & bv2
}
// Or operator
func (bv Len8) Or(bv2 Len8) Len8 {
return bv | bv2
}
// Xor operator
func (bv Len8) Xor(bv2 Len8) Len8 {
return bv ^ bv2
}
// AndNot operator
func (bv Len8) AndNot(bv2 Len8) Len8 {
return bv &^ bv2
}
// Push left shifts the bits
func (bv Len8) Push(i uint8) Len8 {
return bv << i
}
// Pop right shifts the bits
func (bv Len8) Pop(i uint8) Len8 {
return bv >> i
}
|
/* ######################################################################
# Author: (zfly1207@126.com)
# Created Time: 2020-08-31 20:06:45
# File Name: main.go
# Description:
####################################################################### */
// see: https://github.com/itbdw/ip-database/blob/master/src/IpLocation.php
// see: https://github.com/yinheli/qqwry
/*
use:
func main() {
dat, _ := ioutil.ReadFile("./qqwry.dat")
ip := "112.224.67.58"
r := NewIpParser(ip, dat).Parse()
fmt.Println(fmt.Sprintf("%+v", r))
}
*/
package ip_parser
import (
"encoding/binary"
"fmt"
"net"
"strings"
"github.com/axgle/mahonia"
)
const (
INDEX_LEN = 7
REDIRECT_MODE_1 = 0x01
REDIRECT_MODE_2 = 0x02
)
var (
Provinces = []string{"北京", "天津", "重庆", "上海", "河北", "山西", "辽宁", "吉林", "黑龙江", "江苏", "浙江", "安徽", "福建", "江西", "山东", "河南", "湖北", "湖南", "广东", "海南", "四川", "贵州", "云南", "陕西", "甘肃", "青海", "台湾", "内蒙古", "广西", "宁夏", "新疆", "西藏", "香港", "澳门"}
DirectlyCitys = []string{"北京", "天津", "重庆", "上海"}
ProvincialCapital = map[string]string{
"北京市": "北京市",
"天津市": "天津市",
"重庆市": "重庆市",
"上海市": "上海市",
"河北省": "石家庄市",
"山西省": "太原市",
"辽宁省": "沈阳市",
"吉林省": "长春市",
"黑龙江省": "哈尔滨市",
"江苏省": "南京市",
"浙江省": "杭州市",
"安徽省": "合肥市",
"福建省": "福州市",
"江西省": "南昌市",
"山东省": "济南市",
"河南省": "郑州市",
"湖北省": "武汉市",
"湖南省": "长沙市",
"广东省": "广州市",
"海南省": "海口市",
"四川省": "成都市",
"贵州省": "贵阳市",
"云南省": "昆明市",
"陕西省": "西安市",
"甘肃省": "兰州市",
"青海省": "西宁市",
"台湾省": "台北市",
"内蒙古省": "呼和浩特市",
"广西省": "南宁市",
"宁夏省": "银川市",
"新疆省": "乌鲁木齐市",
"西藏省": "拉萨市",
"香港省": "香港市",
"澳门省": "澳门市"}
Carriers = []string{"联通", "移动", "铁通", "电信", "长城", "聚友"}
)
type Info struct {
Country string
Province string
City string
County string
Area string
Carrier string
}
type IpParser struct {
ip string
dat []byte
ptr uint32
}
func NewIpParser(ip string, dat []byte) *IpParser {
o := &IpParser{ip: ip, dat: dat, ptr: 0}
return o
}
func (this *IpParser) Parse() (r *Info) {
offset := this.search(binary.BigEndian.Uint32(net.ParseIP(this.ip).To4()))
if offset == 0 {
return
}
place, carrier := this.parseQqwry(offset)
r = this.parsePlace(place)
r.Carrier = this.parseCarrier(carrier)
return
}
func (this *IpParser) parseCarrier(carrier string) string {
for _, c := range Carriers {
if idx := strings.Index(carrier, c); idx == -1 {
continue
}
return c
}
return ""
}
func (this *IpParser) parsePlace(place string) (r *Info) {
r = &Info{}
if idx := strings.Index(place, "省"); idx > -1 {
r.Province = fmt.Sprintf("%s省", place[:idx])
place = strings.TrimLeft(place, r.Province)
} else {
for _, province := range Provinces {
if idx := strings.Index(place, province); idx == -1 {
continue
}
isDirectlyCity := false
for _, city := range DirectlyCitys {
if city == province {
isDirectlyCity = true
}
}
if isDirectlyCity == true {
r.Province = fmt.Sprintf("%s市", province)
r.City = r.Province
} else {
r.Province = fmt.Sprintf("%s省", province)
}
place = strings.TrimLeft(place, r.Province)
}
}
if len(r.Province) > 0 {
r.Country = "中国"
} else {
r.Country = place
return
}
if idx := strings.Index(place, "市"); idx > -1 {
r.City = fmt.Sprintf("%s市", place[:idx])
place = strings.TrimLeft(place, r.City)
}
if idx := strings.Index(place, "县"); idx > -1 {
r.County = fmt.Sprintf("%s县", place[:idx])
place = strings.TrimLeft(place, r.County)
}
if idx := strings.Index(place, "区"); idx > -1 {
r.Area = fmt.Sprintf("%s区", place[:idx])
place = strings.TrimLeft(place, r.Area)
}
// Fix lack of city field, using provincial capital fill
if len(r.City) == 0 {
r.City = ProvincialCapital[r.Province]
}
return
}
func (this *IpParser) parseQqwry(offset uint32) (place string, carrier string) {
var placeBytes []byte
var carrierBytes []byte
mode := this.readMode(offset + 4)
switch mode {
case REDIRECT_MODE_1:
placeOffset := this.readUInt24()
mode = this.readMode(placeOffset)
if mode == REDIRECT_MODE_2 {
c := this.readUInt24()
placeBytes = this.readString(c)
placeOffset += 4
} else {
placeBytes = this.readString(placeOffset)
placeOffset += uint32(len(placeBytes) + 1)
}
carrierBytes = this.readCarrier(placeOffset)
case REDIRECT_MODE_2:
placeOffset := this.readUInt24()
placeBytes = this.readString(placeOffset)
carrierBytes = this.readCarrier(offset + 8)
default:
placeBytes = this.readString(offset + 4)
carrierBytes = this.readCarrier(offset + uint32(5+len(placeBytes)))
}
enc := mahonia.NewDecoder("gbk")
place = enc.ConvertString(string(placeBytes))
carrier = enc.ConvertString(string(carrierBytes))
if place == " CZ88.NET" || place == "纯真网络" {
place = ""
}
if carrier == " CZ88.NET" {
carrier = ""
}
return
}
func (this *IpParser) readCarrier(offset uint32) []byte {
mode := this.readMode(offset)
if mode == REDIRECT_MODE_1 || mode == REDIRECT_MODE_2 {
carrierOffset := this.readUInt24()
if carrierOffset == 0 {
return []byte("")
} else {
return this.readString(carrierOffset)
}
} else {
return this.readString(offset)
}
return []byte("")
}
func (this *IpParser) readString(offset uint32) []byte {
data := make([]byte, 0, 30)
for {
this.ptr = offset + 1
buf := this.dat[this.ptr-1 : this.ptr]
if buf[0] == 0 {
break
}
offset++
data = append(data, buf[0])
}
return data
}
func (this *IpParser) readMode(offset uint32) byte {
this.ptr = offset + 1
return this.dat[this.ptr-1 : this.ptr][0]
}
func (this *IpParser) readUInt24() (r uint32) {
this.ptr += 3
return this.byte3ToUInt32(this.dat[this.ptr-3 : this.ptr])
}
func (this *IpParser) search(target uint32) uint32 {
start := binary.LittleEndian.Uint32(this.dat[:4])
end := binary.LittleEndian.Uint32(this.dat[4:8])
for start < end {
mid := (((end-start)/INDEX_LEN)>>1)*INDEX_LEN + start
cur := binary.LittleEndian.Uint32(this.dat[mid : mid+4])
// ??
if start+INDEX_LEN == end {
t := this.byte3ToUInt32(this.dat[mid+4 : mid+INDEX_LEN])
if target < binary.LittleEndian.Uint32(this.dat[mid+INDEX_LEN:mid+INDEX_LEN+4]) {
return t
}
return 0
}
if cur == target {
return this.byte3ToUInt32(this.dat[mid+4 : mid+INDEX_LEN])
}
if cur < target {
start = mid
}
if cur > target {
end = mid
}
}
return 0
}
func (this *IpParser) byte3ToUInt32(data []byte) uint32 {
i := uint32(data[0]) & 0xff
i |= (uint32(data[1]) << 8) & 0xff00
i |= (uint32(data[2]) << 16) & 0xff0000
return i
}
|
package api_test
import (
. "cf/api"
"cf/configuration"
"cf/net"
"encoding/base64"
"fmt"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net/http"
"net/http/httptest"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
)
var _ = Describe("AuthenticationRepository", func() {
It("TestSuccessfullyLoggingIn", func() {
deps := setupAuthDependencies(successfulLoginRequest)
defer teardownAuthDependencies(deps)
auth := NewUAAAuthenticationRepository(deps.gateway, deps.config)
apiResponse := auth.Authenticate(map[string]string{
"username": "foo@example.com",
"password": "bar",
})
Expect(deps.handler.AllRequestsCalled()).To(BeTrue())
Expect(apiResponse.IsError()).To(BeFalse())
Expect(deps.config.AuthorizationEndpoint()).To(Equal(deps.ts.URL))
Expect(deps.config.AccessToken()).To(Equal("BEARER my_access_token"))
Expect(deps.config.RefreshToken()).To(Equal("my_refresh_token"))
})
It("TestUnsuccessfullyLoggingIn", func() {
deps := setupAuthDependencies(unsuccessfulLoginRequest)
defer teardownAuthDependencies(deps)
auth := NewUAAAuthenticationRepository(deps.gateway, deps.config)
apiResponse := auth.Authenticate(map[string]string{
"username": "foo@example.com",
"password": "bar",
})
Expect(deps.handler.AllRequestsCalled()).To(BeTrue())
Expect(apiResponse.IsNotSuccessful()).To(BeTrue())
Expect(apiResponse.Message).To(Equal("Password is incorrect, please try again."))
Expect(deps.config.AccessToken()).To(BeEmpty())
})
It("TestServerErrorLoggingIn", func() {
deps := setupAuthDependencies(errorLoginRequest)
defer teardownAuthDependencies(deps)
auth := NewUAAAuthenticationRepository(deps.gateway, deps.config)
apiResponse := auth.Authenticate(map[string]string{
"username": "foo@example.com",
"password": "bar",
})
Expect(deps.handler.AllRequestsCalled()).To(BeTrue())
Expect(apiResponse.IsError()).To(BeTrue())
Expect(apiResponse.Message).To(Equal("Server error, status code: 500, error code: , message: "))
Expect(deps.config.AccessToken()).To(BeEmpty())
})
It("TestLoggingInWithErrorMaskedAsSuccess", func() {
deps := setupAuthDependencies(errorMaskedAsSuccessLoginRequest)
defer teardownAuthDependencies(deps)
auth := NewUAAAuthenticationRepository(deps.gateway, deps.config)
apiResponse := auth.Authenticate(map[string]string{
"username": "foo@example.com",
"password": "bar",
})
Expect(deps.handler.AllRequestsCalled()).To(BeTrue())
Expect(apiResponse.IsError()).To(BeTrue())
Expect(apiResponse.Message).To(Equal("Authentication Server error: I/O error: uaa.10.244.0.22.xip.io; nested exception is java.net.UnknownHostException: uaa.10.244.0.22.xip.io"))
Expect(deps.config.AccessToken()).To(BeEmpty())
})
})
var authHeaders = http.Header{
"accept": {"application/json"},
"content-type": {"application/x-www-form-urlencoded"},
"authorization": {"Basic " + base64.StdEncoding.EncodeToString([]byte("cf:"))},
}
var successfulLoginRequest = testnet.TestRequest{
Method: "POST",
Path: "/oauth/token",
Header: authHeaders,
Matcher: successfulLoginMatcher,
Response: testnet.TestResponse{
Status: http.StatusOK,
Body: `
{
"access_token": "my_access_token",
"token_type": "BEARER",
"refresh_token": "my_refresh_token",
"scope": "openid",
"expires_in": 98765
} `},
}
var successfulLoginMatcher = func(request *http.Request) {
err := request.ParseForm()
if err != nil {
Fail(fmt.Sprintf("Failed to parse form: %s", err))
return
}
Expect(request.Form.Get("username")).To(Equal("foo@example.com"), "Username did not match.")
Expect(request.Form.Get("password")).To(Equal("bar"), "Password did not match.")
Expect(request.Form.Get("grant_type")).To(Equal("password"), "Grant type did not match.")
Expect(request.Form.Get("scope")).To(Equal(""), "Scope did not mathc.")
}
var unsuccessfulLoginRequest = testnet.TestRequest{
Method: "POST",
Path: "/oauth/token",
Response: testnet.TestResponse{
Status: http.StatusUnauthorized,
},
}
var errorLoginRequest = testnet.TestRequest{
Method: "POST",
Path: "/oauth/token",
Response: testnet.TestResponse{
Status: http.StatusInternalServerError,
},
}
var errorMaskedAsSuccessLoginRequest = testnet.TestRequest{
Method: "POST",
Path: "/oauth/token",
Response: testnet.TestResponse{
Status: http.StatusOK,
Body: `
{"error":{"error":"rest_client_error","error_description":"I/O error: uaa.10.244.0.22.xip.io; nested exception is java.net.UnknownHostException: uaa.10.244.0.22.xip.io"}}
`},
}
type authDependencies struct {
ts *httptest.Server
handler *testnet.TestHandler
config configuration.ReadWriter
gateway net.Gateway
}
func setupAuthDependencies(request testnet.TestRequest) (deps authDependencies) {
deps.ts, deps.handler = testnet.NewTLSServer([]testnet.TestRequest{request})
deps.config = testconfig.NewRepository()
deps.config.SetAuthorizationEndpoint(deps.ts.URL)
deps.gateway = net.NewUAAGateway()
return
}
func teardownAuthDependencies(deps authDependencies) {
deps.ts.Close()
}
|
package main
import "fmt"
func main() {
a := 5
func(a int) {
a = 10
fmt.Println("HI")
}(a)
println(a)
}
|
package main
// 坐标结构体
type Node struct {
x, y int
}
var dx []int // x变化向量
var dy []int // y变化向量
var hasBeenHandled map[int]bool // 用于
// BFS调用者
func orangesRotting(grid [][]int) int {
/* 1. 确定搜索方向dx、dy */
dx = []int{0, 0, 1, -1}
dy = []int{1, -1, 0, 0}
hasBeenHandled = make(map[int]bool)
goodOrangeCount := 0
/* 2. 将需要进行BFS的坐标入队 */
queue := make([]Node, 0)
for i := 0; i < len(grid); i++ {
for t := 0; t < len(grid[i]); t++ {
if grid[i][t] == 2 {
queue = append(queue, Node{i, t})
}
if grid[i][t] == 1 {
goodOrangeCount++
}
}
}
/* 3. 调用BFS函数 */
return BFS(grid, queue, goodOrangeCount)
}
// BFS
func BFS(grid [][]int, queue []Node, goodOrangeCount int) int {
if goodOrangeCount == 0 {
return 0
}
minutes := 0 // 相当于层数
for len(queue) != 0 {
size := len(queue)
for size != 0 {
size--
top := queue[0]
queue = queue[1:]
/* 4. 判断进行BFS的坐标是否符合要求 */
x, y := top.x, top.y
if x < 0 || y < 0 || x >= len(grid) || y >= len(grid[x]) {
continue
}
if hasBeenHandled[hash(x, y)] || grid[x][y] == 0 {
continue
}
/* 5. 对坐标进行标记，防止走回头路 */
hasBeenHandled[hash(x, y)] = true
if grid[x][y] == 1 {
goodOrangeCount--
if goodOrangeCount == 0 {
return minutes
}
}
grid[x][y] = 2
/* 6.遍历所有方向 */
for i := 0; i < len(dx); i++ {
/* 7. 将下一个坐标入队 */
nx, ny := x+dx[i], y+dy[i]
queue = append(queue, Node{nx, ny})
}
}
minutes++
}
return -1
}
// 将坐标(x, y)哈希为一个数字，该数字用于唯一的标识坐标(x, y)
func hash(x, y int) int {
// 具体的哈希取决于题目的x,y的取值范围
return (x << 10) | y
}
/*
题目链接:
https://leetcode-cn.com/problems/rotting-oranges/ 腐烂的橘子
*/
|
package calldiv_test
import (
"testing"
"github.com/b-2019-apt-test/divider/pkg/div/calldiv"
"github.com/b-2019-apt-test/divider/pkg/div/divtest"
)
func TestCasesCallDiv(t *testing.T) {
divtest.Cases(t, calldiv.Divider)
}
func BenchmarkCallDiv(b *testing.B) {
divtest.Benchmark(b, calldiv.Divider)
}
func BenchmarkCallDivParallel(b *testing.B) {
divtest.BenchmarkParallel(b, calldiv.Divider)
}
|
package pgsql
import (
"database/sql"
"database/sql/driver"
"time"
)
// TsRangeFromTimeArray2 returns a driver.Valuer that produces a PostgreSQL tsrange from the given Go [2]time.Time.
func TsRangeFromTimeArray2(val [2]time.Time) driver.Valuer {
return tsRangeFromTimeArray2{val: val}
}
// TsRangeToTimeArray2 returns an sql.Scanner that converts a PostgreSQL tsrange into a Go [2]time.Time and sets it to val.
func TsRangeToTimeArray2(val *[2]time.Time) sql.Scanner {
return tsRangeToTimeArray2{val: val}
}
type tsRangeFromTimeArray2 struct {
val [2]time.Time
}
func (v tsRangeFromTimeArray2) Value() (driver.Value, error) {
// len(`"yyyy-mm-dd hh:mm:ss"`) == 21
size := 3 + (len(v.val) * 21)
out := make([]byte, 2, size)
out[0], out[1] = '[', '"'
out = append(out, v.val[0].Format(timestampLayout)...)
out = append(out, '"', ',', '"')
out = append(out, v.val[1].Format(timestampLayout)...)
out = append(out, '"', ')')
return out, nil
}
type tsRangeToTimeArray2 struct {
val *[2]time.Time
}
func (v tsRangeToTimeArray2) Scan(src interface{}) error {
data, err := srcbytes(src)
if err != nil {
return err
} else if data == nil {
return nil
}
var lo, hi time.Time
elems := pgParseRange(data)
if len(elems[0]) > 0 {
s := elems[0]
s = s[1 : len(s)-1]
if lo, err = time.Parse(timestampLayout, string(s)); err != nil {
return err
}
}
if len(elems[1]) > 0 {
s := elems[1]
s = s[1 : len(s)-1]
if hi, err = time.Parse(timestampLayout, string(s)); err != nil {
return err
}
}
v.val[0] = lo
v.val[1] = hi
return nil
}
|
package pg
import (
"github.com/kyleconroy/sqlc/internal/sql/ast"
)
type AlterOwnerStmt struct {
ObjectType ObjectType
Relation *RangeVar
Object ast.Node
Newowner *RoleSpec
}
func (n *AlterOwnerStmt) Pos() int {
return 0
}
|
/**
*@Author: haoxiongxiao
*@Date: 2019/3/28
*@Description: CREATE GO FILE services
*/
package services
import (
"bysj/models"
"bysj/repositories"
)
type FeedBackService struct {
repo *repositories.FeedBackRepositories
}
func NewFeedBackService() *FeedBackService {
return &FeedBackService{repo: repositories.NewFeedBackRepositories()}
}
func (this *FeedBackService) Create(feedBack *models.FeedBack) error {
return this.repo.Create(feedBack)
}
func (this *FeedBackService) List(result *models.PageFeedBackResult) {
this.repo.List(result)
} |
// Copyright 2019 Kuei-chun Chen. All rights reserved.
package analytics
import (
"time"
"go.mongodb.org/mongo-driver/bson"
)
// DocumentDoc contains db.serverStatus().document
type DocumentDoc struct {
Deleted int `json:"deleted" bson:"deleted"`
Inserted int `json:"inserted" bson:"inserted"`
Returned int `json:"returned" bson:"returned"`
Updated int `json:"updated" bson:"updated"`
}
// ExtraInfoDoc contains db.serverStatus().extra_info
type ExtraInfoDoc struct {
PageFaults uint64 `json:"page_faults" bson:"page_faults"`
}
// GlobalLockSubDoc contains db.serverStatus().globalLockDoc.[activeClients|currentQueue]
type GlobalLockSubDoc struct {
Readers uint64 `json:"readers" bson:"readers"`
Total uint64 `json:"total" bson:"total"`
Writers uint64 `json:"writers" bson:"writers"`
}
// GlobalLockDoc contains db.serverStatus().globalLockDoc
type GlobalLockDoc struct {
ActiveClients GlobalLockSubDoc `json:"activeClients" bson:"activeClients"`
CurrentQueue GlobalLockSubDoc `json:"currentQueue" bson:"currentQueue"`
TotalTime int `json:"totalTime" bson:"totalTime"`
}
// MemDoc containers db.serverStatus().mem
type MemDoc struct {
Resident uint64 `json:"resident" bson:"resident"`
Virtual uint64 `json:"virtual" bson:"virtual"`
}
// MetricsDoc contains db.serverStatus().metrics
type MetricsDoc struct {
Document DocumentDoc `json:"document" bson:"document"`
QueryExecutor QueryExecutorDoc `json:"queryExecutor" bson:"queryExecutor"`
Operation OperationDoc `json:"operation" bson:"operation"`
}
// NetworkDoc contains db.serverStatus().network
type NetworkDoc struct {
BytesIn uint64 `json:"bytesIn" bson:"bytesIn"`
BytesOut uint64 `json:"bytesOut" bson:"bytesOut"`
NumRequests uint64 `json:"numRequests" bson:"numRequests"`
PhysicalBytesIn uint64 `json:"physicalBytesIn" bson:"physicalBytesIn"`
PhysicalBytesOut uint64 `json:"physicalBytesOut" bson:"physicalBytesOut"`
}
// OperationDoc contains db.serverStatus().operation
type OperationDoc struct {
ScanAndOrder uint64 `json:"scanAndOrder" bson:"scanAndOrder"`
WriteConflicts uint64 `json:"writeConflicts" bson:"writeConflicts"`
}
// OpCountersDoc contains db.serverStatus().OpCounters
type OpCountersDoc struct {
Command uint64 `json:"command" bson:"command"`
Delete uint64 `json:"delete" bson:"delete"`
Getmore uint64 `json:"getmore" bson:"getmore"`
Insert uint64 `json:"insert" bson:"insert"`
Query uint64 `json:"query" bson:"query"`
Update uint64 `json:"update" bson:"update"`
}
// OpLatenciesDoc contains db.serverStatus().opLatencies
type OpLatenciesDoc struct {
Commands OpLatenciesOpDoc `json:"commands" bson:"commands"`
Reads OpLatenciesOpDoc `json:"reads" bson:"reads"`
Writes OpLatenciesOpDoc `json:"writes" bson:"writes"`
}
// OpLatenciesOpDoc contains doc of db.serverStatus().opLatencies
type OpLatenciesOpDoc struct {
Latency uint64 `json:"latency" bson:"latency"`
Ops uint64 `json:"ops" bson:"ops"`
}
// QueryExecutorDoc contains db.serverStatus().queryExecutor
type QueryExecutorDoc struct {
Scanned uint64 `json:"scanned" bson:"scanned"`
ScannedObjects uint64 `json:"scannedObjects" bson:"scannedObjects"`
}
// WiredTigerBlockManagerDoc contains db.serverStatus().wiredTiger.cache
type WiredTigerBlockManagerDoc struct {
BytesRead uint64 `json:"bytes read"`
BytesWritten uint64 `json:"bytes written"`
BytesWrittenCheckPoint uint64 `json:"bytes written for checkpoint"`
}
// WiredTigerCacheDoc contains db.serverStatus().wiredTiger.cache
type WiredTigerCacheDoc struct {
BytesReadIntoCache uint64 `json:"bytes read into cache" bson:"bytes read into cache"`
BytesWrittenFromCache uint64 `json:"bytes written from cache" bson:"bytes written from cache"`
CurrentlyInCache uint64 `json:"bytes currently in the cache" bson:"bytes currently in the cache"`
MaxBytesConfigured uint64 `json:"maximum bytes configured" bson:"maximum bytes configured"`
ModifiedPagesEvicted uint64 `json:"modified pages evicted" bson:"modified pages evicted"`
UnmodifiedPagesEvicted uint64 `json:"unmodified pages evicted" bson:"unmodified pages evicted"`
TrackedDirtyBytes uint64 `json:"tracked dirty bytes in the cache" bson:"tracked dirty bytes in the cache"`
}
// WiredTigerDataHandleDoc contains db.serverStatus().wiredTiger.data-handle
type WiredTigerDataHandleDoc struct {
Active uint64 `json:"connection data handles currently active" bson:"connection data handles currently active"`
Size uint64 `json:"connection data handle size" bson:"connection data handle size"`
}
// ConcurrentTransactionsCountDoc contains db.serverStatus().wiredTiger.concurrentTransactions.[read|write]
type ConcurrentTransactionsCountDoc struct {
Available uint64 `json:"available" bson:"available"`
Out uint64 `json:"out" bson:"out"`
TotalTickets uint64 `json:"totalTickets" bson:"totalTickets"`
}
// ConcurrentTransactionsDoc contains db.serverStatus().wiredTiger.concurrentTransactions
type ConcurrentTransactionsDoc struct {
Read ConcurrentTransactionsCountDoc `json:"read" bson:"read"`
Write ConcurrentTransactionsCountDoc `json:"write" bson:"write"`
}
// WiredTigerDoc contains db.serverStatus().wiredTiger
type WiredTigerDoc struct {
Perf interface{} `json:"perf" bson:"perf"`
BlockManager WiredTigerBlockManagerDoc `json:"block-manager" bson:"block-manager"`
Cache WiredTigerCacheDoc `json:"cache" bson:"cache"`
ConcurrentTransactions ConcurrentTransactionsDoc `json:"concurrentTransactions" bson:"concurrentTransactions"`
DataHandle WiredTigerDataHandleDoc `json:"data-handle" bson:"data-handle"`
}
// ConnectionsDoc contains db.serverStatus().connections
type ConnectionsDoc struct {
Current uint64 `json:"current" bson:"current"`
Available uint64 `json:"available" bson:"available"`
TotalCreated uint64 `json:"totalCreated" bson:"totalCreated"`
Active uint64 `json:"active" bson:"active"`
}
// ServerStatusDoc contains docs from db.serverStatus()
type ServerStatusDoc struct {
Connections ConnectionsDoc `json:"connections" bson:"connections"`
ExtraInfo ExtraInfoDoc `json:"extra_info" bson:"extra_info"`
GlobalLock GlobalLockDoc `json:"globalLock" bson:"globalLock"`
Host string `json:"host" bson:"host"`
LocalTime time.Time `json:"localTime" bson:"localTime"`
Mem MemDoc `json:"mem" bson:"mem"`
Metrics MetricsDoc `json:"metrics" bson:"metrics"`
Network NetworkDoc `json:"network" bson:"network"`
OpCounters OpCountersDoc `json:"opcounters" bson:"opcounters"`
OpLatencies OpLatenciesDoc `json:"opLatencies" bson:"opLatencies"`
Process string `json:"process" bson:"process"`
Repl bson.M `json:"repl" bson:"repl"`
Sharding bson.M `json:"sharding" bson:"sharding"`
Uptime uint64 `json:"uptime" bson:"uptime"`
Version string `json:"version" bson:"version"`
WiredTiger WiredTigerDoc `json:"wiredTiger" bson:"wiredTiger"`
}
|
package models
import (
"github.com/astaxie/beego/orm"
"time"
)
func (a *FinancialProfit) TableName() string {
return FinancialProfitTBName()
}
//查询的类
type FinancialProfitQueryParam struct {
BaseQueryParam
Name string `json:"name"`
StartTime int64 `json:"startTime"` //开始时间
EndTime int64 `json:"endTime"` //截止时间
OrderId string `json:"orderId"` //订单号
Status string `json:"status"` //状态
Category string `json:"category"`
}
//理财收益表
type FinancialProfit struct {
Id int `orm:"pk;column(id)"json:"id"form:"id"`
//用户id
User *TokenskyUser `orm:"rel(fk);column(user_id)"json:"-"form:"-"`
UserId int `orm:"-"json:"userId"form:"userId"`
//配置表id
ProductId int `orm:"column(product_id)"json:"productId"form:"productId"`
//类型 1活期 2定期
Category int `orm:"column(category)"json:"category"form:"category"`
//关联id
RelevanceId int `orm:"column(relevance_id)"json:"relevanceId"form:"relevanceId"`
//子类 live 活期 dead 定期 withdrawal 提前取出
Product string `orm:"column(product)"json:"product"form:"product"`
//货币类x型
Symbol string `orm:"column(symbol)"json:"symbol"form:"symbol"`
//资产数量
Balance float64 `orm:"column(balance)"json:"balance"form:"balance"`
//支付资产
PayBalance float64 `orm:"column(pay_balance)"json:"payBalance"form:"payBalance"`
//年化利率
YearProfit float64 `orm:"column(year_profit)"json:"yearProfit"form:"yearProfit"`
//收益
Profit float64 `orm:"column(profit)"json:"profit"form:"profit"`
//收益日期
IsDate time.Time `orm:"type(date);column(is_date)"json:"isDate"form:"isDate"`
//创建时间
CreateTime time.Time `orm:"auto_now_add;type(datetime);column(create_time)"json:"createTime"form:"createTime"`
//状态 0收益未发放 1收益已发放
Status int `orm:"column(status)"json:"status"form:"status"`
//
Name string `orm:"-"json:"name"form:"name"`
}
func FinancialProfitPageList(params *FinancialProfitQueryParam) ([]*FinancialProfit, int64) {
o := orm.NewOrm()
query := o.QueryTable(FinancialProfitTBName())
data := make([]*FinancialProfit, 0)
//默认排序
sortorder := "id"
switch params.Sort {
case "id":
sortorder = "id"
}
if params.Order == "desc" {
sortorder = "-" + sortorder
}
//姓名
if params.Name != ""{
query = query.Filter("User__nick_name__exact",params.Name)
}
//订单号
if params.OrderId != ""{
query = query.Filter("financial_order_id__exact",params.OrderId)
}
if params.Category != ""{
query = query.Filter("category__exact",params.Category)
}
//时间段
if params.StartTime > 0 {
query = query.Filter("is_date__gte", time.Unix(params.StartTime, 0))
}
if params.EndTime > 0 {
query = query.Filter("is_date__lte", time.Unix(params.EndTime, 0))
}
total, _ := query.Count()
query.OrderBy(sortorder).Limit(params.Limit, (params.Offset-1)*params.Limit).RelatedSel().All(&data)
for _,obj := range data{
if obj.User != nil{
obj.UserId = obj.User.UserId
obj.Name = obj.User.NickName
}
}
return data, total
}
|
package efclient
import (
"bytes"
"encoding/json"
"fmt"
"log"
"net/http"
"sync"
"time"
"syreclabs.com/go/faker"
"syreclabs.com/go/faker/locales"
)
// User ...
type User struct {
ID int `json:"id"`
Username string `json:"username"`
Email string `json:"email"`
Provider string `json:"provider"`
Password string `json:"password"`
ResetPasswordToken string `json:"resetPasswordToken"`
Confirmed bool `json:"confirmed"`
Blocked bool `json:"blocked"`
Role string `json:"role"`
Counterparties json.RawMessage `json:"counterparties"`
Phone string `json:"phone"`
}
// UserData ...
type UserData struct {
Username string `json:"username"`
Email string `json:"email"`
Password string `json:"password"`
Phone string `json:"phone"`
}
// CreateUser ...
func (c *Client) CreateUser(userData *UserData) (*User, error) {
requestData := map[string]interface{}{
"username": &userData.Username,
"email": &userData.Email,
"password": &userData.Password,
"phone": &userData.Phone,
}
requestBody, err := json.Marshal(requestData)
if err != nil {
return nil, err
}
req, err := http.NewRequest("POST", fmt.Sprintf("%s/auth/local/register", c.BaseURL), bytes.NewBuffer(requestBody))
if err != nil {
return nil, err
}
var res User
if err := c.SendRequest(req, &res); err != nil {
return nil, err
}
return &res, nil
}
// CreateFakeUsers ...
func (c *Client) CreateFakeUsers(wg *sync.WaitGroup, count int) int {
faker.Locale = locales.Ru
ch := make(chan int, count)
ch <- 0
for i := 0; i < count; i++ {
wg.Add(1)
time.Sleep(time.Millisecond * 50)
go func(wg *sync.WaitGroup) {
defer wg.Done()
fakeUser := UserData{
Username: faker.Internet().UserName(),
Email: faker.Internet().Email(),
Password: "password",
Phone: "+7" + faker.PhoneNumber().String(),
}
log.Println(fakeUser)
_, err := c.CreateUser(&fakeUser)
if err != nil {
log.Print(fmt.Errorf("%v", err))
// log.Fatal(err)
} else {
counter := <-ch
ch <- counter + 1
}
}(wg)
}
wg.Wait()
close(ch)
return <-ch
}
|
package uuid
import (
"os"
uuid "github.com/nu7hatch/gouuid"
"github.com/sapk/sca/pkg/model"
log "github.com/sirupsen/logrus"
"github.com/spf13/pflag"
)
//ModuleID define the id of module
const ModuleID = "UUID"
var argUUID string
//Module retrieve information form executing sca
type Module struct {
UUID string
}
//Response describe collector informations
type Response string
//Flags set for Module
func Flags() *pflag.FlagSet {
fSet := pflag.NewFlagSet(ModuleID, pflag.ExitOnError)
fSet.StringVar(&argUUID, "uuid", "", "uuid to use by this collector")
return fSet
}
//New constructor for Module
func New(options map[string]string) model.Module {
log.WithFields(log.Fields{
"id": ModuleID,
"options": options,
}).Debug("Creating new Module")
if argUUID == "" {
hostname, err := os.Hostname()
if err != nil {
log.WithFields(log.Fields{
"hostname": hostname,
"err": err,
}).Warn("Failed to retrieve hostname")
}
u5, err := uuid.NewV5(uuid.NamespaceURL, []byte(hostname)) //TODO better discriminate maybe add time and save it in /etc/sca/uuid ?
if err != nil {
log.WithFields(log.Fields{
"uuid": u5,
"err": err,
}).Fatal("Failed to generate uuid")
}
argUUID = u5.String()
}
return &Module{UUID: argUUID}
}
//ID //TODO
func (m *Module) ID() string {
return ModuleID
}
//Event return event chan
func (m *Module) Event() <-chan string {
return nil
}
//GetData //TODO
func (m *Module) GetData() interface{} {
return m.UUID
}
|
package main
import (
"flag"
"fmt"
"log"
"os"
"os/signal"
"path/filepath"
"strconv"
"strings"
"syscall"
"github.com/allan-simon/go-singleinstance"
"github.com/dlasky/gotk3-layershell/layershell"
"github.com/gotk3/gotk3/gdk"
"github.com/gotk3/gotk3/glib"
"github.com/gotk3/gotk3/gtk"
)
const version = "0.1.2"
var (
appDirs []string
configDirectory string
pinnedFile string
pinned []string
oldTasks []task
mainBox *gtk.Box
src glib.SourceHandle
refresh bool // we will use this to trigger rebuilding mainBox
outerOrientation, innerOrientation gtk.Orientation
widgetAnchor, menuAnchor gdk.Gravity
imgSizeScaled int
currentWsNum, targetWsNum int64
dockWindow *gtk.Window
)
// Flags
var cssFileName = flag.String("s", "style.css", "Styling: css file name")
var targetOutput = flag.String("o", "", "name of Output to display the dock on")
var displayVersion = flag.Bool("v", false, "display Version information")
var autohide = flag.Bool("d", false, "auto-hiDe: show dock when hotspot hovered, close when left or a button clicked")
var full = flag.Bool("f", false, "take Full screen width/height")
var numWS = flag.Int64("w", 8, "number of Workspaces you use")
var position = flag.String("p", "bottom", "Position: \"bottom\", \"top\" or \"left\"")
var exclusive = flag.Bool("x", false, "set eXclusive zone: move other windows aside; overrides the \"-l\" argument")
var imgSize = flag.Int("i", 48, "Icon size")
var layer = flag.String("l", "overlay", "Layer \"overlay\", \"top\" or \"bottom\"")
var launcherCmd = flag.String("c", "nwggrid -p", "Command assigned to the launcher button")
var alignment = flag.String("a", "center", "Alignment in full width/height: \"start\", \"center\" or \"end\"")
var marginTop = flag.Int("mt", 0, "Margin Top")
var marginLeft = flag.Int("ml", 0, "Margin Left")
var marginRight = flag.Int("mr", 0, "Margin Right")
var marginBottom = flag.Int("mb", 0, "Margin Bottom")
func buildMainBox(tasks []task, vbox *gtk.Box) {
mainBox.Destroy()
mainBox, _ = gtk.BoxNew(innerOrientation, 0)
if *alignment == "start" {
vbox.PackStart(mainBox, false, true, 0)
} else if *alignment == "end" {
vbox.PackEnd(mainBox, false, true, 0)
} else {
vbox.PackStart(mainBox, true, false, 0)
}
var err error
pinned, err = loadTextFile(pinnedFile)
if err != nil {
pinned = nil
}
var allItems []string
for _, cntPin := range pinned {
if !isIn(allItems, cntPin) {
allItems = append(allItems, cntPin)
}
}
for _, cntTask := range tasks {
if !isIn(allItems, cntTask.ID) && !strings.Contains(*launcherCmd, cntTask.ID) {
allItems = append(allItems, cntTask.ID)
}
}
// scale icons down when their number increases
if *imgSize*6/(len(allItems)) < *imgSize {
overflow := (len(allItems) - 6) / 3
imgSizeScaled = *imgSize * 6 / (6 + overflow)
} else {
imgSizeScaled = *imgSize
}
var alreadyAdded []string
for _, pin := range pinned {
if !inTasks(tasks, pin) {
button := pinnedButton(pin)
mainBox.PackStart(button, false, false, 0)
} else {
instances := taskInstances(pin, tasks)
task := instances[0]
if len(instances) == 1 {
button := taskButton(task, instances)
mainBox.PackStart(button, false, false, 0)
} else if !isIn(alreadyAdded, task.ID) {
button := taskButton(task, instances)
mainBox.PackStart(button, false, false, 0)
alreadyAdded = append(alreadyAdded, task.ID)
taskMenu(task.ID, instances)
} else {
continue
}
}
}
alreadyAdded = nil
for _, task := range tasks {
// nwggrid is the default launcher, we don't want to see it as a task
if !inPinned(task.ID) && task.ID != "nwggrid" {
instances := taskInstances(task.ID, tasks)
if len(instances) == 1 {
button := taskButton(task, instances)
mainBox.PackStart(button, false, false, 0)
} else if !isIn(alreadyAdded, task.ID) {
button := taskButton(task, instances)
mainBox.PackStart(button, false, false, 0)
alreadyAdded = append(alreadyAdded, task.ID)
taskMenu(task.ID, instances)
} else {
continue
}
}
}
wsButton, _ := gtk.ButtonNew()
wsImage, err := createImage(fmt.Sprintf("/usr/share/nwg-dock/images/%v.svg", currentWsNum), imgSizeScaled)
if err == nil {
wsButton.SetImage(wsImage)
wsButton.SetAlwaysShowImage(true)
wsButton.AddEvents(int(gdk.SCROLL_MASK))
wsButton.Connect("clicked", func() {
focusWorkspace(targetWsNum)
})
wsButton.Connect("enter-notify-event", cancelClose)
wsButton.Connect("scroll-event", func(btn *gtk.Button, e *gdk.Event) bool {
event := gdk.EventScrollNewFromEvent(e)
if event.Direction() == gdk.SCROLL_UP {
if targetWsNum < *numWS && targetWsNum < 20 {
targetWsNum++
} else {
targetWsNum = 1
}
pixbuf, _ := gdk.PixbufNewFromFileAtSize(fmt.Sprintf("/usr/share/nwg-dock/images/%v.svg",
targetWsNum), imgSizeScaled, imgSizeScaled)
wsImage.SetFromPixbuf(pixbuf)
return true
} else if event.Direction() == gdk.SCROLL_DOWN {
if targetWsNum > 1 {
targetWsNum--
} else {
targetWsNum = *numWS
}
pixbuf, _ := gdk.PixbufNewFromFileAtSize(fmt.Sprintf("/usr/share/nwg-dock/images/%v.svg",
targetWsNum), imgSizeScaled, imgSizeScaled)
wsImage.SetFromPixbuf(pixbuf)
return true
}
return false
})
}
mainBox.PackStart(wsButton, false, false, 0)
button, _ := gtk.ButtonNew()
image, err := createImage("/usr/share/nwg-dock/images/grid.svg", imgSizeScaled)
if err == nil {
button.SetImage(image)
button.SetAlwaysShowImage(true)
button.Connect("clicked", func() {
launch(*launcherCmd)
})
button.Connect("enter-notify-event", cancelClose)
}
mainBox.PackStart(button, false, false, 0)
mainBox.ShowAll()
}
func setupHotSpot(monitor gdk.Monitor, dockWindow *gtk.Window) gtk.Window {
w, h := dockWindow.GetSize()
win, _ := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
layershell.InitForWindow(win)
layershell.SetMonitor(win, &monitor)
box, _ := gtk.BoxNew(gtk.ORIENTATION_HORIZONTAL, 0)
win.Add(box)
win.Connect("enter-notify-event", func() {
layershell.SetMonitor(dockWindow, &monitor)
dockWindow.Hide()
dockWindow.Show()
})
if *position == "bottom" || *position == "top" {
win.SetSizeRequest(w, 10)
if *position == "bottom" {
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_BOTTOM, true)
} else {
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_TOP, true)
}
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_LEFT, *full)
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_RIGHT, *full)
}
if *position == "left" {
win.SetSizeRequest(10, h)
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_LEFT, true)
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_TOP, *full)
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_BOTTOM, *full)
}
layershell.SetLayer(win, layershell.LAYER_SHELL_LAYER_TOP)
layershell.SetMargin(win, layershell.LAYER_SHELL_EDGE_TOP, *marginTop)
layershell.SetMargin(win, layershell.LAYER_SHELL_EDGE_LEFT, *marginLeft)
layershell.SetMargin(win, layershell.LAYER_SHELL_EDGE_RIGHT, *marginRight)
layershell.SetMargin(win, layershell.LAYER_SHELL_EDGE_BOTTOM, *marginBottom)
layershell.SetExclusiveZone(win, -1)
return *win
}
func main() {
flag.Parse()
if *displayVersion {
fmt.Printf("nwg-dock version %s\n", version)
os.Exit(0)
}
// Gentle SIGTERM handler thanks to reiki4040 https://gist.github.com/reiki4040/be3705f307d3cd136e85
signalChan := make(chan os.Signal, 1)
signal.Notify(signalChan, syscall.SIGTERM)
go func() {
for {
s := <-signalChan
if s == syscall.SIGTERM {
println("SIGTERM received, bye bye!")
gtk.MainQuit()
}
}
}()
// Unless we are in autohide mode, we probably want the same key/mouse binding to turn the dock off.
// Kill the running instance and exit.
lockFilePath := fmt.Sprintf("%s/nwg-dock.lock", tempDir())
lockFile, err := singleinstance.CreateLockFile(lockFilePath)
if err != nil {
pid, err := readTextFile(lockFilePath)
if err == nil {
i, err := strconv.Atoi(pid)
if err == nil {
if !*autohide {
println("Running instance found, sending SIGTERM and exiting...")
syscall.Kill(i, syscall.SIGTERM)
} else {
println("Already running")
}
}
}
os.Exit(0)
}
defer lockFile.Close()
configDirectory = configDir()
// if doesn't exist:
createDir(configDirectory)
if !pathExists(fmt.Sprintf("%s/style.css", configDirectory)) {
copyFile("/usr/share/nwg-dock/style.css", fmt.Sprintf("%s/style.css", configDirectory))
}
cacheDirectory := cacheDir()
if cacheDirectory == "" {
log.Panic("Couldn't determine cache directory location")
}
pinnedFile = filepath.Join(cacheDirectory, "nwg-dock-pinned")
cssFile := filepath.Join(configDirectory, *cssFileName)
appDirs = getAppDirs()
gtk.Init(nil)
cssProvider, _ := gtk.CssProviderNew()
err = cssProvider.LoadFromPath(cssFile)
if err != nil {
fmt.Printf("%s file not found, using GTK styling\n", cssFile)
} else {
fmt.Printf("Using style: %s\n", cssFile)
screen, _ := gdk.ScreenGetDefault()
gtk.AddProviderForScreen(screen, cssProvider, gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
}
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if err != nil {
log.Fatal("Unable to create window:", err)
}
dockWindow = win
layershell.InitForWindow(win)
var output2mon map[string]*gdk.Monitor
if *targetOutput != "" {
// We want to assign layershell to a monitor, but we only know the output name!
output2mon, err = mapOutputs()
if err == nil {
layershell.SetMonitor(win, output2mon[*targetOutput])
} else {
println(err)
}
}
if *exclusive {
layershell.AutoExclusiveZoneEnable(win)
*layer = "top"
}
if *position == "bottom" || *position == "top" {
if *position == "bottom" {
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_BOTTOM, true)
widgetAnchor = gdk.GDK_GRAVITY_NORTH
menuAnchor = gdk.GDK_GRAVITY_SOUTH
} else {
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_TOP, true)
widgetAnchor = gdk.GDK_GRAVITY_SOUTH
menuAnchor = gdk.GDK_GRAVITY_NORTH
}
outerOrientation = gtk.ORIENTATION_VERTICAL
innerOrientation = gtk.ORIENTATION_HORIZONTAL
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_LEFT, *full)
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_RIGHT, *full)
}
if *position == "left" {
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_LEFT, true)
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_TOP, *full)
layershell.SetAnchor(win, layershell.LAYER_SHELL_EDGE_BOTTOM, *full)
outerOrientation = gtk.ORIENTATION_HORIZONTAL
innerOrientation = gtk.ORIENTATION_VERTICAL
widgetAnchor = gdk.GDK_GRAVITY_EAST
menuAnchor = gdk.GDK_GRAVITY_WEST
}
if *autohide {
// we need to cover the hotspot window, to avoid unwanted .Hide() and .Show() the dockWindow
layershell.SetLayer(win, layershell.LAYER_SHELL_LAYER_OVERLAY)
layershell.SetExclusiveZone(win, -1)
} else {
// otherwise let's leave users freedom of choice
if *layer == "top" {
layershell.SetLayer(win, layershell.LAYER_SHELL_LAYER_TOP)
} else if *layer == "bottom" {
layershell.SetLayer(win, layershell.LAYER_SHELL_LAYER_BOTTOM)
} else {
layershell.SetLayer(win, layershell.LAYER_SHELL_LAYER_OVERLAY)
layershell.SetExclusiveZone(win, -1)
}
}
layershell.SetMargin(win, layershell.LAYER_SHELL_EDGE_TOP, *marginTop)
layershell.SetMargin(win, layershell.LAYER_SHELL_EDGE_LEFT, *marginLeft)
layershell.SetMargin(win, layershell.LAYER_SHELL_EDGE_RIGHT, *marginRight)
layershell.SetMargin(win, layershell.LAYER_SHELL_EDGE_BOTTOM, *marginBottom)
win.Connect("destroy", func() {
gtk.MainQuit()
})
// Close the window on leave, but not immediately, to avoid accidental closes
win.Connect("leave-notify-event", func() {
if *autohide {
src, err = glib.TimeoutAdd(uint(1000), func() bool {
win.Hide()
src = 0
return false
})
}
})
win.Connect("enter-notify-event", func() {
cancelClose()
})
outerBox, _ := gtk.BoxNew(outerOrientation, 0)
outerBox.SetProperty("name", "box")
win.Add(outerBox)
alignmentBox, _ := gtk.BoxNew(innerOrientation, 0)
outerBox.PackStart(alignmentBox, true, true, 0)
mainBox, _ = gtk.BoxNew(innerOrientation, 0)
// We'll pack mainBox later, in buildMainBox
tasks, err := listTasks()
if err != nil {
log.Fatal("Couldn't list tasks:", err)
}
oldTasks = tasks
var oldWsNum int64
buildMainBox(tasks, alignmentBox)
glib.TimeoutAdd(uint(150), func() bool {
currentTasks, _ := listTasks()
if len(currentTasks) != len(oldTasks) || currentWsNum != oldWsNum || refresh {
println("refreshing...")
buildMainBox(currentTasks, alignmentBox)
oldTasks = currentTasks
oldWsNum = currentWsNum
targetWsNum = currentWsNum
refresh = false
}
return true
})
win.ShowAll()
if *autohide {
win.Hide()
mRefProvider, _ := gtk.CssProviderNew()
if err := mRefProvider.LoadFromPath("/usr/share/nwg-dock/hotspot.css"); err != nil {
println(err)
}
if *targetOutput == "" {
// hot spots on all displays
monitors, _ := listMonitors()
for _, monitor := range monitors {
win := setupHotSpot(monitor, win)
context, _ := win.GetStyleContext()
context.AddProvider(mRefProvider, gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
win.ShowAll()
}
} else {
// hot spot on the selected display only
monitor, _ := output2mon[*targetOutput]
win := setupHotSpot(*monitor, win)
context, _ := win.GetStyleContext()
context.AddProvider(mRefProvider, gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
win.ShowAll()
}
}
gtk.Main()
}
|
package pgsql
// PostgreSQL `tsquery` read/write natively supported with:
// `string`
// `[]byte`
type _ native
|
package comparisons
import (
"instructions/base"
"rtda"
)
// IFEQ Branch if int comparison with zero succeeds
/**
if<cond>指令把操作数栈顶的int变量弹出，然后跟0进行比较，
满足条件则跳转。假设从栈顶弹出的变量是x，则指令执行跳转操
作的条件如下：
·ifeq ： x==0
·ifne ： x！=0
·iflt ： x<0
·ifle ： x<=0·ifgt：x>0
·ifge ： x>=0
由于比较指令最终表现为跳转指令。故继承 base.BranchInstruction
*/
type IFEQ struct{ base.BranchInstruction }
func (self *IFEQ) Execute(frame *rtda.Frame) {
val := frame.OperandStack().PopInt()
if val == 0 {
base.Branch(frame, self.Offset)
}
}
type IFNE struct{ base.BranchInstruction }
func (self *IFNE) Execute(frame *rtda.Frame) {
val := frame.OperandStack().PopInt()
if val != 0 {
base.Branch(frame, self.Offset)
}
}
type IFLT struct{ base.BranchInstruction }
func (self *IFLT) Execute(frame *rtda.Frame) {
val := frame.OperandStack().PopInt()
if val < 0 {
base.Branch(frame, self.Offset)
}
}
type IFLE struct{ base.BranchInstruction }
func (self *IFLE) Execute(frame *rtda.Frame) {
val := frame.OperandStack().PopInt()
if val <= 0 {
base.Branch(frame, self.Offset)
}
}
type IFGT struct{ base.BranchInstruction }
func (self *IFGT) Execute(frame *rtda.Frame) {
val := frame.OperandStack().PopInt()
if val > 0 {
base.Branch(frame, self.Offset)
}
}
type IFGE struct{ base.BranchInstruction }
func (self *IFGE) Execute(frame *rtda.Frame) {
val := frame.OperandStack().PopInt()
if val >= 0 {
base.Branch(frame, self.Offset)
}
}
|
// All Rights Reserved.
//
// 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 v20180411
import (
"github.com/tencentyun/tcecloud-sdk-go/tcecloud/common"
tchttp "github.com/tencentyun/tcecloud-sdk-go/tcecloud/common/http"
"github.com/tencentyun/tcecloud-sdk-go/tcecloud/common/profile"
)
const APIVersion = "2018-04-11"
type Client struct {
common.Client
}
// Deprecated
func NewClientWithSecretId(secretId, secretKey, region string) (client *Client, err error) {
cpf := profile.NewClientProfile()
client = &Client{}
client.Init(region).WithSecretId(secretId, secretKey).WithProfile(cpf)
return
}
func NewClient(credential *common.Credential, region string, clientProfile *profile.ClientProfile) (client *Client, err error) {
client = &Client{}
client.Init(region).
WithCredential(credential).
WithProfile(clientProfile)
return
}
func NewActiveHourDCDBInstanceRequest() (request *ActiveHourDCDBInstanceRequest) {
request = &ActiveHourDCDBInstanceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "ActiveHourDCDBInstance")
return
}
func NewActiveHourDCDBInstanceResponse() (response *ActiveHourDCDBInstanceResponse) {
response = &ActiveHourDCDBInstanceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（ActiveHourDCDBInstance）用于恢复按量计费DCDB实例。
func (c *Client) ActiveHourDCDBInstance(request *ActiveHourDCDBInstanceRequest) (response *ActiveHourDCDBInstanceResponse, err error) {
if request == nil {
request = NewActiveHourDCDBInstanceRequest()
}
response = NewActiveHourDCDBInstanceResponse()
err = c.Send(request, response)
return
}
func NewCloneAccountRequest() (request *CloneAccountRequest) {
request = &CloneAccountRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "CloneAccount")
return
}
func NewCloneAccountResponse() (response *CloneAccountResponse) {
response = &CloneAccountResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（CloneAccount）用于克隆实例账户。
func (c *Client) CloneAccount(request *CloneAccountRequest) (response *CloneAccountResponse, err error) {
if request == nil {
request = NewCloneAccountRequest()
}
response = NewCloneAccountResponse()
err = c.Send(request, response)
return
}
func NewCloseDBExtranetAccessRequest() (request *CloseDBExtranetAccessRequest) {
request = &CloseDBExtranetAccessRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "CloseDBExtranetAccess")
return
}
func NewCloseDBExtranetAccessResponse() (response *CloseDBExtranetAccessResponse) {
response = &CloseDBExtranetAccessResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口(CloseDBExtranetAccess)用于关闭云数据库实例的外网访问。关闭外网访问后，外网地址将不可访问，查询实例列表接口将不返回对应实例的外网域名和端口信息。
func (c *Client) CloseDBExtranetAccess(request *CloseDBExtranetAccessRequest) (response *CloseDBExtranetAccessResponse, err error) {
if request == nil {
request = NewCloseDBExtranetAccessRequest()
}
response = NewCloseDBExtranetAccessResponse()
err = c.Send(request, response)
return
}
func NewCopyAccountPrivilegesRequest() (request *CopyAccountPrivilegesRequest) {
request = &CopyAccountPrivilegesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "CopyAccountPrivileges")
return
}
func NewCopyAccountPrivilegesResponse() (response *CopyAccountPrivilegesResponse) {
response = &CopyAccountPrivilegesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（CopyAccountPrivileges）用于复制云数据库账号的权限。
// 注意：相同用户名，不同Host是不同的账号，Readonly属性相同的账号之间才能复制权限。
func (c *Client) CopyAccountPrivileges(request *CopyAccountPrivilegesRequest) (response *CopyAccountPrivilegesResponse, err error) {
if request == nil {
request = NewCopyAccountPrivilegesRequest()
}
response = NewCopyAccountPrivilegesResponse()
err = c.Send(request, response)
return
}
func NewCreateAccountRequest() (request *CreateAccountRequest) {
request = &CreateAccountRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "CreateAccount")
return
}
func NewCreateAccountResponse() (response *CreateAccountResponse) {
response = &CreateAccountResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（CreateAccount）用于创建云数据库账号。一个实例可以创建多个不同的账号，相同的用户名+不同的host是不同的账号。
func (c *Client) CreateAccount(request *CreateAccountRequest) (response *CreateAccountResponse, err error) {
if request == nil {
request = NewCreateAccountRequest()
}
response = NewCreateAccountResponse()
err = c.Send(request, response)
return
}
func NewCreateDCDBInstanceRequest() (request *CreateDCDBInstanceRequest) {
request = &CreateDCDBInstanceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "CreateDCDBInstance")
return
}
func NewCreateDCDBInstanceResponse() (response *CreateDCDBInstanceResponse) {
response = &CreateDCDBInstanceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（CreateDCDBInstance）用于创建包年包月的云数据库实例，可通过传入实例规格、数据库版本号、购买时长等信息创建云数据库实例。
func (c *Client) CreateDCDBInstance(request *CreateDCDBInstanceRequest) (response *CreateDCDBInstanceResponse, err error) {
if request == nil {
request = NewCreateDCDBInstanceRequest()
}
response = NewCreateDCDBInstanceResponse()
err = c.Send(request, response)
return
}
func NewCreateHourDCDBInstanceRequest() (request *CreateHourDCDBInstanceRequest) {
request = &CreateHourDCDBInstanceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "CreateHourDCDBInstance")
return
}
func NewCreateHourDCDBInstanceResponse() (response *CreateHourDCDBInstanceResponse) {
response = &CreateHourDCDBInstanceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（CreateHourDCDBInstance）用于创建按量计费的DCDB实例。
func (c *Client) CreateHourDCDBInstance(request *CreateHourDCDBInstanceRequest) (response *CreateHourDCDBInstanceResponse, err error) {
if request == nil {
request = NewCreateHourDCDBInstanceRequest()
}
response = NewCreateHourDCDBInstanceResponse()
err = c.Send(request, response)
return
}
func NewDeleteAccountRequest() (request *DeleteAccountRequest) {
request = &DeleteAccountRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DeleteAccount")
return
}
func NewDeleteAccountResponse() (response *DeleteAccountResponse) {
response = &DeleteAccountResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DeleteAccount）用于删除云数据库账号。用户名+host唯一确定一个账号。
func (c *Client) DeleteAccount(request *DeleteAccountRequest) (response *DeleteAccountResponse, err error) {
if request == nil {
request = NewDeleteAccountRequest()
}
response = NewDeleteAccountResponse()
err = c.Send(request, response)
return
}
func NewDescribeAccountPrivilegesRequest() (request *DescribeAccountPrivilegesRequest) {
request = &DescribeAccountPrivilegesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeAccountPrivileges")
return
}
func NewDescribeAccountPrivilegesResponse() (response *DescribeAccountPrivilegesResponse) {
response = &DescribeAccountPrivilegesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeAccountPrivileges）用于查询云数据库账号权限。
// 注意：注意：相同用户名，不同Host是不同的账号。
func (c *Client) DescribeAccountPrivileges(request *DescribeAccountPrivilegesRequest) (response *DescribeAccountPrivilegesResponse, err error) {
if request == nil {
request = NewDescribeAccountPrivilegesRequest()
}
response = NewDescribeAccountPrivilegesResponse()
err = c.Send(request, response)
return
}
func NewDescribeAccountsRequest() (request *DescribeAccountsRequest) {
request = &DescribeAccountsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeAccounts")
return
}
func NewDescribeAccountsResponse() (response *DescribeAccountsResponse) {
response = &DescribeAccountsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeAccounts）用于查询指定云数据库实例的账号列表。
func (c *Client) DescribeAccounts(request *DescribeAccountsRequest) (response *DescribeAccountsResponse, err error) {
if request == nil {
request = NewDescribeAccountsRequest()
}
response = NewDescribeAccountsResponse()
err = c.Send(request, response)
return
}
func NewDescribeAvailableExclusiveGroupsRequest() (request *DescribeAvailableExclusiveGroupsRequest) {
request = &DescribeAvailableExclusiveGroupsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeAvailableExclusiveGroups")
return
}
func NewDescribeAvailableExclusiveGroupsResponse() (response *DescribeAvailableExclusiveGroupsResponse) {
response = &DescribeAvailableExclusiveGroupsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口(DescribeAvailableExclusiveGroups)用于拉取独享资源池信息
func (c *Client) DescribeAvailableExclusiveGroups(request *DescribeAvailableExclusiveGroupsRequest) (response *DescribeAvailableExclusiveGroupsResponse, err error) {
if request == nil {
request = NewDescribeAvailableExclusiveGroupsRequest()
}
response = NewDescribeAvailableExclusiveGroupsResponse()
err = c.Send(request, response)
return
}
func NewDescribeDBLogFilesRequest() (request *DescribeDBLogFilesRequest) {
request = &DescribeDBLogFilesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDBLogFiles")
return
}
func NewDescribeDBLogFilesResponse() (response *DescribeDBLogFilesResponse) {
response = &DescribeDBLogFilesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口(DescribeDBLogFiles)用于获取数据库的各种日志列表，包括冷备、binlog、errlog和slowlog。
func (c *Client) DescribeDBLogFiles(request *DescribeDBLogFilesRequest) (response *DescribeDBLogFilesResponse, err error) {
if request == nil {
request = NewDescribeDBLogFilesRequest()
}
response = NewDescribeDBLogFilesResponse()
err = c.Send(request, response)
return
}
func NewDescribeDBParametersRequest() (request *DescribeDBParametersRequest) {
request = &DescribeDBParametersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDBParameters")
return
}
func NewDescribeDBParametersResponse() (response *DescribeDBParametersResponse) {
response = &DescribeDBParametersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口(DescribeDBParameters)用于获取数据库的当前参数设置。
func (c *Client) DescribeDBParameters(request *DescribeDBParametersRequest) (response *DescribeDBParametersResponse, err error) {
if request == nil {
request = NewDescribeDBParametersRequest()
}
response = NewDescribeDBParametersResponse()
err = c.Send(request, response)
return
}
func NewDescribeDBSyncModeRequest() (request *DescribeDBSyncModeRequest) {
request = &DescribeDBSyncModeRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDBSyncMode")
return
}
func NewDescribeDBSyncModeResponse() (response *DescribeDBSyncModeResponse) {
response = &DescribeDBSyncModeResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeDBSyncMode）用于查询云数据库实例的同步模式。
func (c *Client) DescribeDBSyncMode(request *DescribeDBSyncModeRequest) (response *DescribeDBSyncModeResponse, err error) {
if request == nil {
request = NewDescribeDBSyncModeRequest()
}
response = NewDescribeDBSyncModeResponse()
err = c.Send(request, response)
return
}
func NewDescribeDCDBInstancesRequest() (request *DescribeDCDBInstancesRequest) {
request = &DescribeDCDBInstancesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDCDBInstances")
return
}
func NewDescribeDCDBInstancesResponse() (response *DescribeDCDBInstancesResponse) {
response = &DescribeDCDBInstancesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 查询云数据库实例列表，支持通过项目ID、实例ID、内网地址、实例名称等来筛选实例。
// 如果不指定任何筛选条件，则默认返回10条实例记录，单次请求最多支持返回100条实例记录。
func (c *Client) DescribeDCDBInstances(request *DescribeDCDBInstancesRequest) (response *DescribeDCDBInstancesResponse, err error) {
if request == nil {
request = NewDescribeDCDBInstancesRequest()
}
response = NewDescribeDCDBInstancesResponse()
err = c.Send(request, response)
return
}
func NewDescribeDCDBPriceRequest() (request *DescribeDCDBPriceRequest) {
request = &DescribeDCDBPriceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDCDBPrice")
return
}
func NewDescribeDCDBPriceResponse() (response *DescribeDCDBPriceResponse) {
response = &DescribeDCDBPriceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeDCDBPrice）用于在购买实例前，查询实例的价格。
func (c *Client) DescribeDCDBPrice(request *DescribeDCDBPriceRequest) (response *DescribeDCDBPriceResponse, err error) {
if request == nil {
request = NewDescribeDCDBPriceRequest()
}
response = NewDescribeDCDBPriceResponse()
err = c.Send(request, response)
return
}
func NewDescribeDCDBRenewalPriceRequest() (request *DescribeDCDBRenewalPriceRequest) {
request = &DescribeDCDBRenewalPriceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDCDBRenewalPrice")
return
}
func NewDescribeDCDBRenewalPriceResponse() (response *DescribeDCDBRenewalPriceResponse) {
response = &DescribeDCDBRenewalPriceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeDCDBRenewalPrice）用于在续费分布式数据库实例时，查询续费的价格。
func (c *Client) DescribeDCDBRenewalPrice(request *DescribeDCDBRenewalPriceRequest) (response *DescribeDCDBRenewalPriceResponse, err error) {
if request == nil {
request = NewDescribeDCDBRenewalPriceRequest()
}
response = NewDescribeDCDBRenewalPriceResponse()
err = c.Send(request, response)
return
}
func NewDescribeDCDBSaleInfoRequest() (request *DescribeDCDBSaleInfoRequest) {
request = &DescribeDCDBSaleInfoRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDCDBSaleInfo")
return
}
func NewDescribeDCDBSaleInfoResponse() (response *DescribeDCDBSaleInfoResponse) {
response = &DescribeDCDBSaleInfoResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口(DescribeDCDBSaleInfo)用于查询分布式数据库可售卖的地域和可用区信息。
func (c *Client) DescribeDCDBSaleInfo(request *DescribeDCDBSaleInfoRequest) (response *DescribeDCDBSaleInfoResponse, err error) {
if request == nil {
request = NewDescribeDCDBSaleInfoRequest()
}
response = NewDescribeDCDBSaleInfoResponse()
err = c.Send(request, response)
return
}
func NewDescribeDCDBShardsRequest() (request *DescribeDCDBShardsRequest) {
request = &DescribeDCDBShardsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDCDBShards")
return
}
func NewDescribeDCDBShardsResponse() (response *DescribeDCDBShardsResponse) {
response = &DescribeDCDBShardsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeDCDBShards）用于查询云数据库实例的分片信息。
func (c *Client) DescribeDCDBShards(request *DescribeDCDBShardsRequest) (response *DescribeDCDBShardsResponse, err error) {
if request == nil {
request = NewDescribeDCDBShardsRequest()
}
response = NewDescribeDCDBShardsResponse()
err = c.Send(request, response)
return
}
func NewDescribeDCDBUpgradePriceRequest() (request *DescribeDCDBUpgradePriceRequest) {
request = &DescribeDCDBUpgradePriceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDCDBUpgradePrice")
return
}
func NewDescribeDCDBUpgradePriceResponse() (response *DescribeDCDBUpgradePriceResponse) {
response = &DescribeDCDBUpgradePriceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeDCDBUpgradePrice）用于查询升级分布式数据库实例价格。
func (c *Client) DescribeDCDBUpgradePrice(request *DescribeDCDBUpgradePriceRequest) (response *DescribeDCDBUpgradePriceResponse, err error) {
if request == nil {
request = NewDescribeDCDBUpgradePriceRequest()
}
response = NewDescribeDCDBUpgradePriceResponse()
err = c.Send(request, response)
return
}
func NewDescribeDatabaseObjectsRequest() (request *DescribeDatabaseObjectsRequest) {
request = &DescribeDatabaseObjectsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDatabaseObjects")
return
}
func NewDescribeDatabaseObjectsResponse() (response *DescribeDatabaseObjectsResponse) {
response = &DescribeDatabaseObjectsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeDatabaseObjects）用于查询云数据库实例的数据库中的对象列表，包含表、存储过程、视图和函数。
func (c *Client) DescribeDatabaseObjects(request *DescribeDatabaseObjectsRequest) (response *DescribeDatabaseObjectsResponse, err error) {
if request == nil {
request = NewDescribeDatabaseObjectsRequest()
}
response = NewDescribeDatabaseObjectsResponse()
err = c.Send(request, response)
return
}
func NewDescribeDatabaseTableRequest() (request *DescribeDatabaseTableRequest) {
request = &DescribeDatabaseTableRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDatabaseTable")
return
}
func NewDescribeDatabaseTableResponse() (response *DescribeDatabaseTableResponse) {
response = &DescribeDatabaseTableResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeDatabaseTable）用于查询云数据库实例的表信息。
func (c *Client) DescribeDatabaseTable(request *DescribeDatabaseTableRequest) (response *DescribeDatabaseTableResponse, err error) {
if request == nil {
request = NewDescribeDatabaseTableRequest()
}
response = NewDescribeDatabaseTableResponse()
err = c.Send(request, response)
return
}
func NewDescribeDatabasesRequest() (request *DescribeDatabasesRequest) {
request = &DescribeDatabasesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeDatabases")
return
}
func NewDescribeDatabasesResponse() (response *DescribeDatabasesResponse) {
response = &DescribeDatabasesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeDatabases）用于查询云数据库实例的数据库列表。
func (c *Client) DescribeDatabases(request *DescribeDatabasesRequest) (response *DescribeDatabasesResponse, err error) {
if request == nil {
request = NewDescribeDatabasesRequest()
}
response = NewDescribeDatabasesResponse()
err = c.Send(request, response)
return
}
func NewDescribeOrdersRequest() (request *DescribeOrdersRequest) {
request = &DescribeOrdersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeOrders")
return
}
func NewDescribeOrdersResponse() (response *DescribeOrdersResponse) {
response = &DescribeOrdersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeOrders）用于查询分布式数据库订单信息。传入订单Id来查询订单关联的分布式数据库实例，和对应的任务流程ID。
func (c *Client) DescribeOrders(request *DescribeOrdersRequest) (response *DescribeOrdersResponse, err error) {
if request == nil {
request = NewDescribeOrdersRequest()
}
response = NewDescribeOrdersResponse()
err = c.Send(request, response)
return
}
func NewDescribeShardSpecRequest() (request *DescribeShardSpecRequest) {
request = &DescribeShardSpecRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeShardSpec")
return
}
func NewDescribeShardSpecResponse() (response *DescribeShardSpecResponse) {
response = &DescribeShardSpecResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 查询可创建的分布式数据库可售卖的分片规格配置。
func (c *Client) DescribeShardSpec(request *DescribeShardSpecRequest) (response *DescribeShardSpecResponse, err error) {
if request == nil {
request = NewDescribeShardSpecRequest()
}
response = NewDescribeShardSpecResponse()
err = c.Send(request, response)
return
}
func NewDescribeSqlLogsRequest() (request *DescribeSqlLogsRequest) {
request = &DescribeSqlLogsRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DescribeSqlLogs")
return
}
func NewDescribeSqlLogsResponse() (response *DescribeSqlLogsResponse) {
response = &DescribeSqlLogsResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DescribeSqlLogs）用于获取实例SQL日志。
func (c *Client) DescribeSqlLogs(request *DescribeSqlLogsRequest) (response *DescribeSqlLogsResponse, err error) {
if request == nil {
request = NewDescribeSqlLogsRequest()
}
response = NewDescribeSqlLogsResponse()
err = c.Send(request, response)
return
}
func NewDestroyHourDCDBInstanceRequest() (request *DestroyHourDCDBInstanceRequest) {
request = &DestroyHourDCDBInstanceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "DestroyHourDCDBInstance")
return
}
func NewDestroyHourDCDBInstanceResponse() (response *DestroyHourDCDBInstanceResponse) {
response = &DestroyHourDCDBInstanceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（DestroyHourDCDBInstance）用于销毁按量计费实例。
func (c *Client) DestroyHourDCDBInstance(request *DestroyHourDCDBInstanceRequest) (response *DestroyHourDCDBInstanceResponse, err error) {
if request == nil {
request = NewDestroyHourDCDBInstanceRequest()
}
response = NewDestroyHourDCDBInstanceResponse()
err = c.Send(request, response)
return
}
func NewGrantAccountPrivilegesRequest() (request *GrantAccountPrivilegesRequest) {
request = &GrantAccountPrivilegesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "GrantAccountPrivileges")
return
}
func NewGrantAccountPrivilegesResponse() (response *GrantAccountPrivilegesResponse) {
response = &GrantAccountPrivilegesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（GrantAccountPrivileges）用于给云数据库账号赋权。
// 注意：相同用户名，不同Host是不同的账号。
func (c *Client) GrantAccountPrivileges(request *GrantAccountPrivilegesRequest) (response *GrantAccountPrivilegesResponse, err error) {
if request == nil {
request = NewGrantAccountPrivilegesRequest()
}
response = NewGrantAccountPrivilegesResponse()
err = c.Send(request, response)
return
}
func NewInitDCDBInstancesRequest() (request *InitDCDBInstancesRequest) {
request = &InitDCDBInstancesRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "InitDCDBInstances")
return
}
func NewInitDCDBInstancesResponse() (response *InitDCDBInstancesResponse) {
response = &InitDCDBInstancesResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口(InitDCDBInstances)用于初始化云数据库实例，包括设置默认字符集、表名大小写敏感等。
func (c *Client) InitDCDBInstances(request *InitDCDBInstancesRequest) (response *InitDCDBInstancesResponse, err error) {
if request == nil {
request = NewInitDCDBInstancesRequest()
}
response = NewInitDCDBInstancesResponse()
err = c.Send(request, response)
return
}
func NewIsolateHourDCDBInstanceRequest() (request *IsolateHourDCDBInstanceRequest) {
request = &IsolateHourDCDBInstanceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "IsolateHourDCDBInstance")
return
}
func NewIsolateHourDCDBInstanceResponse() (response *IsolateHourDCDBInstanceResponse) {
response = &IsolateHourDCDBInstanceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（IsolateHourDCDBInstance）用于隔离按量计费DCDB实例。
func (c *Client) IsolateHourDCDBInstance(request *IsolateHourDCDBInstanceRequest) (response *IsolateHourDCDBInstanceResponse, err error) {
if request == nil {
request = NewIsolateHourDCDBInstanceRequest()
}
response = NewIsolateHourDCDBInstanceResponse()
err = c.Send(request, response)
return
}
func NewModifyAccountDescriptionRequest() (request *ModifyAccountDescriptionRequest) {
request = &ModifyAccountDescriptionRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "ModifyAccountDescription")
return
}
func NewModifyAccountDescriptionResponse() (response *ModifyAccountDescriptionResponse) {
response = &ModifyAccountDescriptionResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（ModifyAccountDescription）用于修改云数据库账号备注。
// 注意：相同用户名，不同Host是不同的账号。
func (c *Client) ModifyAccountDescription(request *ModifyAccountDescriptionRequest) (response *ModifyAccountDescriptionResponse, err error) {
if request == nil {
request = NewModifyAccountDescriptionRequest()
}
response = NewModifyAccountDescriptionResponse()
err = c.Send(request, response)
return
}
func NewModifyDBInstancesProjectRequest() (request *ModifyDBInstancesProjectRequest) {
request = &ModifyDBInstancesProjectRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "ModifyDBInstancesProject")
return
}
func NewModifyDBInstancesProjectResponse() (response *ModifyDBInstancesProjectResponse) {
response = &ModifyDBInstancesProjectResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（ModifyDBInstancesProject）用于修改云数据库实例所属项目。
func (c *Client) ModifyDBInstancesProject(request *ModifyDBInstancesProjectRequest) (response *ModifyDBInstancesProjectResponse, err error) {
if request == nil {
request = NewModifyDBInstancesProjectRequest()
}
response = NewModifyDBInstancesProjectResponse()
err = c.Send(request, response)
return
}
func NewModifyDBParametersRequest() (request *ModifyDBParametersRequest) {
request = &ModifyDBParametersRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "ModifyDBParameters")
return
}
func NewModifyDBParametersResponse() (response *ModifyDBParametersResponse) {
response = &ModifyDBParametersResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口(ModifyDBParameters)用于修改数据库参数。
func (c *Client) ModifyDBParameters(request *ModifyDBParametersRequest) (response *ModifyDBParametersResponse, err error) {
if request == nil {
request = NewModifyDBParametersRequest()
}
response = NewModifyDBParametersResponse()
err = c.Send(request, response)
return
}
func NewModifyDBSyncModeRequest() (request *ModifyDBSyncModeRequest) {
request = &ModifyDBSyncModeRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "ModifyDBSyncMode")
return
}
func NewModifyDBSyncModeResponse() (response *ModifyDBSyncModeResponse) {
response = &ModifyDBSyncModeResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（ModifyDBSyncMode）用于修改云数据库实例的同步模式。
func (c *Client) ModifyDBSyncMode(request *ModifyDBSyncModeRequest) (response *ModifyDBSyncModeResponse, err error) {
if request == nil {
request = NewModifyDBSyncModeRequest()
}
response = NewModifyDBSyncModeResponse()
err = c.Send(request, response)
return
}
func NewOpenDBExtranetAccessRequest() (request *OpenDBExtranetAccessRequest) {
request = &OpenDBExtranetAccessRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "OpenDBExtranetAccess")
return
}
func NewOpenDBExtranetAccessResponse() (response *OpenDBExtranetAccessResponse) {
response = &OpenDBExtranetAccessResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（OpenDBExtranetAccess）用于开通云数据库实例的外网访问。开通外网访问后，您可通过外网域名和端口访问实例，可使用查询实例列表接口获取外网域名和端口信息。
func (c *Client) OpenDBExtranetAccess(request *OpenDBExtranetAccessRequest) (response *OpenDBExtranetAccessResponse, err error) {
if request == nil {
request = NewOpenDBExtranetAccessRequest()
}
response = NewOpenDBExtranetAccessResponse()
err = c.Send(request, response)
return
}
func NewRenewDCDBInstanceRequest() (request *RenewDCDBInstanceRequest) {
request = &RenewDCDBInstanceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "RenewDCDBInstance")
return
}
func NewRenewDCDBInstanceResponse() (response *RenewDCDBInstanceResponse) {
response = &RenewDCDBInstanceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（RenewDCDBInstance）用于续费分布式数据库实例。
func (c *Client) RenewDCDBInstance(request *RenewDCDBInstanceRequest) (response *RenewDCDBInstanceResponse, err error) {
if request == nil {
request = NewRenewDCDBInstanceRequest()
}
response = NewRenewDCDBInstanceResponse()
err = c.Send(request, response)
return
}
func NewResetAccountPasswordRequest() (request *ResetAccountPasswordRequest) {
request = &ResetAccountPasswordRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "ResetAccountPassword")
return
}
func NewResetAccountPasswordResponse() (response *ResetAccountPasswordResponse) {
response = &ResetAccountPasswordResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（ResetAccountPassword）用于重置云数据库账号的密码。
// 注意：相同用户名，不同Host是不同的账号。
func (c *Client) ResetAccountPassword(request *ResetAccountPasswordRequest) (response *ResetAccountPasswordResponse, err error) {
if request == nil {
request = NewResetAccountPasswordRequest()
}
response = NewResetAccountPasswordResponse()
err = c.Send(request, response)
return
}
func NewUpgradeDCDBInstanceRequest() (request *UpgradeDCDBInstanceRequest) {
request = &UpgradeDCDBInstanceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "UpgradeDCDBInstance")
return
}
func NewUpgradeDCDBInstanceResponse() (response *UpgradeDCDBInstanceResponse) {
response = &UpgradeDCDBInstanceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（UpgradeDCDBInstance）用于升级分布式数据库实例。本接口完成下单和支付两个动作，如果发生支付失败的错误，调用用户账户相关接口中的支付订单接口（PayDeals）重新支付即可。
func (c *Client) UpgradeDCDBInstance(request *UpgradeDCDBInstanceRequest) (response *UpgradeDCDBInstanceResponse, err error) {
if request == nil {
request = NewUpgradeDCDBInstanceRequest()
}
response = NewUpgradeDCDBInstanceResponse()
err = c.Send(request, response)
return
}
func NewUpgradeHourDCDBInstanceRequest() (request *UpgradeHourDCDBInstanceRequest) {
request = &UpgradeHourDCDBInstanceRequest{
BaseRequest: &tchttp.BaseRequest{},
}
request.Init().WithApiInfo("dcdb", APIVersion, "UpgradeHourDCDBInstance")
return
}
func NewUpgradeHourDCDBInstanceResponse() (response *UpgradeHourDCDBInstanceResponse) {
response = &UpgradeHourDCDBInstanceResponse{
BaseResponse: &tchttp.BaseResponse{},
}
return
}
// 本接口（UpgradeHourDCDBInstance）用于升级升级按量计费DCDB实例
func (c *Client) UpgradeHourDCDBInstance(request *UpgradeHourDCDBInstanceRequest) (response *UpgradeHourDCDBInstanceResponse, err error) {
if request == nil {
request = NewUpgradeHourDCDBInstanceRequest()
}
response = NewUpgradeHourDCDBInstanceResponse()
err = c.Send(request, response)
return
}
|
/*
Copyright 2019 Google Inc.
Copyright 2019 The MayaData 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
https://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 composite
import (
"testing"
"time"
batchv1 "k8s.io/api/batch/v1"
apiextensions "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/util/json"
"openebs.io/metac/apis/metacontroller/v1alpha1"
"openebs.io/metac/controller/composite"
"openebs.io/metac/test/integration/framework"
)
// This will be run only once when go test is invoked against this package.
// All the other TestXYZ functions will be invoked via m.Run call only.
//
// framework.TestMain provides setup & teardown features required for
// all the individual testcases to run.
func TestMain(m *testing.M) {
framework.TestWithCRDMetac(m.Run)
}
// TestSyncWebhook tests that the sync webhook triggers and passes the
// request/response properly.
func TestSyncWebhook(t *testing.T) {
testName := "cctl-test-sync-webhook"
labels := map[string]string{
"test": "test",
"metac/controller-name": "composite",
"metac/resource-type": "customresource",
"metac/test-category": "sync-webhook",
}
// fixture provides the common test logic including a way to
// invoke teardown after completion of this particular test
f := framework.NewFixture(t)
defer f.TearDown()
f.CreateNamespace(testName)
parentCRD, parentClient := f.SetupCRD(
"CCtlSyncParent", apiextensions.NamespaceScoped,
)
childCRD, childClient := f.SetupCRD(
"CCtlSyncChild", apiextensions.NamespaceScoped,
)
// define the "reconcile logic" i.e. sync hook logic here
hook := f.ServeWebhook(func(body []byte) ([]byte, error) {
req := composite.SyncHookRequest{}
if err := json.Unmarshal(body, &req); err != nil {
return nil, err
}
// As a simple test of request/response content,
// just build a child with the same name as the parent.
//
// Note that this does not create the child in kubernetes.
// Creation of child in kubernetes is done by composite
// controller on creation of parent resource.
child := framework.BuildUnstructObjFromCRD(childCRD, req.Parent.GetName())
child.SetLabels(labels)
resp := composite.SyncHookResponse{
Children: []*unstructured.Unstructured{child},
}
return json.Marshal(resp)
})
f.CreateCompositeController(
testName,
hook.URL,
framework.BuildResourceRuleFromCRD(parentCRD),
framework.BuildResourceRuleFromCRD(childCRD),
)
parentResource := framework.BuildUnstructObjFromCRD(parentCRD, testName)
unstructured.SetNestedStringMap(
parentResource.Object, labels, "spec", "selector", "matchLabels",
)
t.Logf(
"Creating %s %s/%s",
parentResource.GetKind(),
parentResource.GetNamespace(),
parentResource.GetName(),
)
_, err :=
parentClient.Namespace(testName).Create(parentResource, metav1.CreateOptions{})
if err != nil {
t.Fatal(err)
}
t.Logf(
"Created %s %s/%s",
parentResource.GetKind(),
parentResource.GetNamespace(),
parentResource.GetName(),
)
t.Logf("Waiting for child sync")
err = f.Wait(func() (bool, error) {
_, err := childClient.Namespace(testName).Get(testName, metav1.GetOptions{})
return err == nil, err
})
if err != nil {
t.Errorf("Child sync failed: %v", err)
}
t.Logf("Child sync was successful")
}
// TestCascadingDelete tests that we request cascading deletion of children,
// even if the server-side default for that child type is non-cascading.
func TestCacadingDelete(t *testing.T) {
testName := "cctl-test-cascading-delete"
labels := map[string]string{
"test": "test",
"metac/controller-name": "composite",
"metac/resource-type": "customresource-job",
"metac/test-category": "cascading-delete",
}
f := framework.NewFixture(t)
defer f.TearDown()
f.CreateNamespace(testName)
parentCRD, parentClient := f.SetupCRD(
"CCtlCascadingDeleteParent", apiextensions.NamespaceScoped,
)
jobChildClient := f.GetTypedClientset().BatchV1().Jobs(testName)
// define the "reconcile logic" i.e. sync hook logic here
hook := f.ServeWebhook(func(body []byte) ([]byte, error) {
req := composite.SyncHookRequest{}
if err := json.Unmarshal(body, &req); err != nil {
return nil, err
}
resp := composite.SyncHookResponse{}
replicas, _, _ :=
unstructured.NestedInt64(req.Parent.Object, "spec", "replicas")
if replicas > 0 {
// Create a child batch/v1 Job if requested.
// For backward compatibility, the server-side default on that API is
// non-cascading deletion (don't delete Pods).
// So we can use this as a test case for whether we are correctly requesting
// cascading deletion.
child := framework.BuildUnstructuredObjFromJSON(
"batch/v1",
"Job",
testName,
`{
"spec": {
"template": {
"spec": {
"restartPolicy": "Never",
"containers": [
{
"name": "pi",
"image": "perl"
}
]
}
}
}
}`,
)
child.SetLabels(labels)
resp.Children = append(resp.Children, child)
}
return json.Marshal(resp)
})
f.CreateCompositeController(
testName,
hook.URL,
framework.BuildResourceRuleFromCRD(parentCRD),
&v1alpha1.ResourceRule{APIVersion: "batch/v1", Resource: "jobs"},
)
parentResource := framework.BuildUnstructObjFromCRD(parentCRD, testName)
unstructured.SetNestedStringMap(
parentResource.Object, labels, "spec", "selector", "matchLabels",
)
unstructured.SetNestedField(parentResource.Object, int64(1), "spec", "replicas")
t.Logf(
"Creating %s %s/%s",
parentResource.GetKind(),
parentResource.GetNamespace(),
parentResource.GetName(),
)
var err error
parentResource, err =
parentClient.Namespace(testName).Create(parentResource, metav1.CreateOptions{})
if err != nil {
t.Fatal(err)
}
t.Logf(
"Created %s %s/%s",
parentResource.GetKind(),
parentResource.GetNamespace(),
parentResource.GetName(),
)
t.Logf("Waiting for child job creation")
err = f.Wait(func() (bool, error) {
_, err := jobChildClient.Get(testName, metav1.GetOptions{})
return err == nil, err
})
if err != nil {
t.Errorf("Child job create failed: %v", err)
}
t.Logf("Child job was created successfully")
// Now that child exists, tell parent to delete it.
t.Logf("Updating parent with replicas=0")
_, err =
parentClient.Namespace(testName).AtomicUpdate(parentResource, func(obj *unstructured.Unstructured) bool {
unstructured.SetNestedField(obj.Object, int64(0), "spec", "replicas")
return true
})
if err != nil {
t.Fatal(err)
}
t.Logf("Updated parent with replicas=0")
// Make sure the child gets actually deleted, which means no GC finalizers got
// added to it. Note that we don't actually run the GC in this integration
// test env, so we don't need to worry about the GC racing us to process the
// finalizers.
t.Logf("Waiting for child job to be deleted")
var child *batchv1.Job
err = f.Wait(func() (bool, error) {
var getErr error
child, getErr = jobChildClient.Get(testName, metav1.GetOptions{})
return apierrors.IsNotFound(getErr), nil
})
if err != nil {
out, _ := json.Marshal(child)
t.Errorf("Child job delete failed: %v; object: %s", err, out)
}
t.Logf("Child job deleted successfully")
}
// TestResyncAfter tests that the resyncAfterSeconds field works.
func TestResyncAfter(t *testing.T) {
testName := "cctl-test-resync-after"
labels := map[string]string{
"test": "test",
"metac/controller-name": "composite",
"metac/resource-type": "customresource-job",
"metac/test-category": "resync-after",
}
f := framework.NewFixture(t)
defer f.TearDown()
f.CreateNamespace(testName)
parentCRD, parentClient := f.SetupCRD(
"CCtlResyncAfterParent", apiextensions.NamespaceScoped,
)
var lastSync time.Time
done := false
// reconcile logic i.e. sync hook logic is here
hook := f.ServeWebhook(func(body []byte) ([]byte, error) {
req := composite.SyncHookRequest{}
if err := json.Unmarshal(body, &req); err != nil {
return nil, err
}
resp := composite.SyncHookResponse{}
if req.Parent.Object["status"] == nil {
// If status hasn't been set yet, set it. This is the "zeroth" sync.
// Metacontroller will set our status and then the object should quiesce.
resp.Status = map[string]interface{}{}
} else if lastSync.IsZero() {
// This should be the final sync before quiescing. Do nothing except
// request a resync. Other than our resyncAfter request, there should be
// nothing that causes our object to get resynced.
lastSync = time.Now()
resp.ResyncAfterSeconds = 0.1
} else if !done {
done = true
// This is the second sync. Report how much time elapsed.
resp.Status = map[string]interface{}{
"elapsedSeconds": time.Since(lastSync).Seconds(),
}
} else {
// If we're done, just freeze the status.
resp.Status = req.Parent.Object["status"].(map[string]interface{})
}
return json.Marshal(resp)
})
f.CreateCompositeController(
testName,
hook.URL,
framework.BuildResourceRuleFromCRD(parentCRD),
nil,
)
parentResource := framework.BuildUnstructObjFromCRD(parentCRD, testName)
unstructured.SetNestedStringMap(
parentResource.Object, labels, "spec", "selector", "matchLabels",
)
t.Logf(
"Creating %s %s/%s",
parentResource.GetKind(),
parentResource.GetNamespace(),
parentResource.GetName(),
)
_, err :=
parentClient.Namespace(testName).Create(parentResource, metav1.CreateOptions{})
if err != nil {
t.Fatal(err)
}
t.Logf(
"Created %s %s/%s",
parentResource.GetKind(),
parentResource.GetNamespace(),
parentResource.GetName(),
)
t.Logf("Waiting for status.elaspedSeconds to be reported")
var elapsedSeconds float64
err = f.Wait(func() (bool, error) {
parentResource, err :=
parentClient.Namespace(testName).Get(testName, metav1.GetOptions{})
if err != nil {
return false, err
}
val, found, err := unstructured.NestedFloat64(
parentResource.Object, "status", "elapsedSeconds",
)
if err != nil || !found {
// The value hasn't been populated. Keep waiting.
return false, err
}
elapsedSeconds = val
return true, nil
})
if err != nil {
t.Fatalf("Didn't find status.elapsedSeconds: %v", err)
}
t.Logf("status.elapsedSeconds is %v", elapsedSeconds)
if elapsedSeconds > 1.0 {
t.Errorf(
"Requested resyncAfter did not occur in time; elapsedSeconds: %v",
elapsedSeconds,
)
}
}
|
package main
import (
"fmt"
"io/ioutil"
"log"
"net"
)
// To run this program
// Run 01_write first. It will act as server for this example
// Then run this program
func main() {
conn, err := net.Dial("tcp", ":8080")
if err != nil {
log.Fatalln(err)
}
defer conn.Close()
bs, err := ioutil.ReadAll(conn)
if err != nil {
log.Fatalln(err)
}
fmt.Println(string(bs))
}
|
package main
import (
"fmt"
"github.com/maurodelazeri/pusher-golang-wss/pusher"
)
// Example Handler object
type chanHandler struct{}
func (o *chanHandler) HandleEvent(event pusher.Event) {
fmt.Println("Handler: Got Event:", event.Channel, event.Event, event.Data)
}
// Example Handler function
func eventHandler(event pusher.Event) {
fmt.Println("HandlerFunc: Got Event:", event.Channel, event.Event, event.Data)
}
func main() {
// Create pusher client connection for "app_key"
client := pusher.NewClient("c0eef4118084f8164bec65e6253bf195", "notifier.bitskins.com:443")
// Subscribe to a channel
ch := client.Subscribe("inventory_changes")
// Bind to events on the channel. Can use either a Handler object.
ch.Bind("delisted_or_sold", &chanHandler{})
ch.BindFunc("delisted_or_sold", eventHandler)
// bind to all channel events
client.BindAll(&chanHandler{})
client.BindAllFunc(eventHandler)
select {}
}
|
package problem0123
func maxProfit(prices []int) int {
firstBuy := (int)(-10E5 - 1)
firstSell := 0
secondBuy := (int)(-10E5 - 1)
secondSell := 0
for _, curPrice := range prices {
if firstBuy < -curPrice {
firstBuy = -curPrice
}
if firstSell < firstBuy+curPrice {
firstSell = firstBuy + curPrice
}
if secondBuy < firstSell-curPrice {
secondBuy = firstSell - curPrice
}
if secondSell < secondBuy+curPrice {
secondSell = secondBuy + curPrice
}
}
return secondSell
}
|
package xhcrypt
import (
"encoding/base64"
"fmt"
"testing"
)
func TestAesConfig_Encrypt(t *testing.T) {
plaintext := "LftuD3eBuJhRtEkAajk="
key := "uCd85n9kEOmQf11s+9SShdxzMSDnGqt7ojZPGo0w3nY="
oldKeys := make(map[string][]byte)
if err := Init("=hehui", []byte(key), oldKeys); err != nil {
fmt.Println(err.Error())
return
}
cipherText, err := ConfigAes.Encrypt([]byte(plaintext))
if err != nil {
fmt.Println("Encrypt error: " + err.Error())
return
}
fmt.Println("cipherText = " + cipherText)
newPlain, err := ConfigAes.Decrypt(cipherText)
if err != nil {
fmt.Println("Decrypt error: " + err.Error())
return
}
fmt.Println("newPlain = " + string(newPlain))
fmt.Println("plaintext = " + plaintext)
return
}
func TestAesConfig_Decrypt(t *testing.T) {
key := "uCd85n9kEOmQf11s+9SShdxzMSDnGqt7ojZPGo0w3nY="
oldKeys := make(map[string][]byte)
if err := Init("=DhaV=", []byte(key), oldKeys); err != nil {
fmt.Println(err.Error())
return
}
cipherTextNew := "=DhaV=BiIHehUlKWJqQEUKTg4UMGePRBju+iTlznZLf1jtsvw1BSzOsVsDuX3iM9nc+Rac"
decodePlain, err := ConfigAes.Decrypt(cipherTextNew)
if err != nil {
fmt.Println("Decrypt error: " + err.Error())
return
}
fmt.Println("newPlain = " + string(decodePlain))
plaintext := "LftuD3eBuJhRtEkAajk="
fmt.Println("plaintext = " + plaintext)
fmt.Println("========================================")
cipherTextOld := "pM5fTs4HG/AoOy90GCkHZQAAAAc="
decodePlain, err = ConfigAes.Decrypt(cipherTextOld)
if err != nil {
fmt.Println("Decrypt error: " + err.Error())
return
}
fmt.Println("newPlain = " + string(decodePlain))
return
}
func BenchmarkAesConfig_Encrypt(b *testing.B) {
plaintext := "LftuD3eBuJhRtEkAajk="
key := "uCd85n9kEOmQf11s+9SShdxzMSDnGqt7ojZPGo0w3nY="
oldKeys := make(map[string][]byte)
if err := Init("=DhaV=", []byte(key), oldKeys); err != nil {
fmt.Println(err.Error())
return
}
for i := 0; i < b.N; i++ {
_, err := ConfigAes.Encrypt([]byte(plaintext))
if err != nil {
return
}
}
}
func TestPBKDF2(t *testing.T) {
data, err := base64.StdEncoding.DecodeString("b19mUDdXVighL2NSfhtYOgl0Vv/mwRaY5FI7ApP6MLQ=")
if err != nil {
fmt.Println(err.Error())
return
}
fmt.Println(data)
//f, err := os.Create("Z:\\Goland\\src\\gitee.com\\yongxue\\magicbox\\main\\logs\\test.log")
//if err != nil {
// fmt.Println(err.Error())
// return
//}
//f.Write(data)
//f.Close()
return
}
|
package ghosts
type Poltergeist struct {
}
func (p Poltergeist) Name() string {
return "Poltergeist"
}
func (p Poltergeist) Evidence() [3]string {
return [3]string{"Orbs", "Spirit Box", "Fingerprints"}
}
|
package main
import (
"fmt"
"os"
"strings"
)
type input []string
func (r input) reverse() {
strInput := strings.Join(r[:], " ")
sLen := len(strInput)
revStr := make([]rune, sLen)
for i, v := range strInput {
revStr[sLen-(i+1)] = v
}
fmt.Printf("%s", string(revStr))
}
func main() {
word := input(os.Args[1:])
word.reverse()
}
|
package main
import "github.com/prometheus/client_golang/prometheus"
var (
AuditConnectionEventCounter = prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: "tidb",
Subsystem: "audit",
Name: "audit_connection_event",
Help: "Counter of audit connection event",
}, []string{"event"})
AuditStmtEventCounter = prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: "tidb",
Subsystem: "audit",
Name: "audit_stmt_event",
Help: "Counter of audit stmt event",
}, []string{"sql_type"})
AuditCommandEventCounter = prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: "tidb",
Subsystem: "audit",
Name: "audit_command_event",
Help: "Counter of audit command event",
}, []string{"sql_type"})
)
func initMetric() error {
prometheus.Register(AuditConnectionEventCounter)
prometheus.Register(AuditStmtEventCounter)
prometheus.Register(AuditCommandEventCounter)
return nil
}
|
package monster
import "testing"
//monster.Store()测试用例
func TestStore(t *testing.T) {
monster := &Monster{
Name: "zcr",
Age: 10,
Skill: "kill",
}
err := monster.Store()
if err != true {
t.Fatalf("monster.Store()测试不通过")
}
t.Logf("monster.Store()没问题，测试通过")
}
//monster.ReStore测试用例
func TestReStore(t *testing.T) {
monster := &Monster{}
err := monster.ReStore()
if err != true {
t.Fatalf("monster.ReStore()测试不通过 err=")
}
if monster.Name != "zcr"{
t.Fatalf("monster.ReStore()测试不通过 err=")
}
t.Logf("monster.ReStore()没问题，测试通过")
}
|
// Copyright 2021 BoCloud
//
// 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 manager
import (
"github.com/fabedge/fabedge/pkg/connector/iptables"
"github.com/fabedge/fabedge/pkg/connector/route"
"github.com/fabedge/fabedge/pkg/connector/tunnel"
"github.com/spf13/viper"
"k8s.io/klog/v2"
"os"
"os/signal"
"syscall"
"time"
)
type Manager struct {
config *config
}
type config struct {
interval time.Duration
edgePodCIDR string
tunnelConfigFile string
}
func NewManager() *Manager {
c := &config{
interval: viper.GetDuration("syncPeriod"),
edgePodCIDR: viper.GetString("edgePodCIDR"),
tunnelConfigFile: viper.GetString("tunnelConfig"),
}
return &Manager{
config: c,
}
}
func runTasks(interval time.Duration, handler ...func()) {
t := time.Tick(interval)
for {
<-t
for _, h := range handler {
h()
}
}
}
func (m *Manager) Start() {
routeTaskFn := func() {
if err := route.SyncRoutes(m.config.edgePodCIDR); err != nil {
klog.Errorf("error to sync routes: %s", err)
} else {
klog.Infof("routes:%s are synced", m.config.edgePodCIDR)
}
}
iptablesTaskFn := func() {
if err := iptables.EnsureIPTablesRules(m.config.edgePodCIDR); err != nil {
klog.Errorf("error when to add iptables rules: %s", err)
} else {
klog.Infof("iptables rules are added")
}
}
tunnelTaskFn := func() {
if err := tunnel.SyncConnections(); err != nil {
klog.Errorf("error when to sync tunnels: %s", err)
} else {
klog.Infof("tunnels are synced")
}
}
tasks := []func(){routeTaskFn, iptablesTaskFn, tunnelTaskFn}
// repeats regular tasks periodically
go runTasks(m.config.interval, tasks...)
// sync tunnels when config file updated by cloud.
go onConfigFileChange(m.config.tunnelConfigFile, tunnelTaskFn)
klog.Info("manager started")
// wait os signal
ch := make(chan os.Signal, 1)
signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
<-ch
m.gracefulShutdown()
klog.Info("manager stopped")
}
func (m *Manager) gracefulShutdown() {
//immediately sync
_ = route.SyncRoutes(m.config.edgePodCIDR)
}
|
package mysql
import (
"github.com/ttacon/chalk"
"log"
"mix/core/helper"
"mix/core/logger"
"mix/core/storage"
)
func Sync(conn, ymlPath string) (err error) {
db, err := NewMySQL(conn)
if err != nil {
logger.Error("Connect error:", err)
return
}
onlineTables, err := db.GetTables()
if err != nil {
return
}
storage.MakeDir(storage.Abs(ymlPath))
localTables, err := ReadTableFiles(storage.Abs(ymlPath))
if err != nil {
logger.Error("Read entity files error", err)
return
}
for _, online := range onlineTables {
exist := false
for _, local := range localTables.List {
if online.Table == local.Table {
exist = true
local.Merge(online)
err = writeEntityYaml(ymlPath, local)
if err != nil {
return
}
break
}
}
if !exist {
online.Slug = helper.Singular(online.Table)
err = writeEntityYaml(ymlPath, online)
if err != nil {
return
}
}
}
return
}
func writeEntityYaml(ymlPath string, entity *Entity) (err error) {
if entity.Engine == InnodbEngine {
entity.Engine = ""
}
if entity.Charset == DefaultDatabaseCharset {
entity.Charset = ""
}
if entity.Collation == DefaultDatabaseCollate {
entity.Collation = ""
}
filePath, render, err := storage.WriteYml(ymlPath, entity.Slug, entity, false)
if err != nil {
logger.Error("Write table error:", err)
return
}
if render {
log.Println(chalk.Green.Color("Sync table:"), chalk.Green.Color(chalk.Bold.TextStyle(storage.RelativePath(filePath))))
}
return
}
|
package account
type TransactionKind = byte
const (
DEPOSIT TransactionKind = iota + 1
WITHDRAW
)
type Transaction struct {
Kind TransactionKind
Amt float64
}
|
package actions
import (
"fmt"
"net/http"
"strconv"
"time"
"github.com/gobuffalo/buffalo"
"github.com/gobuffalo/envy"
"github.com/gobuffalo/pop/v5"
"github.com/gobuffalo/x/responder"
)
type userDistanceData struct {
UserID string `json:"user_id" db:"user_id"`
User string `json:"user" db:"user"`
Distance int `json:"distance" db:"distance"`
}
type userActivityCount struct {
UserID string `json:"user_id" db:"user_id"`
User string `json:"user" db:"user"`
Count int `json:"distance" db:"count"`
}
type userDuration struct {
UserID string `json:"user_id" db:"user_id"`
User string `json:"user" db:"user"`
Duration int `json:"distance" db:"duration"`
}
func parseThisNextYear(osEnv string) (string, string) {
thisYear, err := strconv.Atoi(osEnv)
if err != nil {
App().Logger.Errorf("%s could not be parsed int int.", osEnv)
currentYearInt := time.Now().Year()
return fmt.Sprintf("%d", currentYearInt), fmt.Sprintf("%d", currentYearInt+1)
}
return fmt.Sprintf("%d", thisYear), fmt.Sprintf("%d", thisYear+1)
}
func getAllUsersTotalDistance(tx *pop.Connection) ([]userDistanceData, error) {
thisYear, nextYear := parseThisNextYear(envy.Get("ROAW_YEAR", ""))
queryString := "SELECT " +
" u.id as user_id, " +
" u.name as user, " +
" SUM(COALESCE(a.distance,0)) as distance " +
"FROM users u " +
" LEFT JOIN activities a ON a.user_id = u.id " +
"WHERE a.type IS NULL OR (a.type = 'Run' " +
" AND a.datetime >= '" + thisYear + "-01-01' " +
" AND a.datetime < '" + nextYear + "-01-01' ) " +
"GROUP BY u.id " +
"ORDER BY distance DESC"
data := []userDistanceData{}
err := tx.RawQuery(queryString).All(&data)
return data, err
}
func getAllUsersActivityCount(tx *pop.Connection) ([]userActivityCount, error) {
thisYear, nextYear := parseThisNextYear(envy.Get("ROAW_YEAR", ""))
queryString := "SELECT " +
" u.id as user_id, " +
" u.name as user, " +
" COUNT(a.distance) as count " +
"FROM users u " +
" LEFT JOIN activities a ON a.user_id = u.id " +
"WHERE a.type IS NULL OR (a.type = 'Run' " +
" AND a.datetime >= '" + thisYear + "-01-01' " +
" AND a.datetime < '" + nextYear + "-01-01' " +
" AND a.elapsed_time >= 300 ) " +
"GROUP BY u.id " +
"ORDER BY count DESC"
data := []userActivityCount{}
err := tx.RawQuery(queryString).All(&data)
return data, err
}
func getAllUsersTotalDuration(tx *pop.Connection) ([]userDuration, error) {
thisYear, nextYear := parseThisNextYear(envy.Get("ROAW_YEAR", ""))
queryString := "SELECT " +
" u.id as user_id, " +
" u.name as user, " +
" SUM(COALESCE(a.elapsed_time,0)) as duration " +
"FROM users u " +
" LEFT JOIN activities a ON a.user_id = u.id " +
"WHERE a.type IS NULL OR (a.type = 'Run' " +
" AND a.datetime >= '" + thisYear + "-01-01' " +
" AND a.datetime < '" + nextYear + "-01-01' ) " +
"GROUP BY u.id " +
"ORDER BY duration DESC"
data := []userDuration{}
err := tx.RawQuery(queryString).All(&data)
return data, err
}
func getAllUsersMostDistance(tx *pop.Connection) ([]userDistanceData, error) {
thisYear, nextYear := parseThisNextYear(envy.Get("ROAW_YEAR", ""))
queryString := "SELECT " +
" u.id as user_id, " +
" u.name as user, " +
" MAX(COALESCE(a.distance,0)) as distance " +
"FROM users u " +
" LEFT JOIN activities a ON a.user_id = u.id " +
"WHERE a.type IS NULL OR (a.type = 'Run' " +
" AND a.datetime >= '" + thisYear + "-01-01' " +
" AND a.datetime < '" + nextYear + "-01-01' ) " +
"GROUP BY u.id " +
"ORDER BY distance DESC"
data := []userDistanceData{}
err := tx.RawQuery(queryString).All(&data)
return data, err
}
func getAllUsersMostDuration(tx *pop.Connection) ([]userDuration, error) {
thisYear, nextYear := parseThisNextYear(envy.Get("ROAW_YEAR", ""))
queryString := "SELECT " +
" u.id as user_id, " +
" u.name as user, " +
" MAX(COALESCE(a.elapsed_time,0)) as duration " +
"FROM users u " +
" LEFT JOIN activities a ON a.user_id = u.id " +
"WHERE a.type IS NULL OR (a.type = 'Run' " +
" AND a.datetime >= '" + thisYear + "-01-01' " +
" AND a.datetime < '" + nextYear + "-01-01' ) " +
"GROUP BY u.id " +
"ORDER BY duration DESC"
data := []userDuration{}
err := tx.RawQuery(queryString).All(&data)
return data, err
}
// convertPodiumClass will take the 0-index and convert to podium HTML class name
func convertPodiumClass(i int) string {
switch i {
case 0:
return "table-warning" // 1st place - Gold
case 1:
return "table-secondary" // 2nd place - Silver
case 2:
return "table-danger" // 3nd place - Bronze
}
return ""
}
// DashboardHandler shows a dashboard
func DashboardHandler(c buffalo.Context) error {
// Get the DB connection from the context
tx, ok := c.Value("tx").(*pop.Connection)
if !ok {
return fmt.Errorf("no transaction found")
}
allUsersTotalDistance, err := getAllUsersTotalDistance(tx)
if err != nil {
c.Flash().Add("error", fmt.Sprintf("Error fetching total distance data: %v", err))
}
allUsersActivityCount, err := getAllUsersActivityCount(tx)
if err != nil {
c.Flash().Add("error", fmt.Sprintf("Error fetching totalactivity count: %v", err))
}
allUsersTotalDuration, err := getAllUsersTotalDuration(tx)
if err != nil {
c.Flash().Add("error", fmt.Sprintf("Error fetching total duration data: %v", err))
}
weeklyStats, err := getWeeklyDistanceStats(tx)
if err != nil {
c.Flash().Add("error", fmt.Sprintf("Error fetching weekly stats: %v", err))
}
return responder.Wants("html", func(c buffalo.Context) error {
c.Set("convertPodiumClass", convertPodiumClass)
c.Set("totalDistance", allUsersTotalDistance)
c.Set("totalCount", allUsersActivityCount)
c.Set("totalDuration", allUsersTotalDuration)
c.Set("weeklyStats", weeklyStats)
return c.Render(http.StatusOK, r.HTML("/dashboard/index.plush.html"))
}).Wants("json", func(c buffalo.Context) error {
return c.Render(200, r.JSON(allUsersTotalDistance))
}).Wants("xml", func(c buffalo.Context) error {
return c.Render(200, r.XML(allUsersTotalDistance))
}).Respond(c)
}
// DashboardOtherTopsHandler returns simple html (expected to be requested by js)
func DashboardOtherTopsHandler(c buffalo.Context) error {
// Get the DB connection from the context
tx, ok := c.Value("tx").(*pop.Connection)
if !ok {
return fmt.Errorf("no transaction found")
}
allUsersMostDistance, err := getAllUsersMostDistance(tx)
if err != nil {
c.Flash().Add("error", fmt.Sprintf("Error fetching most distance data: %v", err))
}
allUsersMostDuration, err := getAllUsersMostDuration(tx)
if err != nil {
c.Flash().Add("error", fmt.Sprintf("Error fetching most duration data: %v", err))
}
return responder.Wants("html", func(c buffalo.Context) error {
c.Set("convertPodiumClass", convertPodiumClass)
c.Set("mostDistance", allUsersMostDistance)
c.Set("mostDuration", allUsersMostDuration)
return c.Render(http.StatusOK, r.Plain("/dashboard/other-tops.plush.html"))
}).Wants("json", func(c buffalo.Context) error {
return c.Render(200, r.JSON(allUsersMostDistance))
}).Wants("xml", func(c buffalo.Context) error {
return c.Render(200, r.XML(allUsersMostDistance))
}).Respond(c)
}
|
package gcp
import (
"context"
"net/url"
"testing"
"time"
"github.com/stretchr/testify/suite"
)
var (
mod = []byte{1, 2, 3}
zip = []byte{4, 5, 6}
info = []byte{7, 8, 9}
)
type GcpTests struct {
suite.Suite
context context.Context
module string
version string
store *Storage
url *url.URL
bucket *bucketMock
}
func (g *GcpTests) SetupSuite() {
g.context = context.Background()
g.module = "gcp-test"
g.version = "v1.2.3"
g.url, _ = url.Parse("https://storage.googleapis.com/testbucket")
g.bucket = newBucketMock()
g.store = newWithBucket(g.bucket, g.url, time.Second)
}
func TestGcpStorage(t *testing.T) {
suite.Run(t, new(GcpTests))
}
|
package compress
import (
"compress/flate"
"io"
"sync"
)
type FlateWriterPool struct {
level int
pool *sync.Pool
}
func NewFlateWriterPool(level int) *FlateWriterPool {
return &FlateWriterPool{level: level, pool: &sync.Pool{}}
}
func (wp *FlateWriterPool) Get(w io.Writer) *flate.Writer {
v := wp.pool.Get()
if v != nil {
fw := v.(*flate.Writer)
fw.Reset(w)
return fw
}
fw, err := flate.NewWriter(w, wp.level)
if err != nil {
panic(err)
}
return fw
}
func (wp *FlateWriterPool) Put(fw *flate.Writer) {
// Should reset even if we do Reset() inside Get().
// This is done to prevent locking underlying io.Writer from GC.
fw.Reset(nil)
wp.pool.Put(fw)
}
type FlateReaderPool struct {
pool *sync.Pool
}
func NewFlateReaderPool() *FlateReaderPool {
return &FlateReaderPool{pool: &sync.Pool{}}
}
func (rp *FlateReaderPool) Get(r io.Reader) io.ReadCloser {
v := rp.pool.Get()
if v != nil {
v.(flate.Resetter).Reset(r, nil)
return v.(io.ReadCloser)
}
return flate.NewReader(r)
}
func (rp *FlateReaderPool) Put(r io.ReadCloser) {
// Should reset even if we do Reset() inside Get().
// This is done to prevent locking underlying io.Reader from GC.
r.(flate.Resetter).Reset(nil, nil)
rp.pool.Put(r)
}
|
package main
import (
"fmt"
"os"
"path/filepath"
"time"
)
var about = ""
func init() {
about = "List all files in a folder."
}
func main() {
fmt.Println(about)
var files []string
processfolder := "d:/DelMe100/"
err := filepath.Walk(processfolder, func(path string, info os.FileInfo, err error) error {
// No Folders in List
if info.IsDir() {
return nil
}
files = append(files, path)
return nil
})
if err != nil {
panic(err)
}
resultfile, err := os.Create("_results/files.txt")
if err != nil {
panic(err)
}
defer resultfile.Close()
for _, file := range files {
_, err = resultfile.WriteString(file + "\n")
if err != nil {
panic(err)
}
}
fmt.Println("Current time is: ", time.Now())
fmt.Println("Total amount of Files:", len(files))
}
|
package module
import (
"laravel-go/app/service/demo/module"
"laravel-go/pkg/libs"
"strconv"
"github.com/labstack/echo/v4"
)
type ModuleController struct{}
func NewModuleController() *ModuleController {
return &ModuleController{}
}
func (m *ModuleController) Find(c echo.Context) error {
id, _ := strconv.Atoi(c.Param("id"))
data, err := module.NewModuleQueryService().Find(id)
if err != nil {
return libs.NewApi().Fail(c, err.Error())
}
return libs.NewApi().Ok(c, data)
}
func (m *ModuleController) PageList(c echo.Context) error {
title := c.QueryParam("title")
page, _ := strconv.Atoi(c.QueryParam("page"))
size, _ := strconv.Atoi(c.QueryParam("size"))
datas, err := module.NewModuleQueryService().PageList(title, page, size)
if err != nil {
return libs.NewApi().Fail(c, err.Error())
}
return libs.NewApi().Ok(c, datas)
}
func (m *ModuleController) Create(c echo.Context) error {
title := c.FormValue("title")
datas, err := module.NewModuleUpdateService().Create(title)
if err != nil {
return libs.NewApi().Fail(c, err.Error())
}
return libs.NewApi().Ok(c, datas)
}
func (m *ModuleController) Update(c echo.Context) error {
id, _ := strconv.Atoi(c.Param("id"))
title := c.FormValue("title")
datas, err := module.NewModuleUpdateService().Update(id, title)
if err != nil {
return libs.NewApi().Fail(c, err.Error())
}
return libs.NewApi().Ok(c, datas)
}
func (m *ModuleController) Delete(c echo.Context) error {
id, _ := strconv.Atoi(c.Param("id"))
datas, err := module.NewModuleUpdateService().Delete(id)
if err != nil {
return libs.NewApi().Fail(c, err.Error())
}
return libs.NewApi().Ok(c, datas)
}
|
/*
Caryatid build script
Goals:
- Build single-platform binaries
- Build separate binaries for each supported architecture
- Assemble zipfiles for each supported architecture for release
Run with "go run scripts/buildrelease.go"
*/
package main
import (
"archive/zip"
"bytes"
"flag"
"fmt"
"io"
"io/ioutil"
"log"
"os"
"os/exec"
"path"
"path/filepath"
"runtime"
"strings"
)
func updateEnv(inEnv []string, name string, value string) (outEnv []string) {
for _, entry := range inEnv {
eqIdx := strings.Index(entry, "=")
if eqIdx != -1 && entry[0:eqIdx] != name {
outEnv = append(outEnv, entry)
}
}
outEnv = append(outEnv, fmt.Sprintf("%v=%v", name, value))
return
}
func getTempFilePath(directory string) (tempFilePath string, err error) {
tempFile, err := ioutil.TempFile(directory, "")
if err != nil {
return
}
tempFilePath = tempFile.Name()
tempFile.Close()
err = os.Remove(tempFilePath)
return
}
// copyFileToZip copies a file on the filesystem inside an archive represented by zipWriter
func copyFileToZip(zipWriter *zip.Writer, fsPath string, zipPath string) (err error) {
zippedFileHandle, err := zipWriter.Create(zipPath)
if err != nil {
return err
}
fsFileHandle, err := os.Open(fsPath)
defer fsFileHandle.Close()
if err != nil {
return
}
if _, err = io.Copy(zippedFileHandle, fsFileHandle); err != nil {
return
}
return
}
// readDirFullPath takes in path components and returns the absolute path of the input path's children
func readDirFullPath(pathComponents ...string) (fullPaths []string, err error) {
basePath := path.Join(pathComponents...)
pathSubItems, err := ioutil.ReadDir(basePath)
if err != nil {
return
}
for _, subItem := range pathSubItems {
p := path.Join(basePath, subItem.Name())
// fmt.Printf("- %v\n", p)
fullPaths = append(fullPaths, p)
}
return
}
// execGo executes go
func execGo(arguments []string, environment []string, pwd string) (err error) {
var (
stdout bytes.Buffer
stderr bytes.Buffer
)
cmd := exec.Command("go", arguments...)
cmd.Dir = pwd
cmd.Env = environment
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
if err != nil {
errmsg := strings.Join(
[]string{
fmt.Sprintf("Error running 'go %v'", arguments),
"Environment:", strings.Join(environment, "\n"),
"STDOUT:", stdout.String(),
"STDERR:", stderr.String(),
"Go error:", fmt.Sprintf("%v", err),
}, "\n",
)
return fmt.Errorf("%v\n", errmsg)
}
return
}
// assembleZip creates a separate zipfile for each supported platform
func assembleZip(projectRoot string, zipOutDir string, version string) (err error) {
cmdDirList, err := readDirFullPath(projectRoot, "cmd")
if err != nil {
return err
}
for _, plat := range allPlatforms {
projectName := path.Base(projectRoot)
zipBaseName := fmt.Sprintf("%v_%v_%v_%v", projectName, plat.Os, plat.Arch, version)
zipOutPath := path.Join(zipOutDir, fmt.Sprintf("%v.zip", zipBaseName))
zipOutFile, err := os.Create(zipOutPath)
defer zipOutFile.Close()
if err != nil {
return err
}
zipWriter := zip.NewWriter(zipOutFile)
defer zipWriter.Close()
copyFileToZip(zipWriter, path.Join(projectRoot, "readme.markdown"), fmt.Sprintf("%v/readme.markdown", zipBaseName))
for _, cmdDir := range cmdDirList {
cmdName := path.Base(cmdDir)
if plat.Os == "windows" {
cmdName = fmt.Sprintf("%v.exe", cmdName)
}
log.Printf("Building %v for %v...\n", cmdName, plat.String())
tempBuildOutputFile, err := getTempFilePath(projectRoot)
if err != nil {
return err
}
err = execGo([]string{"build", "-o", tempBuildOutputFile}, plat.GetEnv(), cmdDir)
defer os.Remove(tempBuildOutputFile)
if err != nil {
return err
}
if err = copyFileToZip(zipWriter, tempBuildOutputFile, fmt.Sprintf("%v/%v", zipBaseName, cmdName)); err != nil {
return err
}
}
}
return
}
// platform represents an operating system / processor architecture pair
type platform struct {
Os string
Arch string
}
// String() returns a human-readable string for a platform
func (plat *platform) String() string {
return fmt.Sprintf("%v/%v", plat.Os, plat.Arch)
}
// GetEnv() returns os.Environ() + GOOS and GOARCH based on its Os and Arch properties
func (plat *platform) GetEnv() (outEnv []string) {
return updateEnv(updateEnv(os.Environ(), "GOOS", plat.Os), "GOARCH", plat.Arch)
}
var allPlatforms = []platform{
platform{"darwin", "amd64"},
platform{"freebsd", "amd64"},
platform{"freebsd", "386"},
platform{"freebsd", "arm"},
platform{"linux", "amd64"},
platform{"linux", "386"},
platform{"linux", "arm"},
platform{"windows", "amd64"},
platform{"windows", "386"},
}
func main() {
var (
err error
outDir string
_, thisFile, _, rcOk = runtime.Caller(0)
thisDir = filepath.Dir(thisFile)
projectRootDir = filepath.Dir(thisDir)
)
if !rcOk {
panic("Could not determine build script file path")
}
outDirFlag := flag.String("outDir", path.Join(projectRootDir, "release"), "The output directory.")
versionFlag := flag.String("version", "devel", "A version number")
flag.Parse()
if outDir, err = filepath.Abs(*outDirFlag); err != nil {
panic(err)
}
if err = os.MkdirAll(outDir, 0700); err != nil {
panic(err)
}
log.Printf("Project root directory: %v\n", projectRootDir)
log.Printf("Output directory: %v\n", outDir)
if err = assembleZip(projectRootDir, outDir, *versionFlag); err != nil {
panic(err)
}
}
|
package ldap
import (
"crypto/tls"
"errors"
"fmt"
"log"
"net/url"
"strconv"
"time"
"github.com/go-ldap/ldap"
. "github.com/wealthworks/go-debug"
"github.com/liut/staffio/pkg/models"
)
// Basic LDAP authentication service
type ldapSource struct {
Addr string // LDAP address with host and port
UseSSL bool // Use SSL
Base string // Base DN
BindDN string // default reader dn
Passwd string // reader passwd
Filter string // Query filter to validate entry
Attributes []string // Select fileds
Enabled bool // if this source is disabled
c *ldap.Conn // conn
bound bool
}
var (
ErrEmptyAddr = errors.New("ldap addr is empty")
ErrEmptyBase = errors.New("ldap base is empty")
ErrLogin = errors.New("049: Invalid Username/Password")
ErrNotFound = errors.New("Not Found")
userDnFmt = "uid=%s,ou=people,%s"
debug = Debug("staffio:ldap")
)
// Add a new source (LDAP directory) to the global pool
func NewSource(cfg *Config) (*ldapSource, error) {
if cfg.Base == "" {
return nil, ErrEmptyBase
}
log.Printf("new source %s", cfg.Addr)
u, err := url.Parse(cfg.Addr)
if err != nil {
return nil, fmt.Errorf("parse LDAP addr ERR: %s", err)
}
if u.Host == "" && u.Path != "" {
u.Host = u.Path
u.Path = ""
}
var useSSL bool
if u.Scheme == "ldaps" {
useSSL = true
}
pos := last(u.Host, ':')
if pos < 0 {
if useSSL {
u.Host = u.Host + ":636"
} else {
u.Host = u.Host + ":389"
}
}
filter := etPeople.Filter
if cfg.Filter != "" {
filter = cfg.Filter
}
ls := &ldapSource{
Addr: u.Host,
UseSSL: useSSL,
Base: cfg.Base,
BindDN: cfg.Bind,
Passwd: cfg.Passwd,
Filter: filter,
Attributes: etPeople.Attributes,
Enabled: true,
}
return ls, nil
}
func (s *LDAPStore) Close() {
for _, ls := range s.sources {
ls.Close()
}
}
func (ls *ldapSource) String() string {
return ls.Addr
}
func (ls *ldapSource) dial() (*ldap.Conn, error) {
if ls.c != nil {
return ls.c, nil
}
var err error
if ls.UseSSL {
ls.c, err = ldap.DialTLS("tcp", ls.Addr, &tls.Config{InsecureSkipVerify: true})
} else {
ls.c, err = ldap.Dial("tcp", ls.Addr)
}
if err != nil {
log.Printf("LDAP Connect error, %s:%v", ls.Addr, err)
ls.Enabled = false
return nil, err
}
debug("connect to %s ok", ls.Addr)
return ls.c, nil
}
func (ls *ldapSource) Close() {
ls.bound = false
if ls.c != nil {
ls.c.Close()
ls.c = nil
}
}
func (ls *ldapSource) UDN(uid string) string {
return etPeople.DN(uid)
}
func (ls *ldapSource) Ready() (err error) {
err = ls.Bind(ls.BindDN, ls.Passwd, false)
if err == nil {
if err = ls.readyBase(); err != nil {
return
}
err = ls.readyParent("groups")
if err == nil {
err = ls.readyParent("people")
}
}
return
}
func (ls *ldapSource) readyBase() (err error) {
dn := Base
_, err = ls.Entry(dn, etBase.Filter, etBase.Attributes...)
if err == ErrNotFound {
ar := ldap.NewAddRequest(dn)
ar.Attribute("objectClass", []string{etBase.OC, "organization", "top"})
ar.Attribute("o", []string{Domain})
ar.Attribute(etBase.PK, []string{splitDC(Base)})
debug("add %v", ar)
err = ls.c.Add(ar)
if err != nil {
debug("add %q, ERR: %s", dn, err)
} else {
debug("add %q OK", dn)
}
}
return
}
func (ls *ldapSource) readyParent(name string) (err error) {
dn := etParent.DN(name)
_, err = ls.Entry(dn, etParent.Filter, etParent.Attributes...)
if err == ErrNotFound {
debug("ready parent %s, ERR %s", name, err)
ar := ldap.NewAddRequest(dn)
ar.Attribute("objectClass", []string{etParent.OC, "top"})
ar.Attribute(etParent.PK, []string{name})
err = ls.c.Add(ar)
if err != nil {
debug("add %q, ERR: %s", dn, err)
}
}
return
}
func (ls *ldapSource) Bind(dn, passwd string, force bool) error {
if !force && ls.bound {
return nil
}
l, err := ls.dial()
if err != nil {
return err
}
err = l.Bind(dn, passwd)
if err != nil {
log.Printf("LDAP Bind failed for %s, reason: %s", dn, err.Error())
if le, ok := err.(*ldap.Error); ok {
if le.ResultCode == 49 {
return ErrLogin
}
}
return err
}
debug("bind(%s, ***) ok", dn)
ls.bound = true
return nil
}
// deprecated with Entry(dn, filter string, attrs ...string)
func (ls *ldapSource) getEntry(udn string) (*ldap.Entry, error) {
return ls.Entry(udn, ls.Filter, ls.Attributes...)
}
func (ls *ldapSource) Group(cn string) (*ldap.Entry, error) {
return ls.Entry(ls.GDN(cn), etGroup.Filter, etGroup.Attributes...)
}
func (ls *ldapSource) People(uid string) (*ldap.Entry, error) {
return ls.Entry(ls.UDN(uid), ls.Filter, ls.Attributes...)
}
// Entry return a special entry with dn and filter
func (ls *ldapSource) Entry(dn, filter string, attrs ...string) (*ldap.Entry, error) {
if !ls.bound {
err := ls.Bind(ls.BindDN, ls.Passwd, false)
if err != nil {
return nil, err
}
}
search := ldap.NewSearchRequest(
dn,
ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false,
filter,
attrs,
nil)
sr, err := ls.c.Search(search)
if err == nil {
if len(sr.Entries) > 0 {
return sr.Entries[0], nil
}
return nil, ErrNotFound
}
debug("ldap search %q, ERR: %s", dn, err)
if le, ok := err.(*ldap.Error); ok && le.ResultCode == ldap.LDAPResultNoSuchObject {
return nil, ErrNotFound
}
log.Printf("LDAP Search '%s' Error: %s", dn, err)
return nil, err
}
// GetStaff : search an LDAP source if an entry (with uid) is valide and in the specific filter
func (ls *ldapSource) GetStaff(uid string) (*models.Staff, error) {
err := ls.Bind(ls.BindDN, ls.Passwd, false)
if err != nil {
log.Printf("bind faild %s", err)
return nil, err
}
entry, err := ls.getEntry(ls.UDN(uid))
if err != nil {
log.Printf("getEntry(%s) ERR %s", uid, err)
return nil, err
}
return entryToUser(entry), nil
}
func (ls *ldapSource) ListPaged(limit int) (staffs models.Staffs) {
err := ls.Bind(ls.BindDN, ls.Passwd, false)
if err != nil {
// log.Printf("ERROR: Cannot bind: %s\n", err.Error())
return nil
}
if limit < 1 {
limit = 1
}
search := ldap.NewSearchRequest(
"ou=people,"+ls.Base,
ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false,
ls.Filter,
ls.Attributes,
nil)
sr, err := ls.c.SearchWithPaging(search, uint32(limit))
if err != nil {
log.Printf("ERROR: %s for search %v\n", err, search)
return
}
if len(sr.Entries) > 0 {
staffs = make(models.Staffs, len(sr.Entries))
for i, entry := range sr.Entries {
staffs[i] = entryToUser(entry)
}
}
return
}
func entryToUser(entry *ldap.Entry) (u *models.Staff) {
// log.Printf("entry: %v", entry)
u = &models.Staff{
Uid: entry.GetAttributeValue("uid"),
Surname: entry.GetAttributeValue("sn"),
GivenName: entry.GetAttributeValue("givenName"),
CommonName: entry.GetAttributeValue("cn"),
Email: entry.GetAttributeValue("mail"),
Nickname: entry.GetAttributeValue("displayName"),
Mobile: entry.GetAttributeValue("mobile"),
EmployeeType: entry.GetAttributeValue("employeeType"),
Birthday: entry.GetAttributeValue("dateOfBirth"),
AvatarPath: entry.GetAttributeValue("avatarPath"),
Description: entry.GetAttributeValue("description"),
JoinDate: entry.GetAttributeValue("dateOfJoin"),
IDCN: entry.GetAttributeValue("idcnNumber"),
}
(&u.Gender).UnmarshalText(entry.GetRawAttributeValue("gender"))
var err error
if str := entry.GetAttributeValue("employeeNumber"); str != "" {
u.EmployeeNumber, err = strconv.Atoi(str)
if err != nil {
log.Printf("invalid employee number %q, ERR %s", str, err)
}
}
if str := entry.GetAttributeValue("createdTime"); str != "" {
u.Created, err = time.Parse(timeLayout, str)
if err != nil {
log.Printf("invalid time %s, ERR %s", str, err)
}
} else if str := entry.GetAttributeValue("createTimestamp"); str != "" {
u.Created, err = time.Parse(timeLayout, str)
if err != nil {
log.Printf("invalid time %s, ERR %s", str, err)
}
}
if str := entry.GetAttributeValue("modifiedTime"); str != "" {
u.Updated, err = time.Parse(timeLayout, str)
if err != nil {
log.Printf("invalid time %s, ERR %s", str, err)
}
} else if str := entry.GetAttributeValue("modifyTimestamp"); str != "" {
u.Updated, err = time.Parse(timeLayout, str)
if err != nil {
log.Printf("invalid time %s, ERR %s", str, err)
}
}
if blob := entry.GetRawAttributeValue("jpegPhoto"); len(blob) > 0 {
u.JpegPhoto = blob
}
return
}
// Index of rightmost occurrence of b in s.
func last(s string, b byte) int {
i := len(s)
for i--; i >= 0; i-- {
if s[i] == b {
break
}
}
return i
}
|
package console
import (
"os"
"github.com/danielchatfield/go-console/logentry"
)
// Status represents the status of the task
type Status int
// The Status constants
const (
SUCCESS Status = iota
WARNING
FAILURE
)
var (
console = NewConsole()
)
// Console is the interface that wraps the basic logging functions.
type Console interface {
Log(arg interface{}) (n int, err error)
}
// NewConsole returns a new InteractiveConsole if the current terminal supports
// interactivity otherwise returns a SimpleConsole
func NewConsole() Console {
return NewInteractiveConsole(os.Stdout)
}
// Log logs using the default console
func Log(msg interface{}) (n int, err error) {
return console.Log(msg)
}
// LogCommand creates a new CommandLogEntry, logs it and returns it
func LogCommand(cmd string) *logentry.Command {
c := logentry.NewCommand(cmd, "")
console.Log(c)
return c
}
// LogSection logs a section header
func LogSection(str string) {
c := logentry.NewSection(str)
console.Log(c)
}
|
package main
import "fmt"
func main() {
test := "abbz"
//letter := 0
final := ""
for _, x := range test {
if (x == 90){
final += string(65)
continue
}
if(x == 122){
final += string(97)
continue
}
final += string(x + 1)
//fmt.Println(string(x +1))
}
fmt.Println(final)
}
|
// Copyright 2023 Google LLC. All Rights Reserved.
//
// 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 server
import (
"context"
"github.com/GoogleCloudPlatform/declarative-resource-client-library/dcl"
emptypb "github.com/GoogleCloudPlatform/declarative-resource-client-library/python/proto/empty_go_proto"
monitoringpb "github.com/GoogleCloudPlatform/declarative-resource-client-library/python/proto/monitoring/monitoring_go_proto"
"github.com/GoogleCloudPlatform/declarative-resource-client-library/services/google/monitoring"
)
// UptimeCheckConfigServer implements the gRPC interface for UptimeCheckConfig.
type UptimeCheckConfigServer struct{}
// ProtoToUptimeCheckConfigResourceGroupResourceTypeEnum converts a UptimeCheckConfigResourceGroupResourceTypeEnum enum from its proto representation.
func ProtoToMonitoringUptimeCheckConfigResourceGroupResourceTypeEnum(e monitoringpb.MonitoringUptimeCheckConfigResourceGroupResourceTypeEnum) *monitoring.UptimeCheckConfigResourceGroupResourceTypeEnum {
if e == 0 {
return nil
}
if n, ok := monitoringpb.MonitoringUptimeCheckConfigResourceGroupResourceTypeEnum_name[int32(e)]; ok {
e := monitoring.UptimeCheckConfigResourceGroupResourceTypeEnum(n[len("MonitoringUptimeCheckConfigResourceGroupResourceTypeEnum"):])
return &e
}
return nil
}
// ProtoToUptimeCheckConfigHttpCheckRequestMethodEnum converts a UptimeCheckConfigHttpCheckRequestMethodEnum enum from its proto representation.
func ProtoToMonitoringUptimeCheckConfigHttpCheckRequestMethodEnum(e monitoringpb.MonitoringUptimeCheckConfigHttpCheckRequestMethodEnum) *monitoring.UptimeCheckConfigHttpCheckRequestMethodEnum {
if e == 0 {
return nil
}
if n, ok := monitoringpb.MonitoringUptimeCheckConfigHttpCheckRequestMethodEnum_name[int32(e)]; ok {
e := monitoring.UptimeCheckConfigHttpCheckRequestMethodEnum(n[len("MonitoringUptimeCheckConfigHttpCheckRequestMethodEnum"):])
return &e
}
return nil
}
// ProtoToUptimeCheckConfigHttpCheckContentTypeEnum converts a UptimeCheckConfigHttpCheckContentTypeEnum enum from its proto representation.
func ProtoToMonitoringUptimeCheckConfigHttpCheckContentTypeEnum(e monitoringpb.MonitoringUptimeCheckConfigHttpCheckContentTypeEnum) *monitoring.UptimeCheckConfigHttpCheckContentTypeEnum {
if e == 0 {
return nil
}
if n, ok := monitoringpb.MonitoringUptimeCheckConfigHttpCheckContentTypeEnum_name[int32(e)]; ok {
e := monitoring.UptimeCheckConfigHttpCheckContentTypeEnum(n[len("MonitoringUptimeCheckConfigHttpCheckContentTypeEnum"):])
return &e
}
return nil
}
// ProtoToUptimeCheckConfigContentMatchersMatcherEnum converts a UptimeCheckConfigContentMatchersMatcherEnum enum from its proto representation.
func ProtoToMonitoringUptimeCheckConfigContentMatchersMatcherEnum(e monitoringpb.MonitoringUptimeCheckConfigContentMatchersMatcherEnum) *monitoring.UptimeCheckConfigContentMatchersMatcherEnum {
if e == 0 {
return nil
}
if n, ok := monitoringpb.MonitoringUptimeCheckConfigContentMatchersMatcherEnum_name[int32(e)]; ok {
e := monitoring.UptimeCheckConfigContentMatchersMatcherEnum(n[len("MonitoringUptimeCheckConfigContentMatchersMatcherEnum"):])
return &e
}
return nil
}
// ProtoToUptimeCheckConfigMonitoredResource converts a UptimeCheckConfigMonitoredResource object from its proto representation.
func ProtoToMonitoringUptimeCheckConfigMonitoredResource(p *monitoringpb.MonitoringUptimeCheckConfigMonitoredResource) *monitoring.UptimeCheckConfigMonitoredResource {
if p == nil {
return nil
}
obj := &monitoring.UptimeCheckConfigMonitoredResource{
Type: dcl.StringOrNil(p.GetType()),
}
return obj
}
// ProtoToUptimeCheckConfigResourceGroup converts a UptimeCheckConfigResourceGroup object from its proto representation.
func ProtoToMonitoringUptimeCheckConfigResourceGroup(p *monitoringpb.MonitoringUptimeCheckConfigResourceGroup) *monitoring.UptimeCheckConfigResourceGroup {
if p == nil {
return nil
}
obj := &monitoring.UptimeCheckConfigResourceGroup{
GroupId: dcl.StringOrNil(p.GetGroupId()),
ResourceType: ProtoToMonitoringUptimeCheckConfigResourceGroupResourceTypeEnum(p.GetResourceType()),
}
return obj
}
// ProtoToUptimeCheckConfigHttpCheck converts a UptimeCheckConfigHttpCheck object from its proto representation.
func ProtoToMonitoringUptimeCheckConfigHttpCheck(p *monitoringpb.MonitoringUptimeCheckConfigHttpCheck) *monitoring.UptimeCheckConfigHttpCheck {
if p == nil {
return nil
}
obj := &monitoring.UptimeCheckConfigHttpCheck{
RequestMethod: ProtoToMonitoringUptimeCheckConfigHttpCheckRequestMethodEnum(p.GetRequestMethod()),
UseSsl: dcl.Bool(p.GetUseSsl()),
Path: dcl.StringOrNil(p.GetPath()),
Port: dcl.Int64OrNil(p.GetPort()),
AuthInfo: ProtoToMonitoringUptimeCheckConfigHttpCheckAuthInfo(p.GetAuthInfo()),
MaskHeaders: dcl.Bool(p.GetMaskHeaders()),
ContentType: ProtoToMonitoringUptimeCheckConfigHttpCheckContentTypeEnum(p.GetContentType()),
ValidateSsl: dcl.Bool(p.GetValidateSsl()),
Body: dcl.StringOrNil(p.GetBody()),
}
return obj
}
// ProtoToUptimeCheckConfigHttpCheckAuthInfo converts a UptimeCheckConfigHttpCheckAuthInfo object from its proto representation.
func ProtoToMonitoringUptimeCheckConfigHttpCheckAuthInfo(p *monitoringpb.MonitoringUptimeCheckConfigHttpCheckAuthInfo) *monitoring.UptimeCheckConfigHttpCheckAuthInfo {
if p == nil {
return nil
}
obj := &monitoring.UptimeCheckConfigHttpCheckAuthInfo{
Username: dcl.StringOrNil(p.GetUsername()),
Password: dcl.StringOrNil(p.GetPassword()),
}
return obj
}
// ProtoToUptimeCheckConfigTcpCheck converts a UptimeCheckConfigTcpCheck object from its proto representation.
func ProtoToMonitoringUptimeCheckConfigTcpCheck(p *monitoringpb.MonitoringUptimeCheckConfigTcpCheck) *monitoring.UptimeCheckConfigTcpCheck {
if p == nil {
return nil
}
obj := &monitoring.UptimeCheckConfigTcpCheck{
Port: dcl.Int64OrNil(p.GetPort()),
}
return obj
}
// ProtoToUptimeCheckConfigContentMatchers converts a UptimeCheckConfigContentMatchers object from its proto representation.
func ProtoToMonitoringUptimeCheckConfigContentMatchers(p *monitoringpb.MonitoringUptimeCheckConfigContentMatchers) *monitoring.UptimeCheckConfigContentMatchers {
if p == nil {
return nil
}
obj := &monitoring.UptimeCheckConfigContentMatchers{
Content: dcl.StringOrNil(p.GetContent()),
Matcher: ProtoToMonitoringUptimeCheckConfigContentMatchersMatcherEnum(p.GetMatcher()),
}
return obj
}
// ProtoToUptimeCheckConfig converts a UptimeCheckConfig resource from its proto representation.
func ProtoToUptimeCheckConfig(p *monitoringpb.MonitoringUptimeCheckConfig) *monitoring.UptimeCheckConfig {
obj := &monitoring.UptimeCheckConfig{
Name: dcl.StringOrNil(p.GetName()),
DisplayName: dcl.StringOrNil(p.GetDisplayName()),
MonitoredResource: ProtoToMonitoringUptimeCheckConfigMonitoredResource(p.GetMonitoredResource()),
ResourceGroup: ProtoToMonitoringUptimeCheckConfigResourceGroup(p.GetResourceGroup()),
HttpCheck: ProtoToMonitoringUptimeCheckConfigHttpCheck(p.GetHttpCheck()),
TcpCheck: ProtoToMonitoringUptimeCheckConfigTcpCheck(p.GetTcpCheck()),
Period: dcl.StringOrNil(p.GetPeriod()),
Timeout: dcl.StringOrNil(p.GetTimeout()),
Project: dcl.StringOrNil(p.GetProject()),
}
for _, r := range p.GetContentMatchers() {
obj.ContentMatchers = append(obj.ContentMatchers, *ProtoToMonitoringUptimeCheckConfigContentMatchers(r))
}
for _, r := range p.GetSelectedRegions() {
obj.SelectedRegions = append(obj.SelectedRegions, r)
}
return obj
}
// UptimeCheckConfigResourceGroupResourceTypeEnumToProto converts a UptimeCheckConfigResourceGroupResourceTypeEnum enum to its proto representation.
func MonitoringUptimeCheckConfigResourceGroupResourceTypeEnumToProto(e *monitoring.UptimeCheckConfigResourceGroupResourceTypeEnum) monitoringpb.MonitoringUptimeCheckConfigResourceGroupResourceTypeEnum {
if e == nil {
return monitoringpb.MonitoringUptimeCheckConfigResourceGroupResourceTypeEnum(0)
}
if v, ok := monitoringpb.MonitoringUptimeCheckConfigResourceGroupResourceTypeEnum_value["UptimeCheckConfigResourceGroupResourceTypeEnum"+string(*e)]; ok {
return monitoringpb.MonitoringUptimeCheckConfigResourceGroupResourceTypeEnum(v)
}
return monitoringpb.MonitoringUptimeCheckConfigResourceGroupResourceTypeEnum(0)
}
// UptimeCheckConfigHttpCheckRequestMethodEnumToProto converts a UptimeCheckConfigHttpCheckRequestMethodEnum enum to its proto representation.
func MonitoringUptimeCheckConfigHttpCheckRequestMethodEnumToProto(e *monitoring.UptimeCheckConfigHttpCheckRequestMethodEnum) monitoringpb.MonitoringUptimeCheckConfigHttpCheckRequestMethodEnum {
if e == nil {
return monitoringpb.MonitoringUptimeCheckConfigHttpCheckRequestMethodEnum(0)
}
if v, ok := monitoringpb.MonitoringUptimeCheckConfigHttpCheckRequestMethodEnum_value["UptimeCheckConfigHttpCheckRequestMethodEnum"+string(*e)]; ok {
return monitoringpb.MonitoringUptimeCheckConfigHttpCheckRequestMethodEnum(v)
}
return monitoringpb.MonitoringUptimeCheckConfigHttpCheckRequestMethodEnum(0)
}
// UptimeCheckConfigHttpCheckContentTypeEnumToProto converts a UptimeCheckConfigHttpCheckContentTypeEnum enum to its proto representation.
func MonitoringUptimeCheckConfigHttpCheckContentTypeEnumToProto(e *monitoring.UptimeCheckConfigHttpCheckContentTypeEnum) monitoringpb.MonitoringUptimeCheckConfigHttpCheckContentTypeEnum {
if e == nil {
return monitoringpb.MonitoringUptimeCheckConfigHttpCheckContentTypeEnum(0)
}
if v, ok := monitoringpb.MonitoringUptimeCheckConfigHttpCheckContentTypeEnum_value["UptimeCheckConfigHttpCheckContentTypeEnum"+string(*e)]; ok {
return monitoringpb.MonitoringUptimeCheckConfigHttpCheckContentTypeEnum(v)
}
return monitoringpb.MonitoringUptimeCheckConfigHttpCheckContentTypeEnum(0)
}
// UptimeCheckConfigContentMatchersMatcherEnumToProto converts a UptimeCheckConfigContentMatchersMatcherEnum enum to its proto representation.
func MonitoringUptimeCheckConfigContentMatchersMatcherEnumToProto(e *monitoring.UptimeCheckConfigContentMatchersMatcherEnum) monitoringpb.MonitoringUptimeCheckConfigContentMatchersMatcherEnum {
if e == nil {
return monitoringpb.MonitoringUptimeCheckConfigContentMatchersMatcherEnum(0)
}
if v, ok := monitoringpb.MonitoringUptimeCheckConfigContentMatchersMatcherEnum_value["UptimeCheckConfigContentMatchersMatcherEnum"+string(*e)]; ok {
return monitoringpb.MonitoringUptimeCheckConfigContentMatchersMatcherEnum(v)
}
return monitoringpb.MonitoringUptimeCheckConfigContentMatchersMatcherEnum(0)
}
// UptimeCheckConfigMonitoredResourceToProto converts a UptimeCheckConfigMonitoredResource object to its proto representation.
func MonitoringUptimeCheckConfigMonitoredResourceToProto(o *monitoring.UptimeCheckConfigMonitoredResource) *monitoringpb.MonitoringUptimeCheckConfigMonitoredResource {
if o == nil {
return nil
}
p := &monitoringpb.MonitoringUptimeCheckConfigMonitoredResource{}
p.SetType(dcl.ValueOrEmptyString(o.Type))
mFilterLabels := make(map[string]string, len(o.FilterLabels))
for k, r := range o.FilterLabels {
mFilterLabels[k] = r
}
p.SetFilterLabels(mFilterLabels)
return p
}
// UptimeCheckConfigResourceGroupToProto converts a UptimeCheckConfigResourceGroup object to its proto representation.
func MonitoringUptimeCheckConfigResourceGroupToProto(o *monitoring.UptimeCheckConfigResourceGroup) *monitoringpb.MonitoringUptimeCheckConfigResourceGroup {
if o == nil {
return nil
}
p := &monitoringpb.MonitoringUptimeCheckConfigResourceGroup{}
p.SetGroupId(dcl.ValueOrEmptyString(o.GroupId))
p.SetResourceType(MonitoringUptimeCheckConfigResourceGroupResourceTypeEnumToProto(o.ResourceType))
return p
}
// UptimeCheckConfigHttpCheckToProto converts a UptimeCheckConfigHttpCheck object to its proto representation.
func MonitoringUptimeCheckConfigHttpCheckToProto(o *monitoring.UptimeCheckConfigHttpCheck) *monitoringpb.MonitoringUptimeCheckConfigHttpCheck {
if o == nil {
return nil
}
p := &monitoringpb.MonitoringUptimeCheckConfigHttpCheck{}
p.SetRequestMethod(MonitoringUptimeCheckConfigHttpCheckRequestMethodEnumToProto(o.RequestMethod))
p.SetUseSsl(dcl.ValueOrEmptyBool(o.UseSsl))
p.SetPath(dcl.ValueOrEmptyString(o.Path))
p.SetPort(dcl.ValueOrEmptyInt64(o.Port))
p.SetAuthInfo(MonitoringUptimeCheckConfigHttpCheckAuthInfoToProto(o.AuthInfo))
p.SetMaskHeaders(dcl.ValueOrEmptyBool(o.MaskHeaders))
p.SetContentType(MonitoringUptimeCheckConfigHttpCheckContentTypeEnumToProto(o.ContentType))
p.SetValidateSsl(dcl.ValueOrEmptyBool(o.ValidateSsl))
p.SetBody(dcl.ValueOrEmptyString(o.Body))
mHeaders := make(map[string]string, len(o.Headers))
for k, r := range o.Headers {
mHeaders[k] = r
}
p.SetHeaders(mHeaders)
return p
}
// UptimeCheckConfigHttpCheckAuthInfoToProto converts a UptimeCheckConfigHttpCheckAuthInfo object to its proto representation.
func MonitoringUptimeCheckConfigHttpCheckAuthInfoToProto(o *monitoring.UptimeCheckConfigHttpCheckAuthInfo) *monitoringpb.MonitoringUptimeCheckConfigHttpCheckAuthInfo {
if o == nil {
return nil
}
p := &monitoringpb.MonitoringUptimeCheckConfigHttpCheckAuthInfo{}
p.SetUsername(dcl.ValueOrEmptyString(o.Username))
p.SetPassword(dcl.ValueOrEmptyString(o.Password))
return p
}
// UptimeCheckConfigTcpCheckToProto converts a UptimeCheckConfigTcpCheck object to its proto representation.
func MonitoringUptimeCheckConfigTcpCheckToProto(o *monitoring.UptimeCheckConfigTcpCheck) *monitoringpb.MonitoringUptimeCheckConfigTcpCheck {
if o == nil {
return nil
}
p := &monitoringpb.MonitoringUptimeCheckConfigTcpCheck{}
p.SetPort(dcl.ValueOrEmptyInt64(o.Port))
return p
}
// UptimeCheckConfigContentMatchersToProto converts a UptimeCheckConfigContentMatchers object to its proto representation.
func MonitoringUptimeCheckConfigContentMatchersToProto(o *monitoring.UptimeCheckConfigContentMatchers) *monitoringpb.MonitoringUptimeCheckConfigContentMatchers {
if o == nil {
return nil
}
p := &monitoringpb.MonitoringUptimeCheckConfigContentMatchers{}
p.SetContent(dcl.ValueOrEmptyString(o.Content))
p.SetMatcher(MonitoringUptimeCheckConfigContentMatchersMatcherEnumToProto(o.Matcher))
return p
}
// UptimeCheckConfigToProto converts a UptimeCheckConfig resource to its proto representation.
func UptimeCheckConfigToProto(resource *monitoring.UptimeCheckConfig) *monitoringpb.MonitoringUptimeCheckConfig {
p := &monitoringpb.MonitoringUptimeCheckConfig{}
p.SetName(dcl.ValueOrEmptyString(resource.Name))
p.SetDisplayName(dcl.ValueOrEmptyString(resource.DisplayName))
p.SetMonitoredResource(MonitoringUptimeCheckConfigMonitoredResourceToProto(resource.MonitoredResource))
p.SetResourceGroup(MonitoringUptimeCheckConfigResourceGroupToProto(resource.ResourceGroup))
p.SetHttpCheck(MonitoringUptimeCheckConfigHttpCheckToProto(resource.HttpCheck))
p.SetTcpCheck(MonitoringUptimeCheckConfigTcpCheckToProto(resource.TcpCheck))
p.SetPeriod(dcl.ValueOrEmptyString(resource.Period))
p.SetTimeout(dcl.ValueOrEmptyString(resource.Timeout))
p.SetProject(dcl.ValueOrEmptyString(resource.Project))
sContentMatchers := make([]*monitoringpb.MonitoringUptimeCheckConfigContentMatchers, len(resource.ContentMatchers))
for i, r := range resource.ContentMatchers {
sContentMatchers[i] = MonitoringUptimeCheckConfigContentMatchersToProto(&r)
}
p.SetContentMatchers(sContentMatchers)
sSelectedRegions := make([]string, len(resource.SelectedRegions))
for i, r := range resource.SelectedRegions {
sSelectedRegions[i] = r
}
p.SetSelectedRegions(sSelectedRegions)
return p
}
// applyUptimeCheckConfig handles the gRPC request by passing it to the underlying UptimeCheckConfig Apply() method.
func (s *UptimeCheckConfigServer) applyUptimeCheckConfig(ctx context.Context, c *monitoring.Client, request *monitoringpb.ApplyMonitoringUptimeCheckConfigRequest) (*monitoringpb.MonitoringUptimeCheckConfig, error) {
p := ProtoToUptimeCheckConfig(request.GetResource())
res, err := c.ApplyUptimeCheckConfig(ctx, p)
if err != nil {
return nil, err
}
r := UptimeCheckConfigToProto(res)
return r, nil
}
// applyMonitoringUptimeCheckConfig handles the gRPC request by passing it to the underlying UptimeCheckConfig Apply() method.
func (s *UptimeCheckConfigServer) ApplyMonitoringUptimeCheckConfig(ctx context.Context, request *monitoringpb.ApplyMonitoringUptimeCheckConfigRequest) (*monitoringpb.MonitoringUptimeCheckConfig, error) {
cl, err := createConfigUptimeCheckConfig(ctx, request.GetServiceAccountFile())
if err != nil {
return nil, err
}
return s.applyUptimeCheckConfig(ctx, cl, request)
}
// DeleteUptimeCheckConfig handles the gRPC request by passing it to the underlying UptimeCheckConfig Delete() method.
func (s *UptimeCheckConfigServer) DeleteMonitoringUptimeCheckConfig(ctx context.Context, request *monitoringpb.DeleteMonitoringUptimeCheckConfigRequest) (*emptypb.Empty, error) {
cl, err := createConfigUptimeCheckConfig(ctx, request.GetServiceAccountFile())
if err != nil {
return nil, err
}
return &emptypb.Empty{}, cl.DeleteUptimeCheckConfig(ctx, ProtoToUptimeCheckConfig(request.GetResource()))
}
// ListMonitoringUptimeCheckConfig handles the gRPC request by passing it to the underlying UptimeCheckConfigList() method.
func (s *UptimeCheckConfigServer) ListMonitoringUptimeCheckConfig(ctx context.Context, request *monitoringpb.ListMonitoringUptimeCheckConfigRequest) (*monitoringpb.ListMonitoringUptimeCheckConfigResponse, error) {
cl, err := createConfigUptimeCheckConfig(ctx, request.GetServiceAccountFile())
if err != nil {
return nil, err
}
resources, err := cl.ListUptimeCheckConfig(ctx, request.GetProject())
if err != nil {
return nil, err
}
var protos []*monitoringpb.MonitoringUptimeCheckConfig
for _, r := range resources.Items {
rp := UptimeCheckConfigToProto(r)
protos = append(protos, rp)
}
p := &monitoringpb.ListMonitoringUptimeCheckConfigResponse{}
p.SetItems(protos)
return p, nil
}
func createConfigUptimeCheckConfig(ctx context.Context, service_account_file string) (*monitoring.Client, error) {
conf := dcl.NewConfig(dcl.WithUserAgent("dcl-test"), dcl.WithCredentialsFile(service_account_file))
return monitoring.NewClient(conf), nil
}
|
/*
* @lc app=leetcode.cn id=852 lang=golang
*
* [852] 山脉数组的峰顶索引
*/
package main
// @lc code=start
func peakIndexInMountainArray(arr []int) int {
for i := 1; i < len(arr); i++ {
if arr[i] < arr[i-1] {
return i - 1
}
}
return -1
}
// func main() {
// fmt.Println(peakIndexInMountainArray([]int{0, 1, 0}))
// }
// @lc code=end
|
package configure
/*
import (
"io/ioutil"
"os"
"testing"
"github.com/devspace-cloud/devspace/pkg/devspace/config/loader"
"github.com/devspace-cloud/devspace/pkg/devspace/config/versions/latest"
"github.com/devspace-cloud/devspace/pkg/util/log"
"gotest.tools/assert"
)
type addSyncPathTestCase struct {
name string
fakeConfig *latest.Config
localPathParam string
containerPathParam string
namespace string
labelSelectorParam string
excludedPathsStringParam string
expectedErr string
expectedSyncInConfig []*latest.SyncConfig
}
func TestAddSyncPath(t *testing.T) {
testCases := []addSyncPathTestCase{
addSyncPathTestCase{
name: "Add sync path with wrong containerPath",
containerPathParam: " ",
expectedErr: "ContainerPath (--container) must start with '/'. Info: There is an issue with MINGW based terminals like git bash",
},
addSyncPathTestCase{
name: "Add sync path with success",
fakeConfig: &latest.Config{},
containerPathParam: "/containerPath",
excludedPathsStringParam: "./ExcludeThis",
labelSelectorParam: "Hello=World",
expectedSyncInConfig: []*latest.SyncConfig{
&latest.SyncConfig{
LabelSelector: map[string]string{"Hello": "World"},
ContainerPath: "/containerPath",
LocalSubPath: "",
ExcludePaths: []string{"./ExcludeThis"},
Namespace: "",
},
},
},
}
//Make temporary test dir
dir, err := ioutil.TempDir("", "testDir")
if err != nil {
t.Fatalf("Error creating temporary directory: %v", err)
}
wdBackup, err := os.Getwd()
if err != nil {
t.Fatalf("Error getting current working directory: %v", err)
}
err = os.Chdir(dir)
if err != nil {
t.Fatalf("Error changing working directory: %v", err)
}
// 8. Delete temp folder
defer func() {
err = os.Chdir(wdBackup)
if err != nil {
t.Fatalf("Error changing dir back: %v", err)
}
err = os.RemoveAll(dir)
if err != nil {
t.Fatalf("Error removing dir: %v", err)
}
}()
for _, testCase := range testCases {
if testCase.fakeConfig == nil {
testCase.fakeConfig = &latest.Config{}
} else {
loader.SetFakeConfig(testCase.fakeConfig)
}
err = AddSyncPath(testCase.fakeConfig, testCase.localPathParam, testCase.containerPathParam, testCase.namespace, testCase.labelSelectorParam, testCase.excludedPathsStringParam)
if testCase.expectedErr == "" {
assert.NilError(t, err, "Error adding sync path in testCase %s", testCase.name)
} else {
assert.Error(t, err, testCase.expectedErr, "Wrong or no error from AddSyncPath in testCase %s", testCase.name)
}
assert.Equal(t, len(testCase.fakeConfig.Dev.Sync), len(testCase.expectedSyncInConfig), "Wrong number of syncs after adding in testCase %s", testCase.name)
for index := range testCase.expectedSyncInConfig {
for key, value := range testCase.expectedSyncInConfig[index].LabelSelector {
assert.Equal(t, value, testCase.fakeConfig.Dev.Sync[index].LabelSelector[key], "Wrong labelSelectorMap in added sync in testCase %s", testCase.name)
}
assert.Equal(t, testCase.expectedSyncInConfig[index].ContainerPath, testCase.fakeConfig.Dev.Sync[index].ContainerPath, "Wrong containerPath in added sync in testCase %s", testCase.name)
assert.Equal(t, testCase.expectedSyncInConfig[index].LocalSubPath, testCase.fakeConfig.Dev.Sync[index].LocalSubPath, "Wrong LocalSubPath in added sync in testCase %s", testCase.name)
for excludePathIndex, excludePath := range testCase.expectedSyncInConfig[index].ExcludePaths {
assert.Equal(t, excludePath, testCase.fakeConfig.Dev.Sync[index].ExcludePaths[excludePathIndex], "Wrong excluded path in added sync in testCase %s", testCase.name)
}
assert.Equal(t, testCase.expectedSyncInConfig[index].Namespace, testCase.fakeConfig.Dev.Sync[index].Namespace, "Wrong Namespace in added sync in testCase %s", testCase.name)
}
}
}
type removeSyncPathTestCase struct {
name string
fakeConfig *latest.Config
removeAllParam bool
localPathParam string
containerPathParam string
labelSelectorParam string
expectedErr string
expectedSyncPathLocalPaths []string
}
func TestRemoveSyncPath(t *testing.T) {
testCases := []removeSyncPathTestCase{
removeSyncPathTestCase{
name: "No flag",
fakeConfig: nil, //default config has two syncPaths
expectedErr: "You have to specify at least one of the supported flags",
expectedSyncPathLocalPaths: []string{"somePath", "someOtherPath"},
},
removeSyncPathTestCase{
name: "Remove all",
fakeConfig: nil, //default config has two syncPaths
removeAllParam: true,
},
removeSyncPathTestCase{
name: "Remove one by local file",
fakeConfig: nil, //default config has two syncPaths
localPathParam: "somePath",
expectedSyncPathLocalPaths: []string{"someOtherPath"},
},
removeSyncPathTestCase{
name: "Remove one by labelSelectorMap",
fakeConfig: nil, //default config has two syncPaths
labelSelectorParam: "index=secound",
expectedSyncPathLocalPaths: []string{"somePath"},
},
}
//Make temporary test dir
dir, err := ioutil.TempDir("", "testDir")
if err != nil {
t.Fatalf("Error creating temporary directory: %v", err)
}
wdBackup, err := os.Getwd()
if err != nil {
t.Fatalf("Error getting current working directory: %v", err)
}
err = os.Chdir(dir)
if err != nil {
t.Fatalf("Error changing working directory: %v", err)
}
// 8. Delete temp folder
defer func() {
err = os.Chdir(wdBackup)
if err != nil {
t.Fatalf("Error changing dir back: %v", err)
}
err = os.RemoveAll(dir)
if err != nil {
t.Fatalf("Error removing dir: %v", err)
}
}()
for _, testCase := range testCases {
if testCase.fakeConfig == nil {
testCase.fakeConfig = &latest.Config{
Dev: &latest.DevConfig{
Sync: []*latest.SyncConfig{
&latest.SyncConfig{
LocalSubPath: "somePath",
ContainerPath: "someContainerPath",
LabelSelector: map[string]string{
"index": "first",
},
},
&latest.SyncConfig{
LocalSubPath: "someOtherPath",
ContainerPath: "someOtherContainerPath",
LabelSelector: map[string]string{
"index": "secound",
},
},
},
},
} //default config
}
loader.SetFakeConfig(testCase.fakeConfig)
config, err := loader.GetBaseConfig(&loader.ConfigOptions{})
if err != nil {
log.Fatal(err)
}
err = RemoveSyncPath(config, testCase.removeAllParam, testCase.localPathParam, testCase.containerPathParam, testCase.labelSelectorParam)
if testCase.expectedErr == "" {
assert.NilError(t, err, "Error initializing namespace in testCase %s", testCase.name)
} else {
assert.Error(t, err, testCase.expectedErr, "Wrong or no error from initializing namespace in testCase %s", testCase.name)
}
assert.Equal(t, len(testCase.expectedSyncPathLocalPaths), len(testCase.fakeConfig.Dev.Sync), "Wrong number of remaining syncPaths in testCase %s", testCase.name)
OUTER:
for _, expectedLocalPath := range testCase.expectedSyncPathLocalPaths {
for _, syncPath := range testCase.fakeConfig.Dev.Sync {
if syncPath.LocalSubPath == expectedLocalPath {
continue OUTER
}
}
t.Fatalf("Expected remaining LocalPath %s not found in sync paths", expectedLocalPath)
}
}
}*/
|
package models
type Photo struct {
BaseModel
URL string `gorm:"not null" json:"url"`
Path string `json:"-"`
}
|
package widget
import (
"image"
"gioui.org/gesture"
"gioui.org/io/pointer"
"gioui.org/layout"
"gioui.org/op"
)
// Range is for selecting a range.
type Range struct {
Values []float32
dragIndex int
drag gesture.Drag
action rangeAction
pos float32
changed bool
}
type rangeAction uint8
const (
rangeActionNone rangeAction = iota
rangeActionDragging
rangeActionDraggingBoth
)
func (r *Range) updateFromEvent(
evt *pointer.Event, thumbRadius, fingerSize int, length float32,
min, max float32,
) {
if evt == nil {
if !r.drag.Dragging() {
r.action = rangeActionNone
}
return
}
pos := (evt.Position.X-float32(thumbRadius))/length*(max-min) + min
if r.action == rangeActionNone {
fingerSize := float32(fingerSize) / length * (max - min)
r.setAction(fingerSize, length, pos)
}
switch r.action {
case rangeActionDragging:
r.setRange(r.dragIndex, pos, min, max)
case rangeActionDraggingBoth:
dpos := pos - r.pos
r.pos = pos
r.setRange(r.dragIndex-1, r.Values[r.dragIndex-1]+dpos, min, max)
r.setRange(r.dragIndex, r.Values[r.dragIndex]+dpos, min, max)
}
}
func (r *Range) setAction(fingerSize, length, pos float32) {
if pos < r.Values[0]+fingerSize {
r.dragIndex, r.action = 0, rangeActionDragging
return
}
if pos > r.Values[len(r.Values)-1]-fingerSize {
r.dragIndex, r.action = len(r.Values)-1, rangeActionDragging
return
}
for i, v := range r.Values {
if v-fingerSize < pos && pos < v+fingerSize {
r.dragIndex, r.action = i, rangeActionDragging
return
}
if pos < v {
r.dragIndex, r.action = i, rangeActionDraggingBoth
r.pos = pos
return
}
}
}
func (r *Range) setRange(index int, v, rangeMin, rangeMax float32) {
switch index {
case 0:
if len(r.Values) > 1 {
rangeMax = r.Values[1]
}
case len(r.Values) - 1:
rangeMin = r.Values[index-1]
default:
rangeMin = r.Values[index-1]
rangeMax = r.Values[index+1]
}
if v < rangeMin {
v = rangeMin
}
if v > rangeMax {
v = rangeMax
}
if v != r.Values[index] {
r.Values[index] = v
r.changed = true
}
}
// Changed returns whether any of min/max values were changed since the last
// method invocation.
func (f *Range) Changed() (changed bool) {
changed, f.changed = f.changed, false
return
}
// Layout updates the range accordingly to gestures.
func (f *Range) Layout(gtx layout.Context, thumbRadius, fingerSize int, min, max float32) layout.Dimensions {
size := gtx.Constraints.Min
length := float32(size.X - 2*thumbRadius)
var de *pointer.Event
for _, e := range f.drag.Events(gtx.Metric, gtx, gesture.Horizontal) {
if e.Type == pointer.Press || e.Type == pointer.Drag {
de = &e
}
}
f.updateFromEvent(de, thumbRadius, fingerSize, length, min, max)
defer op.Save(gtx.Ops).Load()
pointer.Rect(image.Rectangle{Max: size}).Add(gtx.Ops)
f.drag.Add(gtx.Ops)
return layout.Dimensions{Size: size}
}
|
package authorization
import (
"regexp"
"testing"
"github.com/stretchr/testify/assert"
)
func TestRegexpGroupStringSubjectMatcher_IsMatch(t *testing.T) {
testCases := []struct {
name string
have *RegexpGroupStringSubjectMatcher
input string
subject Subject
expected bool
}{
{
"Abc",
&RegexpGroupStringSubjectMatcher{
MustCompileRegexNoPtr(`^(?P<User>[a-zA-Z0-9]+)\.regex.com$`),
1,
0,
},
"example.com",
Subject{Username: "a-user"},
false,
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
assert.Equal(t, tc.expected, tc.have.IsMatch(tc.input, tc.subject))
})
}
}
func MustCompileRegexNoPtr(input string) regexp.Regexp {
out := regexp.MustCompile(input)
return *out
}
|
package datastore
import (
"Go-Ground-Station/constants"
"fmt"
"rloop/Go-Ground-Station/gsgrpc"
"rloop/Go-Ground-Station/gstypes"
"runtime"
"strings"
"sync"
"time"
)
type DataStoreManager struct {
isRunningMutex sync.RWMutex
isRunning bool
doRunMutex sync.RWMutex
doRun bool
signalChannel chan bool
checkerSignalChannel chan bool
packetChannel <-chan gstypes.PacketStoreElement
receiversChannelHolder *gsgrpc.ChannelsHolder
ticker *time.Ticker
packetStoreCount int64
rtDataStoreMutex *sync.Mutex
rtData map[string]gstypes.DataStoreElement
}
func (manager *DataStoreManager) Start() {
manager.doRun = true
if !manager.isRunning {
fmt.Println("go run manager run")
go manager.run()
fmt.Println("go run checker")
go manager.checker()
}
}
func (manager *DataStoreManager) Stop() {
manager.doRun = false
if manager.isRunning {
manager.signalChannel <- true
manager.checkerSignalChannel <- true
}
}
func (manager *DataStoreManager) run() {
manager.isRunning = true
MainLoop:
for {
select {
case element := <-manager.packetChannel:
manager.ProcessNewPacket(element)
case <-manager.signalChannel:
break MainLoop
}
//this call is necessary so that the goroutine doesn't use too many cpu time at once
runtime.Gosched()
}
manager.isRunning = false
}
func (manager *DataStoreManager) initDataStore() {
var dataBundle gstypes.DataStoreBundle
var arr []gstypes.DataStoreElement
var preCount = 0
var count = 0
for _, definition := range constants.PacketDefinitions {
preCount += len(definition.Parameters)
}
preCount = preCount * 2
arr = make([]gstypes.DataStoreElement, preCount)
for _, definition := range constants.PacketDefinitions {
for _, node := range definition.MetaData {
for _, param := range definition.Parameters {
element := gstypes.DataStoreElement{}
element.Data = gstypes.DataStoreUnit{}
element.Data.ValueIndex = 4
element.PacketName = node.Name
element.FullParameterName = cleanJoin(node.ParameterPrefix, param.Name)
element.IsStale = true
element.ParameterName = param.Name
element.Units = param.Units
arr[count] = element
count++
}
}
}
dataBundle = gstypes.DataStoreBundle{}
dataBundle.Data = arr[:count]
manager.rtDataStoreMutex.Lock()
manager.saveToDataStore(dataBundle)
manager.rtDataStoreMutex.Unlock()
}
func (manager *DataStoreManager) checker() {
fmt.Println("Checker started")
//check all RxTimes on data and set to 0 when RX greater than 4 seconds
CheckerLoop:
for {
select {
case t := <-manager.ticker.C:
manager.checkDatastore(t)
case <-manager.checkerSignalChannel:
break CheckerLoop
}
}
}
func (manager *DataStoreManager) ProcessNewPacket(packet gstypes.PacketStoreElement) {
rxTime := packet.RxTime
packetName := packet.PacketName
parameters := packet.Parameters
paramCount := len(parameters)
prefix := packet.ParameterPrefix
dataBundle := gstypes.DataStoreBundle{}
dataBundle.Data = make([]gstypes.DataStoreElement, paramCount)
for idx := 0; idx < paramCount; idx++ {
parameter := parameters[idx]
fullyFormattedName := cleanJoin(prefix, parameter.ParameterName)
parameter.ParameterName = fullyFormattedName
parameter.FullParameterName = fullyFormattedName
parameter.RxTime = rxTime
parameter.PacketName = packetName
manager.UpdateDatastoreElement(¶meter)
dataBundle.Data[idx] = parameter
}
manager.rtDataStoreMutex.Lock()
manager.saveToDataStore(dataBundle)
manager.sendDatastoreUpdate()
manager.rtDataStoreMutex.Unlock()
manager.packetStoreCount++
}
func (manager *DataStoreManager) UpdateDatastoreElement(element *gstypes.DataStoreElement) {
switch element.Data.ValueIndex {
case 1:
element.Data.Int64Value = int64(element.Data.Int8Value)
element.Data.ValueIndex = 4
case 2:
element.Data.Int64Value = int64(element.Data.Int16Value)
element.Data.ValueIndex = 4
case 3:
element.Data.Int64Value = int64(element.Data.Int32Value)
element.Data.ValueIndex = 4
case 5:
element.Data.Uint64Value = uint64(element.Data.Uint8Value)
element.Data.ValueIndex = 8
case 6:
element.Data.Uint64Value = uint64(element.Data.Uint16Value)
element.Data.ValueIndex = 8
case 7:
element.Data.Uint64Value = uint64(element.Data.Uint32Value)
element.Data.ValueIndex = 8
case 9:
element.Data.Float64Value = float64(element.Data.FloatValue)
element.Data.ValueIndex = 10
}
}
func (manager *DataStoreManager) checkDatastore(currTime time.Time) {
var data []gstypes.DataStoreElement
//will count the amount of zeroed parameters and be used to slice the array the right size
var count = 0
manager.rtDataStoreMutex.Lock()
//the current length or amount of parameters in the datastore
paramLen := len(manager.rtData)
//make a new array that will be populated with the new values, enough to fit all current parameters
data = make([]gstypes.DataStoreElement, paramLen)
//used to calculate the time difference and to set the new time
//of when the parameters were updated last, only for parameters that will be zeroed
currentTime := currTime.Unix()
fmt.Println("checking...")
for _, dataStoreElement := range manager.rtData {
recordedTime := dataStoreElement.RxTime
if (currentTime - recordedTime) > 4 {
dataStoreElement.IsStale = true
dataStoreElement.Data.Int64Value = 0
dataStoreElement.Data.Uint64Value = 0
dataStoreElement.Data.Float64Value = 0
dataStoreElement.RxTime = time.Now().Unix()
data[count] = dataStoreElement
count++
}
}
if count > 0 {
dataBundle := gstypes.DataStoreBundle{}
dataBundle.Data = data[0:count]
manager.saveToDataStore(dataBundle)
manager.sendDatastoreUpdate()
}
manager.rtDataStoreMutex.Unlock()
}
func (manager *DataStoreManager) saveToDataStore(dataBundle gstypes.DataStoreBundle) {
for _, element := range dataBundle.Data {
//fmt.Printf("storing data: %v \n", element)
manager.rtData[element.FullParameterName] = element
}
}
func (manager *DataStoreManager) sendDatastoreUpdate() {
dataBundle := gstypes.DataStoreBundle{}
dataBundle.Data = make([]gstypes.DataStoreElement, len(manager.rtData))
idx := 0
for _, value := range manager.rtData {
dataBundle.Data[idx] = value
idx++
}
manager.sendDataBundle(dataBundle)
}
func (manager *DataStoreManager) sendDataBundle(dataBundle gstypes.DataStoreBundle) {
manager.receiversChannelHolder.ReceiverMutex.Lock()
//send the bundle to all subscribers
for channel := range manager.receiversChannelHolder.Receivers {
select {
case *channel <- dataBundle:
default:
fmt.Printf("streamerchannel is full \n")
}
}
manager.receiversChannelHolder.ReceiverMutex.Unlock()
}
func (manager *DataStoreManager) GetStatus() (bool, bool) {
defer func() {
manager.isRunningMutex.RUnlock()
manager.doRunMutex.RUnlock()
}()
manager.isRunningMutex.RLock()
manager.doRunMutex.RLock()
return manager.isRunning, manager.doRun
}
func cleanJoin(prefix string, name string) string {
var fullyFormattedName string
prefix = strings.TrimSpace(prefix)
name = strings.TrimSpace(name)
if prefix != "" {
s := []string{prefix, name}
fullyFormattedName = strings.Join(s, " ")
} else {
fullyFormattedName = name
}
return fullyFormattedName
}
func New(channelsHolder *gsgrpc.ChannelsHolder) (*DataStoreManager, chan<- gstypes.PacketStoreElement) {
//the channel that will be used to transfer data between the parser and the datastoremanager
packetStoreChannel := make(chan gstypes.PacketStoreElement, 64)
signalChannel := make(chan bool)
checkerSignalChannel := make(chan bool)
dataStoreManager := &DataStoreManager{
signalChannel: signalChannel,
checkerSignalChannel: checkerSignalChannel,
packetStoreCount: 0,
receiversChannelHolder: channelsHolder,
packetChannel: packetStoreChannel,
rtData: map[string]gstypes.DataStoreElement{},
rtDataStoreMutex: &sync.Mutex{},
ticker: time.NewTicker(time.Second * 3)}
dataStoreManager.initDataStore()
return dataStoreManager, packetStoreChannel
}
|
package main
import (
"fmt"
"net"
"time"
"github.com/mailway-app/config"
"github.com/pkg/errors"
)
func runPreflightChecks() error {
port := config.CurrConfig.PortFrontlineSMTP
if ok, _ := testPort(port); !ok {
return errors.Errorf("port %d appears to be blocked", port)
}
return nil
}
func testPort(port int) (bool, error) {
addr := fmt.Sprintf("portquiz.net:%d", port)
timeout := 3 * time.Second
c, err := net.DialTimeout("tcp", addr, timeout)
if err != nil {
return false, err
}
c.Close()
return true, nil
}
|
package 背包问题
// ---------------------- 01背包问题 ----------------------
// 执行用时：0 ms, 在所有 Go 提交中击败了 100.00% 的用户
// 内存消耗：2.3 MB, 在所有 Go 提交中击败了 100.00% 的用户
func lastStoneWeightII(stones []int) int {
canForm := getRelationOfCanForm(stones)
weightOfAllStone := getSum(stones)
maxOffsetWeight := 2 * getCanFormNumNearestAndLessRef(canForm, weightOfAllStone/2) // Offset: 抵消
return weightOfAllStone - maxOffsetWeight
}
func getRelationOfCanForm(stones []int) [][]bool {
sum := getSum(stones)
canForm := get2DBoolSlice(len(stones)+1, sum+1) // canForm[i][t]表示 在 stones[:i] 中取出一些数，能否组成 t 。
canForm[0][0] = true
for i := 1; i <= len(stones); i++ {
for t := 0; t <= sum; t++ {
if t-stones[i-1] >= 0 {
canForm[i][t] = canForm[i-1][t] || canForm[i-1][t-stones[i-1]]
} else {
canForm[i][t] = canForm[i-1][t]
}
}
}
return canForm
}
func getCanFormNumNearestAndLessRef(canForm [][]bool, ref int) int {
for i := ref; i >= 1; i-- {
if canForm[len(canForm)-1][i] {
return i
}
}
panic("不应到达这里")
}
func getSum(array []int) int {
sum := 0
for i := 0; i < len(array); i++ {
sum += array[i]
}
return sum
}
func get2DBoolSlice(rows, column int) [][]bool {
slice := make([][]bool, rows)
for i := 0; i < len(slice); i++ {
slice[i] = make([]bool, column)
}
return slice
}
/*
题目链接: https://leetcode-cn.com/problems/last-stone-weight-ii/
总结:
1. 这题就是要找出，能组成的最接近sum/2的数。
2. 之前做过类似的题目，就是背包问题嘛。
*/
|
// Copyright 2019 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 types
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestDecodeEscapedUnicode(t *testing.T) {
in := "597d"
r, size, err := decodeEscapedUnicode([]byte(in))
require.NoError(t, err)
require.Equal(t, "好\x00", string(r[:]))
require.Equal(t, 3, size)
}
func BenchmarkDecodeEscapedUnicode(b *testing.B) {
for i := 0; i < b.N; i++ {
in := "597d"
_, _, _ = decodeEscapedUnicode([]byte(in))
}
}
func BenchmarkMergePatchBinary(b *testing.B) {
valueA, _ := ParseBinaryJSONFromString(`{"title":"Goodbye!","author":{"givenName":"John","familyName":"Doe"},"tags":["example","sample"],"content":"This will be unchanged"}`)
valueB, _ := ParseBinaryJSONFromString(`{"title":"Hello!","phoneNumber":"+01-123-456-7890","author":{"familyName":null},"tags":["example"]}`)
for i := 0; i < b.N; i++ {
_, _ = MergePatchBinaryJSON([]*BinaryJSON{&valueA, &valueB})
}
}
func BenchmarkMergeBinary(b *testing.B) {
valueA, _ := ParseBinaryJSONFromString(`{"title":"Goodbye!","author":{"givenName":"John","familyName":"Doe"},"tags":["example","sample"],"content":"This will be unchanged"}`)
valueB, _ := ParseBinaryJSONFromString(`{"title":"Hello!","phoneNumber":"+01-123-456-7890","author":{"familyName":null},"tags":["example"]}`)
for i := 0; i < b.N; i++ {
_ = MergeBinaryJSON([]BinaryJSON{valueA, valueB})
}
}
func TestBinaryCompare(t *testing.T) {
tests := []struct {
left BinaryJSON
right BinaryJSON
result int
}{
{
CreateBinaryJSON("a"),
CreateBinaryJSON("b"),
-1,
},
{
CreateBinaryJSON(Opaque{
TypeCode: 0,
Buf: []byte{0, 1, 2, 3},
}),
CreateBinaryJSON(Opaque{
TypeCode: 0,
Buf: []byte{0, 1, 2},
}),
1,
},
{
CreateBinaryJSON(Opaque{
TypeCode: 0,
Buf: []byte{0, 1, 2, 3},
}),
CreateBinaryJSON(Opaque{
TypeCode: 0,
Buf: []byte{0, 2, 1},
}),
-1,
},
{
CreateBinaryJSON("test"),
CreateBinaryJSON(Opaque{
TypeCode: 0,
Buf: []byte{0, 2, 1},
}),
-1,
},
}
compareMsg := map[int]string{
1: "greater than",
0: "equal with",
-1: "smaller than",
}
for _, test := range tests {
require.Equal(t, test.result, CompareBinaryJSON(test.left, test.right), "%s should be %s %s", test.left.String(), compareMsg[test.result], test.right.String())
}
}
|
package main
import (
"bufio"
"fmt"
"os"
)
const filePath = "./input.txt"
func countParens(input string) int {
ct := 0
for _, c := range input {
if c == '(' {
ct++
} else if c == ')' {
ct--
} else {
//do nothing on invalid char
}
}
return ct
}
func enterBasement(input string) int {
ct := 0
for i, c := range input {
if c == '(' {
ct++
} else if c == ')' {
ct--
} else {
//do nothing on invalid char
}
if ct < 0 {
return i + 1
}
}
return -1
}
func readFile(filePath string) string {
inFile, err := os.Open(filePath)
if err != nil {
panic(err)
}
defer inFile.Close()
reader := bufio.NewScanner(inFile)
var outString string
for reader.Scan() {
outString = outString + reader.Text()
}
return outString
}
func main() {
//fmt.Println(readFile(filePath))
instring := readFile(filePath)
//destFloor := countParens(instring)
fmt.Println(countParens(instring))
fmt.Println(enterBasement(instring))
}
|
package sqlbuilder
import (
"database/sql/driver"
"fmt"
"io"
"reflect"
"sort"
"strings"
)
const (
// Portable true/false literals.
sqlTrue = "(1=1)"
sqlFalse = "(1=0)"
)
type expr struct {
sql string
args []interface{}
}
func Expr(sql string, args ...interface{}) expr {
return expr{sql: sql, args: args}
}
func (e expr) ToSql() (sql string, args []interface{}, err error) {
return e.sql, e.args, nil
}
type exprs []expr
func (es exprs) AppendToSql(w io.Writer, sep string, args []interface{}) ([]interface{}, error) {
for i, e := range es {
if i > 0 {
_, err := io.WriteString(w, sep)
if err != nil {
return nil, err
}
}
_, err := io.WriteString(w, e.sql)
if err != nil {
return nil, err
}
args = append(args, e.args...)
}
return args, nil
}
// Eq is syntactic sugar for use with Where/Having/Set methods.
// Ex:
// .Where(Eq{"id": 1})
type Eq map[string]interface{}
func (eq Eq) toSQL(useNotOpr bool) (sql string, args []interface{}, err error) {
if len(eq) == 0 {
// Empty Sql{} evaluates to true.
sql = sqlTrue
return
}
var (
exprs []string
equalOpr = "="
inOpr = "IN"
nullOpr = "IS"
inEmptyExpr = sqlFalse
)
if useNotOpr {
equalOpr = "<>"
inOpr = "NOT IN"
nullOpr = "IS NOT"
inEmptyExpr = sqlTrue
}
sortedKeys := getSortedKeys(eq)
for _, key := range sortedKeys {
var expr string
val := eq[key]
switch v := val.(type) {
case driver.Valuer:
if val, err = v.Value(); err != nil {
return
}
}
r := reflect.ValueOf(val)
if r.Kind() == reflect.Ptr {
if r.IsNil() {
val = nil
} else {
val = r.Elem().Interface()
}
}
if val == nil {
expr = fmt.Sprintf("%s %s NULL", key, nullOpr)
} else {
if isListType(val) {
valVal := reflect.ValueOf(val)
if valVal.Len() == 0 {
expr = inEmptyExpr
if args == nil {
args = []interface{}{}
}
} else {
for i := 0; i < valVal.Len(); i++ {
args = append(args, valVal.Index(i).Interface())
}
expr = fmt.Sprintf("%s %s (%s)", key, inOpr, Placeholders(valVal.Len()))
}
} else {
expr = fmt.Sprintf("%s %s ?", key, equalOpr)
args = append(args, val)
}
}
exprs = append(exprs, expr)
}
sql = strings.Join(exprs, " AND ")
return
}
func (eq Eq) ToSql() (sql string, args []interface{}, err error) {
return eq.toSQL(false)
}
// NotEq is syntactic sugar for use with Where/Having/Set methods.
// Ex:
// .Where(NotEq{"id": 1}) == "id <> 1"
type NotEq Eq
func (neq NotEq) ToSql() (sql string, args []interface{}, err error) {
return Eq(neq).toSQL(true)
}
func getSortedKeys(exp map[string]interface{}) []string {
sortedKeys := make([]string, 0, len(exp))
for k := range exp {
sortedKeys = append(sortedKeys, k)
}
sort.Strings(sortedKeys)
return sortedKeys
}
func isListType(val interface{}) bool {
if driver.IsValue(val) {
return false
}
valVal := reflect.ValueOf(val)
return valVal.Kind() == reflect.Array || valVal.Kind() == reflect.Slice
}
|
package day2
import (
"strconv"
"strings"
"github.com/littleajax/adventofcode/helpers"
)
type passwordRules struct {
Password string
Char rune
Min int
Max int
}
func ProcessInputs() []passwordRules {
values := helpers.FetchInputs("./inputs/day2.txt")
inputs := []passwordRules{}
for _, value := range values {
//strings are formatted as n-k: password
hyphenIndex := strings.IndexRune(value, '-')
spaceIndex := strings.IndexRune(value, ' ')
colonIndex := strings.IndexRune(value, ':')
min, _ := strconv.Atoi(value[:hyphenIndex])
max, _ := strconv.Atoi(value[hyphenIndex+1 : spaceIndex])
char := value[spaceIndex+1]
password := value[colonIndex+2:]
inputs = append(inputs, passwordRules{
Password: password,
Min: min,
Max: max,
Char: rune(char),
})
}
return inputs
}
func PasswordPositionCheck(passwords []passwordRules) (hitcount int) {
for _, value := range passwords {
var charCount int
if value.Char == rune(value.Password[value.Min-1]) {
charCount++
}
if value.Char == rune(value.Password[value.Max-1]) {
charCount++
}
if charCount == 1 {
hitcount++
}
}
return
}
func PasswordCheck(passwords []passwordRules) (hitcount int) {
for _, value := range passwords {
var charCount int
for _, char := range value.Password {
if rune(char) == value.Char {
charCount++
}
}
if charCount >= value.Min && charCount <= value.Max {
hitcount++
}
}
return
}
|
// Copyright (C) 2015 Scaleway. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE.md file.
package cli
import (
"fmt"
"github.com/scaleway/scaleway-cli/pkg/commands"
)
var cmdLogin = &Command{
Exec: runLogin,
UsageLine: "login [OPTIONS]",
Description: "Log in to Scaleway API",
Help: `Generates a configuration file in '/home/$USER/.scwrc'
containing credentials used to interact with the Scaleway API. This
configuration file is automatically used by the 'scw' commands.
You can get your credentials on https://cloud.scaleway.com/#/credentials
`,
}
func init() {
cmdLogin.Flag.StringVar(&organization, []string{"o", "-organization"}, "", "Organization")
cmdLogin.Flag.StringVar(&token, []string{"t", "-token"}, "", "Token")
cmdLogin.Flag.BoolVar(&loginHelp, []string{"h", "-help"}, false, "Print usage")
cmdLogin.Flag.BoolVar(&loginSkipSSHKey, []string{"s", "-skip-ssh-key"}, false, "Don't ask to upload an SSH Key")
}
// FLags
var organization string // -o flag
var token string // -t flag
var loginHelp bool // -h, --help flag
var loginSkipSSHKey bool // -s, --skip-ssh-key flag
func runLogin(cmd *Command, rawArgs []string) error {
if loginHelp {
return cmd.PrintUsage()
}
if len(rawArgs) != 0 {
return cmd.PrintShortUsage()
}
if (organization != "" || token != "") && (organization == "" || token == "") {
return fmt.Errorf("you must define organization AND token")
}
args := commands.LoginArgs{
Organization: organization,
Token: token,
SkipSSHKey: loginSkipSSHKey,
}
ctx := cmd.GetContext(rawArgs)
return commands.RunLogin(ctx, args)
}
|
package config
import (
"github.com/aquinofb/location_service/controllers"
"github.com/gin-gonic/gin"
)
func Router() *gin.Engine {
gin.SetMode(gin.ReleaseMode)
router := gin.Default()
router.GET("/", controllers.HomeIndex)
api := router.Group("/api")
{
api.GET("/places", controllers.PlacesIndex)
api.GET("/places/:reference", controllers.HomeShow)
}
return router
}
|
package main
/*
#cgo LDFLAGS: -lluajit-5.1
#include <stdlib.h>
#include <stdio.h>
#include <luajit-2.0/lua.h>
#include <luajit-2.0/lualib.h>
#include <luajit-2.0/lauxlib.h>
int my_func() {
printf("Hello from the C preamble!\n");
return 0;
}
*/
import "C"
import (
"fmt"
"os"
"unsafe"
)
const src = `
local ffi = require('ffi')
ffi.cdef([[
int my_func();
]])
print("Hello from Lua!")
ffi.C.my_func()
`
func main() {
C.my_func()
// Initialize state.
state := C.luaL_newstate()
if state == nil {
fmt.Println("Unable to initialize Lua context.")
os.Exit(1)
}
C.luaL_openlibs(state)
// Compile the script.
csrc := C.CString(src)
defer C.free(unsafe.Pointer(csrc))
if C.luaL_loadstring(state, csrc) != 0 {
errstring := C.GoString(C.lua_tolstring(state, -1, nil))
fmt.Printf("Lua error: %v\n", errstring)
os.Exit(1)
}
// Run script.
if C.lua_pcall(state, 0, 0, 0) != 0 {
errstring := C.GoString(C.lua_tolstring(state, -1, nil))
fmt.Printf("Lua execution error: %v\n", errstring)
os.Exit(1)
}
} |
package schema
import (
"github.com/facebook/ent/dialect"
"github.com/facebook/ent"
"github.com/facebook/ent/schema/field"
)
// UserInfo holds the schema definition for the UserInfo entity.
type UserInfo struct {
ent.Schema
}
// Mixin of the UserInfo.
func (UserInfo) Mixin() []ent.Mixin {
return []ent.Mixin{}
}
func (UserInfo) Config() ent.Config {
return ent.Config{
Table: "user_info",
}
}
// Fields of the UserInfo.
func (UserInfo) Fields() []ent.Field {
return []ent.Field{
field.Int64("id").Comment(`主键`),
field.String("user_identity").Optional().Comment(`标识`),
field.Int32("channel").Default(0).Comment(`渠道：XXX`),
field.Int32("form").Default(0).Comment(`来源：XXX`),
field.Time("created_at").Optional().SchemaType(map[string]string{dialect.MySQL: "datetime"}).Comment(`创建时间`),
field.Time("updated_at").Optional().SchemaType(map[string]string{dialect.MySQL: "datetime"}).Comment(`更新时间`),
field.Time("deleted_at").Optional().SchemaType(map[string]string{dialect.MySQL: "datetime"}).Comment(`删除时间`),
}
}
// Edges of the UserInfo.
func (UserInfo) Edges() []ent.Edge {
return nil
}
|
package conexionBD
import (
"time"
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/postgres"
"github.com/xubio-inc/sueldos-lib-framework/configuracion"
)
func ConnectBD(tenant string) *gorm.DB {
var db *gorm.DB
var err error
configuracion := configuracion.GetInstance()
db, err = gorm.Open("postgres", "host= "+configuracion.Ip+" port=5432 user=postgres dbname= "+configuracion.Namedb+" password="+configuracion.Passdb+" sslmode="+configuracion.Ssldb)
if err != nil {
panic("failed to connect database: " + err.Error())
}
db.DB().SetConnMaxLifetime(time.Second * 300)
//db.DB().SetMaxIdleConns()
//db.DB().SetMaxOpenConns()
//Crea el schema si no existe
db.Exec("CREATE SCHEMA IF NOT EXISTS " + tenant)
db.SingularTable(true)
if tenant == "public" {
db.Exec("SET search_path = " + tenant)
} else {
db.Exec("GRANT USAGE ON SCHEMA " + tenant + " TO read_only")
db.Exec("ALTER DEFAULT PRIVILEGES FOR USER postgres IN SCHEMA " + tenant +" GRANT SELECT ON TABLES TO read_only")
db.Exec("SET search_path = " + tenant + ",public")
}
return db
}
func ObtenerDB(tenant string) *gorm.DB {
return ConnectBD(tenant)
}
func CerrarDB(db *gorm.DB) {
db.DB().Close()
}
func LockTable(db *gorm.DB, tablename string){
db.Exec("select * from " + tablename + " FOR UPDATE")
} |
package lib
import (
"fmt"
"testing"
)
type UrlIds struct {
Url string
Id int
}
type UrlHosts struct {
Url string
Host string
}
func TestGetArticleId(t *testing.T) {
t.Log("Testing the parsing of article IDs from urls")
testCases := []UrlIds{{
"http://www.freep.com/story/money/2015/09/16/uaw-fca-showdown/32488047/",
32488047,
}, {
"http://www.freep.com/story/sports/nfl/lions/2015/09/15/melvin-ingram-matthew-stafford-detroit-lions/72323384/",
72323384,
}, {
"http://www.freep.com/story/sports/college/university-michigan/wolverines/2015/09/15/michigan-wolverines-offensive-line/72292760",
72292760,
}, {
"http://www.detroitnews.com/story/entertainment/arts/2015/09/16/dia-names-new-director/32497959/",
32497959,
}, {
"this should return -1",
-1,
}}
for i := 0; i < len(testCases); i++ {
testCase := testCases[i]
id := GetArticleId(testCase.Url)
if id != testCase.Id {
panic(fmt.Sprintf("Url %s should have generated ID %d, instead it generated %d", testCase.Url, testCase.Id, id))
}
}
}
func TestGetHost(t *testing.T) {
t.Log("testing the parsing of a host in a url string")
// These are valid test cases that should return a host
testCases := []UrlHosts{{
"http://google.com",
"google",
}, {
"http://freep.com/sports/lions/",
"freep",
}, {
"http://www.detroitnews.com/story/entertainment/arts/2015/09/16/dia-names-new-director/32497959/",
"detroitnews",
}, {
"http://this.that.domain.subdomain.wtf.freep.com/this/is/some/path",
"freep",
}}
for i := 0; i < len(testCases); i++ {
testCase := testCases[i]
url := testCase.Url
expected := testCase.Host
result, err := GetHost(url)
if err != nil {
panic(err)
} else if result != expected {
panic(fmt.Sprintf("Url %s should have host %s. Instead got %s", url, expected, result))
}
}
// These are invalid test cases that should return an error
errorCases := []string{
"invalid url",
"freep.this.com/asdfasdf",
"1231231231",
"----------123what?",
"http:::::asdfasdf",
}
for i := 0; i < len(errorCases); i++ {
testCase := errorCases[i]
result, err := GetHost(testCase)
if err == nil {
panic(fmt.Sprintf("Test case '%s' should have returned an error", testCase))
} else if result != "" {
panic(fmt.Sprintf("Test case '%s' should have return '' for a host", testCase))
}
}
}
|
package cmd
import (
"context"
"fmt"
"path/filepath"
"github.com/spf13/cobra"
"github.com/superfly/flyctl/cmdctx"
"github.com/superfly/flyctl/flyctl"
"github.com/superfly/flyctl/internal/buildinfo"
"github.com/superfly/flyctl/internal/client"
"github.com/superfly/flyctl/internal/update"
"github.com/superfly/flyctl/docstrings"
)
func newVersionCommand(client *client.Client) *Command {
versionStrings := docstrings.Get("version")
version := BuildCommandKS(nil, runVersion, versionStrings, client)
version.AddStringFlag(StringFlagOpts{
Name: "saveinstall",
Shorthand: "s",
Description: "Save parameter in config",
})
version.Flag("saveinstall").Hidden = true
updateStrings := docstrings.Get("version.update")
BuildCommandKS(version, runUpdate, updateStrings, client)
initStateCmd := BuildCommand(version, runInitState, "init-state", "init-state", "Initialize installation state", client)
initStateCmd.Hidden = true
initStateCmd.Args = cobra.ExactArgs(1)
return version
}
func runVersion(ctx *cmdctx.CmdContext) error {
saveInstall := ctx.Config.GetString("saveinstall")
if saveInstall != "" {
stateFilePath := filepath.Join(flyctl.ConfigDir(), "state.yml")
update.InitState(stateFilePath, saveInstall)
}
info := buildinfo.Info()
if ctx.OutputJSON() {
ctx.WriteJSON(info)
} else {
fmt.Println(info)
}
return nil
}
func runInitState(ctx *cmdctx.CmdContext) error {
stateFilePath := filepath.Join(flyctl.ConfigDir(), "state.yml")
return update.InitState(stateFilePath, ctx.Args[0])
}
func runUpdate(ctx *cmdctx.CmdContext) error {
stateFilePath := filepath.Join(flyctl.ConfigDir(), "state.yml")
return update.PerformInPlaceUpgrade(context.TODO(), stateFilePath, buildinfo.Version())
}
|
// Copyright 2021 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,
// See the License for the specific language governing permissions and
// limitations under the License.
package auth
import (
"encoding/hex"
"testing"
"github.com/pingcap/tidb/parser/mysql"
"github.com/stretchr/testify/require"
)
var foobarPwdSHA2Hash, _ = hex.DecodeString("24412430303524031A69251C34295C4B35167C7F1E5A7B63091349503974624D34504B5A424679354856336868686F52485A736E4A733368786E427575516C73446469496537")
func TestCheckShaPasswordGood(t *testing.T) {
pwd := "foobar"
r, err := CheckHashingPassword(foobarPwdSHA2Hash, pwd, mysql.AuthCachingSha2Password)
require.NoError(t, err)
require.True(t, r)
}
func TestCheckShaPasswordBad(t *testing.T) {
pwd := "not_foobar"
pwhash, _ := hex.DecodeString("24412430303524031A69251C34295C4B35167C7F1E5A7B63091349503974624D34504B5A424679354856336868686F52485A736E4A733368786E427575516C73446469496537")
r, err := CheckHashingPassword(pwhash, pwd, mysql.AuthCachingSha2Password)
require.NoError(t, err)
require.False(t, r)
}
func TestCheckShaPasswordShort(t *testing.T) {
pwd := "not_foobar"
pwhash, _ := hex.DecodeString("aaaaaaaa")
_, err := CheckHashingPassword(pwhash, pwd, mysql.AuthCachingSha2Password)
require.Error(t, err)
}
func TestCheckShaPasswordDigestTypeIncompatible(t *testing.T) {
pwd := "not_foobar"
pwhash, _ := hex.DecodeString("24422430303524031A69251C34295C4B35167C7F1E5A7B63091349503974624D34504B5A424679354856336868686F52485A736E4A733368786E427575516C73446469496537")
_, err := CheckHashingPassword(pwhash, pwd, mysql.AuthCachingSha2Password)
require.Error(t, err)
}
func TestCheckShaPasswordIterationsInvalid(t *testing.T) {
pwd := "not_foobar"
pwhash, _ := hex.DecodeString("24412430304724031A69251C34295C4B35167C7F1E5A7B63091349503974624D34504B5A424679354856336868686F52485A736E4A733368786E427575516C73446469496537")
_, err := CheckHashingPassword(pwhash, pwd, mysql.AuthCachingSha2Password)
require.Error(t, err)
}
// The output from NewHashPassword is not stable as the hash is based on the generated salt.
// This is why CheckHashingPassword is used here.
func TestNewSha2Password(t *testing.T) {
pwd := "testpwd"
pwhash := NewHashPassword(pwd, mysql.AuthCachingSha2Password)
r, err := CheckHashingPassword([]byte(pwhash), pwd, mysql.AuthCachingSha2Password)
require.NoError(t, err)
require.True(t, r)
for r := range pwhash {
require.Less(t, pwhash[r], uint8(128))
require.NotEqual(t, pwhash[r], 0) // NUL
require.NotEqual(t, pwhash[r], 36) // '$'
}
}
func BenchmarkShaPassword(b *testing.B) {
for i := 0; i < b.N; i++ {
m, err := CheckHashingPassword(foobarPwdSHA2Hash, "foobar", mysql.AuthCachingSha2Password)
require.Nil(b, err)
require.True(b, m)
}
}
|
package main
import (
"fmt"
"log"
"math"
"regexp"
"strconv"
)
func mult(nums ...int) int {
prod := 1
for _, n := range nums {
prod *= n
}
return prod
}
type Tile struct {
dim []int
id int
bfield [][]bool
field []string
original []string
sides []int
permstate int
}
func (t *Tile) String() string {
s := fmt.Sprintf("Tile %d:", t.id)
for _, l := range t.bfield {
s += fmt.Sprintf("\n")
for _, f := range l {
if f {
s += "#"
} else {
s += "."
}
}
}
return s
}
func (t *Tile) North() int { return t.sides[0] }
func (t *Tile) East() int { return t.sides[1] }
func (t *Tile) South() int { return t.sides[2] }
func (t *Tile) West() int { return t.sides[3] }
func (t *Tile) FitsToTheTopOf(t2 *Tile) bool { return t.South() == t2.North() }
func (t *Tile) FitsToTheRightOf(t2 *Tile) bool { return t.West() == t2.East() }
func (t *Tile) FitsToTheBottomOf(t2 *Tile) bool { return t.North() == t2.South() }
func (t *Tile) FitsToTheLeftOf(t2 *Tile) bool { return t.East() == t2.West() }
func (t *Tile) FitsInto(newtiles []*Tile, dim int) bool {
if len(newtiles) == 0 {
return true
}
if len(newtiles) < dim {
return t.FitsToTheRightOf(newtiles[len(newtiles)-1])
}
if len(newtiles)%dim == 0 {
return t.FitsToTheBottomOf(newtiles[len(newtiles)-dim])
}
cl := t.FitsToTheRightOf(newtiles[len(newtiles)-1])
cr := t.FitsToTheBottomOf(newtiles[len(newtiles)-dim])
c := cl && cr
return c
}
var titlerex = regexp.MustCompile(`^.* +(\d+):$`)
func getId(tiletitle string) (id int, e error) {
matches := titlerex.FindStringSubmatch(tiletitle)
if len(matches) >= 2 {
if i, err := strconv.Atoi(matches[1]); err == nil {
id = i
} else {
e = fmt.Errorf("tile id is not a numer: '%s'", tiletitle)
}
} else {
e = fmt.Errorf("tile not in standard format: '%s'", tiletitle)
}
return id, e
}
func getField(field []string) [][]bool {
var bfield [][]bool
for _, line := range field {
var bline []bool
for _, c := range line {
if c == '.' {
bline = append(bline, false)
} else {
bline = append(bline, true)
}
}
bfield = append(bfield, bline)
}
return bfield
}
func side2bin(side []bool) int {
n := ""
for _, s := range side {
if s {
n += "1"
} else {
n += "0"
}
}
var i int64
var err error
if i, err = strconv.ParseInt(n, 2, 64); err != nil {
i = -1
log.Print(err)
}
return int(i)
}
func getSides(field [][]bool) []int {
var sides []int
sides = append(sides, side2bin(field[0]))
var right []bool
for _, line := range field {
right = append(right, line[len(line)-1])
}
sides = append(sides, side2bin(right))
sides = append(sides, side2bin(field[len(field)-1]))
var left []bool
for _, line := range field {
left = append(left, line[0])
}
sides = append(sides, side2bin(left))
return sides
}
func NewTile(id string, field []string) *Tile {
t := &Tile{original: field}
t.id, _ = getId(id)
t.field = append(t.field, t.original...)
t.bfield = getField(field)
t.dim = []int{len(field), len(field[0])}
t.sides = getSides(t.bfield)
return t
}
func (t *Tile) Reset() {
t.field = []string{}
t.field = append(t.field, t.original...)
t.permstate = 0
t.bfield = getField(t.field)
t.dim = []int{len(t.field), len(t.field[0])}
t.sides = getSides(t.bfield)
}
func (t *Tile) Rotate() {
var res [][]byte
for _, line := range t.field {
res = append(res, make([]byte, len(line)))
}
n := len(t.field)
x := n / 2
y := n - 1
for i := 0; i < x; i++ {
for j := i; j < y-i; j++ {
k := t.field[i][j]
res[i][j] = t.field[y-j][i]
res[y-j][i] = t.field[y-i][y-j]
res[y-i][y-j] = t.field[j][y-i]
res[j][y-i] = k
}
}
t.field = nil
for _, line := range res {
t.field = append(t.field, string(line))
}
t.bfield = getField(t.field)
t.sides = getSides(t.bfield)
}
func (t *Tile) Flipv() {
var res []string
for i := len(t.field) - 1; i >= 0; i-- {
res = append(res, t.field[i])
}
t.field = res
t.bfield = getField(t.field)
t.sides = getSides(t.bfield)
}
func reverse(s string) string {
runes := []rune(s)
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
runes[i], runes[j] = runes[j], runes[i]
}
return string(runes)
}
func (t *Tile) Fliph() {
var res []string
for _, f := range t.field {
res = append(res, reverse(f))
}
t.field = res
t.bfield = getField(t.field)
t.sides = getSides(t.bfield)
}
/*# ensure top left edge
edge_tiles[0].to_left_top()
field = [[edge_tiles[0]]]
tiles.remove(edge_tiles[0])
cur_tile = field[0][0]
while True:
while True:
next_tile = [t for t in tiles if cur_tile.right_edge() in t.all_edges()]
if not next_tile:
break
next_tile[0].to_left(cur_tile.right_edge())
cur_tile = next_tile[0]
tiles.remove(cur_tile)
field[-1].append(cur_tile)
next_tile = [t for t in tiles if field[-1][0].bottom_edge() in t.all_edges()]
if not next_tile:
break
next_tile[0].to_top(field[-1][0].bottom_edge())
cur_tile = next_tile[0]
tiles.remove(cur_tile)
field.append([cur_tile])
*/
func PrintSquareIDs(tiles []*Tile) {
d := int(math.Sqrt(float64(len(tiles))))
for i := 0; i < d; i++ {
for j := 0; j < d; j++ {
fmt.Print(tiles[d*i+j].id, " ")
}
fmt.Println()
}
}
func PrintSquareFields(tiles []*Tile) {
d := int(math.Sqrt(float64(len(tiles))))
for i := 0; i < d; i++ {
for j := 0; j < len(tiles[0].field)-1; j++ {
for k := 0; k < d; k++ {
fmt.Print(tiles[d*i+k].field[j], " ")
}
fmt.Println()
}
fmt.Println()
}
}
func Reset(tiles []*Tile) {
for _, t := range tiles {
t.Reset()
}
}
func GetCorners(tiles []*Tile) []int {
if len(tiles) == 0 {
return []int{0, 0, 0, 0}
}
d := int(math.Sqrt(float64(len(tiles))))
return []int{tiles[0].id, tiles[d-1].id, tiles[len(tiles)-d].id, tiles[len(tiles)-1].id}
}
const MAXPERMS = 8
func (t *Tile) Permutate() {
switch t.permstate {
case 0, 1, 2, 4, 5, 6:
t.Rotate()
t.permstate++
break
// case 4, 9:
// t.Fliph()
// t.permstate++
// break
case 3, 7:
t.Flipv()
t.permstate++
break
default:
t.permstate = 0
break
}
}
func (t *Tile) tryPermutations(nt []*Tile, d int) bool {
if t.FitsInto(nt, d) {
return true
} else {
for i := 0; i < MAXPERMS; i++ {
t.Permutate()
if t.FitsInto(nt, d) {
return true
}
}
}
return false
}
func rec(remaining, already []*Tile, dim int) (found []*Tile) {
if len(remaining) == 0 {
return already
}
for i := 0; i < len(remaining); i++ {
if remaining[i].tryPermutations(already, dim) {
newalready := append(already, remaining[i])
newremaining := append(remaining[:i], remaining[i+1:]...)
found = append(found, rec(newremaining, newalready, dim)...)
}
}
return found
}
func show(t *Tile, rest []*Tile) {
fmt.Print("[ ", t.id, "-")
for _, v := range rest {
fmt.Print(" ", v.id)
}
fmt.Println(" ]")
}
func inspect(t *Tile, r1, r2 []*Tile) {
fmt.Printf("t0: %d r1 ", t.id)
for _, v := range r1 {
fmt.Printf(" %d", v.id)
}
fmt.Printf(" r2: ")
for _, v := range r2 {
fmt.Printf(" %d", v.id)
}
fmt.Println()
}
func t1(tiles []*Tile) int {
d := int(math.Sqrt(float64(len(tiles))))
var found []*Tile
for i := range tiles {
fmt.Printf("Trying start with tile #%d : %d\n", i, tiles[i].id)
Reset(tiles)
for p := 0; p < MAXPERMS; p++ {
ps := tiles[i].permstate
Reset(tiles)
for tiles[i].permstate < ps {
tiles[i].Permutate()
}
if ps != tiles[i].permstate {
log.Fatal("error did not permutate")
}
fmt.Println("\tPermutation ", tiles[i].permstate)
tmptiles := make([]*Tile, len(tiles))
copy(tmptiles, tiles)
rest := append(tmptiles[:i], tmptiles[i+1:]...)
found = rec(append([]*Tile{tmptiles[i]}, rest...), []*Tile{}, d)
if len(found) != len(tiles) {
tiles[i].Permutate()
} else {
return mult(GetCorners(found)...)
}
}
}
return mult(GetCorners(found)...)
}
func main() {
var input string = "input.txt"
// input = "example2.txt"
tiles := ReadData(input)
fmt.Println("t1 ", t1(tiles))
// fmt.Printf("ticket scanning error rate: %d\n", tickedScanningErrorRate(rules, myticket, nearbies))
// fmt.Printf("Prouct of the six departure numbers: %d\n", ProductOfDepartureField(rules, myticket, nearbies))
}
|
package main
import (
"errors"
"github.com/gorilla/websocket"
)
type Client interface {
getConn() *websocket.Conn
}
func ClientWriteText(client Client, data []byte) error {
return client.getConn().WriteMessage(websocket.TextMessage, data)
}
func ClientWriteJSON(client Client, data interface{}) error {
return client.getConn().WriteJSON(data)
}
func ClientWrite(client Client, msgType int, data []byte) error {
if client != nil && client.getConn() != nil {
return client.getConn().WriteMessage(msgType, data)
}
return errors.New("Invalid client")
}
|
package rakuten
type TravelService service
|
package persistence
import (
"time"
"github.com/steotia/go-analytics-crypto-api/marketdata"
)
type MarketPairDoc struct {
Hour time.Time `bson:"hour"`
MarketPair string `bson:"market_pair"`
Minutes map[string]marketdata.MarketData `bson:"minutes"`
}
|
package main
func main() {
println(foo())
x, y := bar()
println(x)
println(y)
}
func foo() int {
return 42
}
func bar() (int, string) {
return 43, "hello"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.