text
stringlengths 11
4.05M
|
|---|
package bslib
import (
"database/sql"
"os"
_ "github.com/mattn/go-sqlite3" // Needed to work correctly with database/sql
)
// StorageDB is a class to access all storage functionality
type storageDB struct {
// instance & status
sDB *sql.DB
dbOpen bool
sTX *sql.Tx
// db settings
dbVersion int
dbID string
cryptID string
keyWord string
}
func (sdb *storageDB) StartTX() (err error) {
if sdb.sDB == nil {
return formError(BSERR00012DbTxStartFailed, "Database is not open")
}
if sdb.sTX != nil {
return formError(BSERR00012DbTxStartFailed, "Active transaction is already open, cannot open it twice, close previous first")
}
sdb.sTX, err = sdb.sDB.Begin()
if err != nil {
return formError(BSERR00012DbTxStartFailed, err.Error())
}
return nil
}
func (sdb *storageDB) CommitTX() (err error) {
return sdb.EndTransaction(true)
}
func (sdb *storageDB) RollbackTX() (err error) {
return sdb.EndTransaction(false)
}
func (sdb *storageDB) EndTransaction(commit bool) (err error) {
if sdb.sTX == nil {
return formError(BSERR00013DbTxEndFailed)
}
if commit {
err = sdb.sTX.Commit()
} else {
err = sdb.sTX.Rollback()
}
sdb.sTX = nil
return err
}
const cDBOpenParms = "?_txlock=immediate"
// Open method opens database in the provided file
func (sdb *storageDB) Open(filePath string) error {
var err error
sdb.dbOpen = false
if _, err = os.Stat(filePath); err == nil {
// File exists, open and check integrity
sdb.sDB, err = sql.Open("sqlite3", "file:"+filePath+cDBOpenParms)
if err != nil {
return err
}
err = sdb.getSettings()
if err != nil {
return err
}
sdb.dbOpen = true
return nil
}
// File does not exists
sdb.sDB, err = sql.Open("sqlite3", "file:"+filePath+cDBOpenParms)
if err != nil {
return err
}
sdb.sDB.SetMaxOpenConns(1) // trying to remove db is locked issue
err = sdb.StartTX()
if err != nil {
return err
}
err = sdb.initDb()
if err != nil {
return err
}
err = sdb.EndTransaction(true)
if err != nil {
return err
}
sdb.dbOpen = true
return nil
}
func (sdb *storageDB) Close() error {
if !sdb.dbOpen {
return nil
}
if sdb.sDB != nil {
err := sdb.sDB.Close()
if err != nil {
return err
}
sdb.dbOpen = false
sdb.sDB = nil
}
return nil
}
// IsOpen - returns the flag if the database os already open
func (sdb *storageDB) IsOpen() bool {
return sdb.dbOpen
}
// Version - returns current version of DB
func (sdb *storageDB) Version() int {
return sdb.dbVersion
}
const constSelectTables = `
SELECT name
FROM sqlite_master
WHERE type='table' AND name='settings'
`
func (sdb *storageDB) checkIntegrity() (bool, error) {
rows, err := sdb.sDB.Query(constSelectTables)
if err != nil {
return false, formError(BSERR00001DbIntegrityCheckFailed, err.Error())
}
foundSettings := false
if rows.Next() {
var tableName string
err = rows.Scan(&tableName)
if err != nil {
errRowsClose := rows.Close()
if errRowsClose != nil {
return false, formError(BSERR00001DbIntegrityCheckFailed, err.Error(), errRowsClose.Error())
}
return false, formError(BSERR00001DbIntegrityCheckFailed, err.Error())
}
if tableName == "settings" {
foundSettings = true
}
}
err = rows.Close()
if err != nil {
return false, formError(BSERR00001DbIntegrityCheckFailed, err.Error())
}
return foundSettings, nil
}
const constSelectVersion = `
SELECT database_version, database_id, crypt_id, keyword
FROM settings LIMIT 1
`
func (sdb *storageDB) getSettings() error {
foundSettings, err := sdb.checkIntegrity()
if err != nil {
return formError(BSERR00001DbIntegrityCheckFailed, err.Error())
}
if !foundSettings {
return formError(BSERR00001DbIntegrityCheckFailed, "settings table is not found")
}
rowsSet, errSet := sdb.sDB.Query(constSelectVersion)
if errSet != nil {
return formError(BSERR00001DbIntegrityCheckFailed, errSet.Error())
}
if rowsSet.Next() {
errSet = rowsSet.Scan(&sdb.dbVersion, &sdb.dbID, &sdb.cryptID, &sdb.keyWord)
if errSet != nil {
errSetClose := rowsSet.Close()
if errSetClose != nil {
return formError(BSERR00001DbIntegrityCheckFailed, errSet.Error(), errSetClose.Error())
}
return formError(BSERR00001DbIntegrityCheckFailed, errSet.Error())
}
}
return rowsSet.Close()
}
func (sdb *storageDB) initDb() (err error) {
if sdb.sTX == nil {
return formError(BSERR00003DbTransactionFailed)
}
err = sdb.createTable(sqlCreateTableSettings)
if err != nil {
return err
}
err = sdb.createTable(sqlCreateTableItems)
if err != nil {
return err
}
err = sdb.createTable(sqlCreateTableFields)
if err != nil {
return err
}
err = sdb.createTable(sqlCreateTableTemplateItems)
if err != nil {
return err
}
err = sdb.createTable(sqlCreateTableTemplateFields)
if err != nil {
return err
}
err = sdb.createTable(sqlCreateTableTags)
if err != nil {
return err
}
err = sdb.createTable(sqlCreateTableItemsTags)
if err != nil {
return err
}
return nil
}
|
// vi:nu:et:sts=4 ts=4 sw=4
// How to parse html in Golang using the HTML Tokenizer.
//
// Warning: The HTML Tokenizer is a one-pass parser. It is not a tree
// structure that you can do passes over. If you want a tree
// like structure, then you should use html.Parse().
//
// 1/9/2020 - I modified this to validate the array data. I needed this
// validation for unit testing in genapp and was the reason that
// I did this experimentation. The test is a simple check on the
// first TD's Element a's Text to see that it is a number and
// progresses from 0;
// See: https://github.com/2kranki/genapp
package main
import "fmt"
import "io/ioutil"
import "log"
import "os"
import "strconv"
import "strings"
import "golang.org/x/net/html"
func ValidateFile(path string) error {
var in_td bool = false
var num_td int
var num_entry int
var nameEven string
b, err := ioutil.ReadFile(path)
if err != nil {
fmt.Print(err)
}
str := string(b)
rdr := strings.NewReader(str)
tokens := html.NewTokenizer(rdr)
depth := 0
loop:
for {
tt := tokens.Next()
fmt.Printf("Token: type:%V ", tt)
switch tt {
// ErrorToken means that an error occurred during tokenization
case html.ErrorToken:
fmt.Println(" End:", tokens.Err().Error())
break loop
// TextToken means a text node
case html.TextToken:
t := tokens.Token()
for i:=0; i<len(t.Attr); i++ {
fmt.Print(" Attr:", t.Attr[i])
}
fmt.Println(" Text:",t.Data)
if in_td && len(t.Data) == 1 {
if (num_td & 1) == 1 {
num, err := strconv.Atoi(t.Data)
if err != nil {
log.Fatalf("%s\n", err.Error())
}
if num != num_entry {
fmt.Println("==>Test failed!\n\n")
return fmt.Errorf("Invalid integer: %d %s\n",num_entry,t.Data)
}
fmt.Println("\t\t\tNumEntry:",num_entry)
num_entry++
} else {
if nameEven != "" && (nameEven[0] + 1) != t.Data[0] {
fmt.Println("==>Test failed!\n\n")
return fmt.Errorf("Invalid name: %s %s\n",nameEven,t.Data)
}
nameEven = t.Data
fmt.Println("\t\t\tNameEven:",nameEven)
}
}
// A StartTagToken looks like <a>
case html.StartTagToken:
t := tokens.Token()
depth++
for i:=0; i<len(t.Attr); i++ {
fmt.Print(" Attr:", t.Attr[i])
}
fmt.Println(" StartTag:", depth, t.Data)
if t.Data == "td" {
in_td = true
num_td++
}
// An EndTagToken looks like </a>
case html.EndTagToken:
t := tokens.Token()
for i:=0; i<len(t.Attr); i++ {
fmt.Print(" Attr:", t.Attr[i])
}
depth--
fmt.Println(" EndTag:", depth, t.Data)
if t.Data == "td" {
in_td = false
}
// A SelfClosingTagToken tag looks like <br/>
case html.SelfClosingTagToken:
t := tokens.Token()
for i:=0; i<len(t.Attr); i++ {
fmt.Print(" Attr:", t.Attr[i])
}
fmt.Println(" Self Closing:",tt)
// A CommentToken looks like <!--x-->
case html.CommentToken:
t := tokens.Token()
for i:=0; i<len(t.Attr); i++ {
fmt.Print(" Attr:", t.Attr[i])
}
fmt.Println(" Comment:",t.Data)
// A DoctypeToken looks like <!DOCTYPE x>
case html.DoctypeToken:
t := tokens.Token()
for i:=0; i<len(t.Attr); i++ {
fmt.Print(" Attr:", t.Attr[i])
}
fmt.Println(" DocType:",t.Data)
}
}
fmt.Println("==>Test succeeded!\n\n")
return nil
}
func main() {
var err error
fmt.Println("Testing HTML2...\n")
err = ValidateFile("./data/app01sq_list_html2.txt")
fmt.Println("...End of HTML2 Tests...\n")
if err != nil {
fmt.Print(err.Error())
os.Exit(4)
}
fmt.Println("Testing HTML3...\n")
err = ValidateFile("./data/app01sq_list_html3.txt")
fmt.Println("...End of HTML3 Tests...\n")
if err == nil {
fmt.Print("Error - Test for html3 file should have failed!\n")
os.Exit(4)
}
}
|
package dbl
import (
"database/sql"
"errors"
"fmt"
_ "github.com/lib/pq"
"time"
)
type DAO struct {
db *sql.DB
ConnStr string
binDao *BinDao
fileDao *FileDao
infoDao *InfoDao
transactionDao *TransactionDao
}
// Init a database connection given
// a database name and user.
func Init(dbHost string, dbPort int, dbName, dbUser, dbPassword string) (DAO, error) {
var dao DAO
connStr := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", dbHost, dbPort, dbUser, dbPassword, dbName)
db, err := sql.Open("postgres", connStr)
if err != nil {
return dao, err
}
if err != nil {
return dao, err
}
if err := db.Ping(); err != nil {
return dao, errors.New(fmt.Sprintf("Unable to ping the database: %s:%d\n", dbHost, dbPort))
}
db.SetMaxOpenConns(25)
db.SetMaxIdleConns(25)
db.SetConnMaxLifetime(5 * time.Minute)
dao = DAO{db: db}
dao.ConnStr = connStr
dao.binDao = &BinDao{db: db}
dao.fileDao = &FileDao{db: db}
dao.infoDao = &InfoDao{db: db}
dao.transactionDao = &TransactionDao{db: db}
return dao, nil
}
func (dao DAO) Close() error {
return dao.db.Close()
}
func (dao DAO) CreateSchema() error {
// Not implemented
return nil
}
func (dao DAO) ResetDB() error {
sqlStatements := []string{
"DELETE FROM file",
"DELETE FROM bin",
"DELETE FROM transaction"}
for _, s := range sqlStatements {
if _, err := dao.db.Exec(s); err != nil {
fmt.Printf("Error in reset: %s\n", err.Error())
return err
}
}
return nil
}
func (dao DAO) Bin() *BinDao {
return dao.binDao
}
func (dao DAO) File() *FileDao {
return dao.fileDao
}
func (dao DAO) Info() *InfoDao {
return dao.infoDao
}
func (dao DAO) Transaction() *TransactionDao {
return dao.transactionDao
}
func (dao DAO) Status() bool {
if err := dao.db.Ping(); err != nil {
fmt.Printf("Database status check returned: %s\n", err.Error())
return false
}
return true
}
func (dao DAO) Stats() sql.DBStats {
return dao.db.Stats()
}
|
package src
import (
"github.com/barrydev/api-3h-shop/src/common/utils"
"github.com/gin-gonic/gin"
)
type App struct {
instance *gin.Engine
}
func (app *App) NewGinEngine() *gin.Engine {
_app := gin.Default()
_cors := utils.Cors()
_app.Use(_cors)
BindRouterWithApp(_app, []gin.HandlerFunc{_cors})
app.instance = _app
return _app
}
|
// Package network manages the network services of the application dataplane. This
// means ensuring that containers can find and communicate with each other in accordance
// with the policy specification. It achieves this by manipulating IP addresses and
// hostnames within the containers, Open vSwitch on each running worker, and the OVN
// controller.
package network
import (
"github.com/quilt/quilt/db"
"github.com/quilt/quilt/join"
"github.com/quilt/quilt/minion/ipdef"
"github.com/quilt/quilt/minion/ovsdb"
log "github.com/Sirupsen/logrus"
)
const labelMac = "0a:00:00:00:00:00"
const lSwitch = "quilt"
// Run blocks implementing the network services.
func Run(conn db.Conn) {
go runNat(conn)
go runDNS(conn)
go runUpdateIPs(conn)
for range conn.TriggerTick(30, db.MinionTable, db.ContainerTable,
db.ConnectionTable, db.LabelTable, db.EtcdTable).C {
if conn.EtcdLeader() {
runMaster(conn)
}
}
}
// The leader of the cluster is responsible for properly configuring OVN northd for
// container networking. This simply means creating a logical port for each container
// and label. The specialized OpenFlow rules Quilt requires are managed by the workers
// individuallly.
func runMaster(conn db.Conn) {
var init bool
var labels []db.Label
var containers []db.Container
var connections []db.Connection
conn.Txn(db.ConnectionTable, db.ContainerTable, db.EtcdTable,
db.LabelTable, db.MinionTable).Run(func(view db.Database) error {
init = checkSupervisorInit(view)
labels = view.SelectFromLabel(func(label db.Label) bool {
return label.IP != ""
})
containers = view.SelectFromContainer(func(dbc db.Container) bool {
return dbc.IP != ""
})
connections = view.SelectFromConnection(nil)
return nil
})
if !init {
return
}
ovsdbClient, err := ovsdb.Open()
if err != nil {
log.WithError(err).Error("Failed to connect to OVSDB.")
return
}
defer ovsdbClient.Disconnect()
ovsdbClient.CreateLogicalSwitch(lSwitch)
lports, err := ovsdbClient.ListLogicalPorts()
if err != nil {
log.WithError(err).Error("Failed to list OVN ports.")
return
}
dbcKey := func(val interface{}) interface{} {
return val.(db.Container).IP
}
portKey := func(val interface{}) interface{} {
return val.(ovsdb.LPort).Name
}
_, ovsps, dbcs := join.HashJoin(ovsdb.LPortSlice(lports),
db.ContainerSlice(containers), portKey, dbcKey)
for _, dbcIface := range dbcs {
dbc := dbcIface.(db.Container)
err := ovsdbClient.CreateLogicalPort(lSwitch, dbc.IP,
ipdef.IPStrToMac(dbc.IP), dbc.IP)
if err != nil {
log.WithError(err).Warnf("Failed to create logical port: %s",
dbc.IP)
} else {
log.Infof("New logical port: %s", dbc.IP)
}
}
for _, ovsp := range ovsps {
lport := ovsp.(ovsdb.LPort)
if err := ovsdbClient.DeleteLogicalPort(lSwitch, lport); err != nil {
log.WithError(err).Warnf("Failed to delete logical port: %s",
lport.Name)
} else {
log.Infof("Delete logical port: %s", lport.Name)
}
}
updateACLs(ovsdbClient, connections, labels)
}
func checkSupervisorInit(view db.Database) bool {
self, err := view.MinionSelf()
return err == nil && self.SupervisorInit
}
|
package amqp_kit
import (
"context"
"testing"
"time"
"github.com/streadway/amqp"
"github.com/stretchr/testify/suite"
)
type apiSuite struct {
suite.Suite
dsn string
conn *amqp.Connection
}
func (s *apiSuite) SetupSuite() {
var err error
s.dsn = MakeDsn(&Config{
Address: "127.0.0.1:5672",
User: "guest",
Password: "guest"},
)
s.conn, err = amqp.Dial(s.dsn)
s.Require().NoError(err)
}
func (s *apiSuite) TearDownSuite() {
s.conn.Close()
}
func TestApiSuite(t *testing.T) {
suite.Run(t, new(apiSuite))
}
func (s *apiSuite) TestServe() {
ch, err := s.conn.Channel()
s.NoError(err)
err = Declare(ch, `exc`, `test-a`, []string{`key.request.test`})
s.NoError(err)
dec1 := make(chan *amqp.Delivery)
dec2 := make(chan *amqp.Delivery)
subs := []SubscribeInfo{
{
Q: `test-a`,
Key: `key.request.test`,
E: func(ctx context.Context, request interface{}) (response interface{}, err error) {
return nil, nil
},
Dec: func(i context.Context, delivery *amqp.Delivery) (request interface{}, err error) {
s.Equal(delivery.RoutingKey, `key.request.test`)
dec1 <- delivery
return nil, nil
},
Enc: EncodeJSONResponse,
O: []SubscriberOption{SubscriberAfter(SetAckAfterEndpoint(true))},
},
}
subs1 := []SubscribeInfo{
{
Q: `test-a`,
Key: `key.request.test`,
E: func(ctx context.Context, request interface{}) (response interface{}, err error) {
return nil, nil
},
Dec: func(i context.Context, delivery *amqp.Delivery) (request interface{}, err error) {
s.Equal(delivery.RoutingKey, `key.request.test`)
dec2 <- delivery
return nil, nil
},
Enc: EncodeJSONResponse,
O: []SubscriberOption{SubscriberAfter(SetAckAfterEndpoint(true))},
},
}
ser := NewServer(subs, s.conn)
err = ser.Serve()
s.NoError(err)
ch, err = s.conn.Channel()
s.NoError(err)
pub := NewPublisher(ch)
err = pub.Publish("exc", "key.request.test", `cor_1`, []byte(`{"f1":"b1"}`))
s.NoError(err)
select {
case d := <-dec1:
s.Equal(d.Body, []byte(`{"f1":"b1"}`))
case <-time.After(5 * time.Second):
}
err = ser.Stop()
s.Require().NoError(err)
err = pub.Publish("exc", "key.request.test", `cor_2`, []byte(`{"f2":"b2"}`))
s.NoError(err)
select {
case d := <-dec1:
s.Empty(d)
case <-time.After(5 * time.Second):
}
ser = NewServer(subs1, s.conn)
err = ser.Serve()
s.NoError(err)
err = pub.Publish("exc", "key.request.test", `cor_3`, []byte(`{"f3":"b3"}`))
s.NoError(err)
select {
case d := <-dec2:
s.Equal(d.Body, []byte(`{"f2":"b2"}`))
case <-time.After(5 * time.Second):
s.Fail("timeout. waiting answer for cor_3")
}
select {
case d := <-dec2:
s.Equal(d.Body, []byte(`{"f3":"b3"}`))
case <-time.After(5 * time.Second):
s.Fail("timeout. waiting answer for cor_3")
}
}
|
/*
* Copyright © 2019-2022 Software AG, Darmstadt, Germany and/or its licensors
*
* 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 adabas
import (
"fmt"
"runtime"
"strconv"
"strings"
"testing"
"github.com/SoftwareAG/adabas-go-api/adatypes"
"github.com/stretchr/testify/assert"
)
var lastIsn adatypes.Isn
func BenchmarkConnection_cached(b *testing.B) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: BenchmarkConnection_cached")
adatypes.InitDefinitionCache()
defer adatypes.FinitDefinitionCache()
for i := 0; i < 1000; i++ {
// fmt.Print(".")
// if (i+1)%100 == 0 {
// fmt.Printf("%d/1000\n", i)
// }
err = readAll(b)
if err != nil {
return
}
}
}
func readAll(b *testing.B) error {
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(b, cerr) {
return cerr
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if !assert.NoError(b, rerr) {
fmt.Println("Error create request", rerr)
return rerr
}
err := request.QueryFields("NAME,FIRST-NAME,PERSONNEL-ID")
if !assert.NoError(b, err) {
return err
}
request.Limit = 0
result, rErr := request.ReadLogicalBy("NAME")
if !assert.NoError(b, rErr) {
return rErr
}
if !assert.Equal(b, 1107, len(result.Values)) {
return fmt.Errorf("Error length mismatch")
}
return nil
}
func BenchmarkConnection_noreconnect(b *testing.B) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: BenchmarkConnection_noreconnect")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(b, cerr) {
return
}
defer connection.Close()
for i := 0; i < 1000; i++ {
// fmt.Print(".")
// if (i+1)%100 == 0 {
// fmt.Printf("%d/1000\n", i)
// }
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if !assert.NoError(b, rerr) {
fmt.Println("Error create request", rerr)
return
}
err := request.QueryFields("NAME,FIRST-NAME,PERSONNEL-ID")
if !assert.NoError(b, err) {
return
}
request.Limit = 0
var result *Response
result, err = request.ReadLogicalBy("NAME")
if !assert.NoError(b, err) {
return
}
if !assert.Equal(b, 1107, len(result.Values)) {
return
}
}
}
func TestAuth(t *testing.T) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
//connection, cerr := NewConnection("acj;map;config=[177(adatcp://pinas:60177),4]")
connection, cerr := NewConnection("acj;target=" + adabasStatDBIDs + ";auth=NONE,user=TestAuth,id=4,host=xx")
if !assert.NoError(t, cerr) {
return
}
assert.Contains(t, connection.ID.String(), "xx :TestAuth [4] ")
connection.Close()
connection, cerr = NewConnection("acj;target=" + adabasStatDBIDs + ";auth=NONE,user=ABCDEFGHIJ,id=65535,host=KLMNOPQRSTUVWXYZ")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
assert.Contains(t, connection.ID.String(), "KLMNOPQR:ABCDEFGH [65535] ")
}
func TestConnectionRemoteMap(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
fmt.Println("Connect to ", adabasTCPLocation())
connection, cerr := NewConnection("acj;map;config=[177(adatcp://" + adabasTCPLocation() + "),4];auth=NONE,user=TCRemMap")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
for i := 0; i < 5; i++ {
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if !assert.NoError(t, rerr) {
fmt.Println("Error create request", rerr)
return
}
err := request.QueryFields("NAME,FIRST-NAME,PERSONNEL-ID")
if !assert.NoError(t, err) {
return
}
request.Limit = 0
var result *Response
result, err = request.ReadLogicalBy("NAME")
if !assert.NoError(t, err) {
return
}
if !assert.Equal(t, 1107, len(result.Values)) {
return
}
}
}
func TestConnectionRemoteMapStat(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
adatypes.InitDefinitionCache()
defer adatypes.FinitDefinitionCache()
statistics = true
connection, cerr := NewConnection("acj;map;config=[177(adatcp://" + adabasTCPLocation() + "),4];auth=NONE,user=TCRemMap")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
for i := 0; i < 3; i++ {
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if !assert.NoError(t, rerr) {
fmt.Println("Error create request", rerr)
return
}
err := request.QueryFields("NAME,FIRST-NAME,PERSONNEL-ID")
if !assert.NoError(t, err) {
return
}
request.Limit = 2
var result *Response
result, err = request.ReadLogicalBy("NAME")
if !assert.NoError(t, err) {
return
}
if !assert.Equal(t, 2, len(result.Values)) {
return
}
}
assert.Equal(t, "", connection.adabasToData.ID.user)
assert.Equal(t, "TCRemMap", string(connection.adabasToData.ID.AdaID.User[:]))
adabas := connection.adabasToData
if assert.NotNil(t, adabas.statistics) {
dumpAdabasStats(adabas.statistics)
assert.Equal(t, adabas.statistics, connection.adabasToMap.statistics)
assert.Equal(t, adabas.transactions, connection.adabasToMap.transactions)
s := adabas.statistics.statMap["OP"]
if assert.NotNil(t, s) {
// Should be only one OP
assert.Equal(t, uint64(1), s.calls)
}
s = adabas.statistics.statMap["LF"]
if assert.NotNil(t, s) {
// Should be LF of Map file and Data file
assert.Equal(t, uint64(2), s.calls)
}
assert.Equal(t, uint64(1), adabas.statistics.remote)
assert.Equal(t, uint64(8), adabas.statistics.remoteSend)
assert.Equal(t, uint64(8), adabas.statistics.remoteReceive)
assert.Equal(t, uint64(0), adabas.statistics.remoteClosed)
}
statistics = true
}
func dumpAdabasStats(stat *Statistics) {
fmt.Println("Number of calls:", stat.calls)
adatypes.Central.Log.Infof("Adabas statistics:")
for o, s := range stat.statMap {
fmt.Printf("%s[%s] = %v (%d)\n", s.code, o, s.timeNeeded, s.calls)
}
fmt.Printf("Remote opened : %d\n", stat.remote)
fmt.Printf("Remote closed : %d\n", stat.remoteClosed)
fmt.Printf("Remote send : %d\n", stat.remoteSend)
fmt.Printf("Remote received: %d\n", stat.remoteReceive)
}
func TestConnectionMap(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map=EMPLOYEES-NAT-DDM;config=[" + adabasStatDBIDs + ",4];auth=NONE,user=XMAP")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
for i := 0; i < 5; i++ {
fmt.Printf("%d. instance called\n", i+1)
request, rerr := connection.CreateReadRequest()
if !assert.NoError(t, rerr) {
fmt.Println("Error create request", rerr)
return
}
err := request.QueryFields("NAME,FIRST-NAME,PERSONNEL-ID")
if !assert.NoError(t, err) {
return
}
request.Limit = 0
var result *Response
result, err = request.ReadLogicalBy("NAME")
if !assert.NoError(t, err) {
return
}
if !assert.Equal(t, 1107, len(result.Values)) {
return
}
}
}
func BenchmarkConnection_noreconnectremote(b *testing.B) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: BenchmarkConnection_noreconnectremote")
connection, cerr := NewConnection("acj;map;config=[177(adatcp://" + adabasTCPLocation() + "),4]")
if !assert.NoError(b, cerr) {
return
}
defer connection.Close()
for i := 0; i < 1000; i++ {
// fmt.Print(".")
// if (i+1)%100 == 0 {
// fmt.Printf("%d/1000\n", i)
// }
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if !assert.NoError(b, rerr) {
fmt.Println("Error create request", rerr)
return
}
err := request.QueryFields("NAME,FIRST-NAME,PERSONNEL-ID")
if !assert.NoError(b, err) {
return
}
request.Limit = 0
var result *Response
result, err = request.ReadLogicalBy("NAME")
if !assert.NoError(b, err) {
return
}
if !assert.Equal(b, 1107, len(result.Values)) {
return
}
}
}
func checkVehicleMap(mapName string, jsonImport string) error {
databaseURL := &DatabaseURL{URL: *NewURLWithDbid(adabasModDBID), Fnr: 250}
mr := NewMapRepositoryWithURL(*databaseURL)
a, _ := NewAdabas(adabasStatDBID)
defer a.Close()
_, err := mr.SearchMap(a, mapName)
if err != nil {
fmt.Println("Search map, try loading map ...", err)
maps, err := LoadJSONMap(jsonImport)
if err != nil {
return err
}
fmt.Println("Number of maps", len(maps))
for _, m := range maps {
m.Repository = databaseURL
dataURL := &DatabaseURL{URL: *NewURLWithDbid(adabasModDBID), Fnr: m.Data.Fnr}
m.Data = dataURL
fmt.Println("Load map ...", m.String(), m.Data.URL.String())
err = m.Store()
if err != nil {
fmt.Println("Error loading map ...", err)
return err
}
}
}
return nil
}
func TestConnectionWithMultipleMap(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
initTestLogWithFile(t, "connection_map.log")
cerr := checkVehicleMap("VehicleMap", "VehicleMap.json")
if !assert.NoError(t, cerr) {
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[" + adabasModDBIDs + ",250|24,4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
fmt.Println("Connection : ", connection)
request, err := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if assert.NoError(t, err) {
fmt.Println("Limit query data:")
request.QueryFields("NAME,PERSONNEL-ID")
request.Limit = 0
fmt.Println("Read logigcal data:")
result, err := request.ReadLogicalWith("PERSONNEL-ID=[11100301:11100303]")
assert.NoError(t, err)
// fmt.Println("Result data:")
// result.DumpValues()
if assert.Equal(t, 3, len(result.Values)) {
ae := result.Values[1].HashFields["NAME"]
assert.Equal(t, "HAIBACH", strings.TrimSpace(ae.String()))
ei64, xErr := ae.Int64()
assert.Error(t, xErr, "Error should be send if value is string")
assert.Equal(t, int64(0), ei64)
}
}
request, err = connection.CreateMapReadRequest("VehicleMap")
if assert.NoError(t, err) {
fmt.Println("Limit query data:")
request.QueryFields("Vendor,Model")
request.Limit = 0
fmt.Println("Read logigcal data:")
result, err := request.ReadLogicalWith("Vendor=RENAULT")
assert.NoError(t, err)
// fmt.Println("Result data:")
// result.DumpValues()
if assert.Equal(t, 57, len(result.Values)) {
ae := result.Values[1].HashFields["Vendor"]
assert.Equal(t, "RENAULT", strings.TrimSpace(ae.String()))
ei64, xErr := ae.Int64()
assert.Error(t, xErr, "Error should be send if value is string")
assert.Equal(t, int64(0), ei64)
}
}
}
func TestConnectionMapPointingToRemote(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
initTestLogWithFile(t, "connection_map.log")
cerr := checkVehicleMap("REMPL11", "rempl11.json")
if !assert.NoError(t, cerr) {
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[" + adabasModDBIDs + ",250];auth=NONE,user=TCMapPoin,id=4,host=REMOTE")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
fmt.Println("Connection : ", connection)
request, err := connection.CreateMapReadRequest("REMPL11")
if assert.NoError(t, err) {
fmt.Println("Limit query data:")
request.QueryFields("NAME,PERSONNEL-ID")
request.Limit = 0
fmt.Println("Read logigcal data:")
result, err := request.ReadLogicalWith("PERSONNEL-ID=[11100301:11100303]")
assert.NoError(t, err)
// fmt.Println("Result data:")
// result.DumpValues()
if assert.NotNil(t, result) {
if assert.Equal(t, 3, len(result.Values)) {
ae := result.Values[1].HashFields["NAME"]
assert.Equal(t, "HAIBACH", strings.TrimSpace(ae.String()))
ei64, xErr := ae.Int64()
assert.Error(t, xErr, "Error should be send if value is string")
assert.Equal(t, int64(0), ei64)
}
}
}
}
func copyRecordData(adaValue adatypes.IAdaValue, x interface{}) (adatypes.TraverseResult, error) {
record := x.(*Record)
fmt.Println(adaValue.Type().Name(), "=", adaValue.String())
err := record.SetValueWithIndex(adaValue.Type().Name(), nil, adaValue.Value())
if err != nil {
fmt.Println("Error add Value: ", err)
return adatypes.EndTraverser, err
}
val, _ := record.SearchValue(adaValue.Type().Name())
fmt.Println("Search Value", val.String())
return adatypes.Continue, nil
}
func copyData(adabasRequest *adatypes.Request, x interface{}) (err error) {
store := x.(*StoreRequest)
var record *Record
record, err = store.CreateRecord()
if err != nil {
fmt.Printf("Error creating record %v\n", err)
return
}
tm := adatypes.TraverserValuesMethods{EnterFunction: copyRecordData}
_, err = adabasRequest.Definition.TraverseValues(tm, record)
if err != nil {
return err
}
fmt.Println("Record=", record.String())
adatypes.Central.Log.Debugf("Store init ..........")
err = store.Store(record)
if err != nil {
return err
}
adatypes.Central.Log.Debugf("Store done ..........")
return
}
func TestConnectionCopyMapTransaction(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
initTestLogWithFile(t, "connection_map.log")
adatypes.Central.Log.Infof("TEST: %s", t.Name())
cErr := clearFile(16)
if !assert.NoError(t, cErr) {
return
}
databaseURL := &DatabaseURL{URL: *NewURLWithDbid(adabasModDBID), Fnr: 4}
mr := NewMapRepositoryWithURL(*databaseURL)
ada, _ := NewAdabas(adabasModDBID)
_, err := mr.SearchMap(ada, "COPYEMPL")
if err != nil {
maps, merr := LoadJSONMap("COPYEMPL.json")
if !assert.NoError(t, merr) {
return
}
fmt.Println("Number of maps", len(maps))
assert.Equal(t, 1, len(maps))
maps[0].Repository = databaseURL
err = maps[0].Store()
if !assert.NoError(t, err) {
return
}
}
defer ada.Close()
DumpGlobalMapRepositories()
connection, cerr := NewConnection("acj;map;config=[" + adabasModDBIDs + ",4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
rconnection, rerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(t, rerr) {
return
}
defer rconnection.Close()
fmt.Println("Connection : ", connection)
store, err := connection.CreateMapStoreRequest("COPYEMPL")
if !assert.NoError(t, err) {
return
}
err = store.StoreFields("NAME,PERSONNEL-ID")
if !assert.NoError(t, err) {
return
}
request, rerr := rconnection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if assert.NoError(t, rerr) {
fmt.Println("Limit query data:")
request.QueryFields("NAME,PERSONNEL-ID")
request.Limit = 0
result := &Response{}
fmt.Println("Read logigcal data:")
err = request.ReadLogicalWithWithParser("PERSONNEL-ID=[11100000:11101000]", copyData, store)
assert.NoError(t, err)
// fmt.Println("Result data:")
// result.DumpValues()
if !assert.Equal(t, 0, len(result.Values)) {
return
}
}
err = store.EndTransaction()
assert.NoError(t, err)
connection.Close()
}
func ExampleConnection_readWithMap() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleAdabas_readFileDefinitionMap")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("NAME,FIRST-NAME,PERSONNEL-ID")
if err != nil {
return
}
request.Limit = 0
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadLogicalWith("PERSONNEL-ID=[11100314:11100317]")
if err != nil {
fmt.Println("Error read logical data", err)
return
}
_ = result.DumpValues()
// Output:Read logigcal data:
// Dump all result values
// Record Isn: 0393
// PERSONNEL-ID = > 11100314 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > WOLFGANG <
// NAME = > SCHMIDT <
// Record Isn: 0261
// PERSONNEL-ID = > 11100315 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > GLORIA <
// NAME = > MERTEN <
// Record Isn: 0262
// PERSONNEL-ID = > 11100316 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > HEINZ <
// NAME = > RAMSER <
// Record Isn: 0263
// PERSONNEL-ID = > 11100317 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > ALFONS <
// NAME = > DORSCH <
}
func ExampleConnection_readWithMapFormatted() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleConnection_readWithMapFormatted")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("NAME,FIRST-NAME,PERSONNEL-ID,BIRTH")
if err != nil {
return
}
request.Limit = 0
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadLogicalWith("PERSONNEL-ID=[11100314:11100317]")
if err != nil {
fmt.Println("Error reading", err)
return
}
_ = result.DumpValues()
// Output:Read logigcal data:
// Dump all result values
// Record Isn: 0393
// PERSONNEL-ID = > 11100314 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > WOLFGANG <
// NAME = > SCHMIDT <
// BIRTH = > 1953/08/18 <
// Record Isn: 0261
// PERSONNEL-ID = > 11100315 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > GLORIA <
// NAME = > MERTEN <
// BIRTH = > 1949/11/02 <
// Record Isn: 0262
// PERSONNEL-ID = > 11100316 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > HEINZ <
// NAME = > RAMSER <
// BIRTH = > 1978/12/23 <
// Record Isn: 0263
// PERSONNEL-ID = > 11100317 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > ALFONS <
// NAME = > DORSCH <
// BIRTH = > 1948/02/29 <
}
func ExampleConnection_readFileDefinitionMapGroup() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleConnection_readFileDefinitionMapGroup")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("FULL-NAME,PERSONNEL-ID,SALARY")
if err != nil {
fmt.Println("Error query fields for request", err)
return
}
request.Limit = 0
fmt.Println("Read logigcal data:")
var result *Response
result, err = request.ReadLogicalWith("PERSONNEL-ID=[11100315:11100316]")
if err != nil {
fmt.Println("Error read logical data", err)
return
}
_ = result.DumpValues()
// Output: Read logigcal data:
// Dump all result values
// Record Isn: 0261
// PERSONNEL-ID = > 11100315 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > GLORIA <
// NAME = > MERTEN <
// MIDDLE-I = > E <
// INCOME = [ 2 ]
// SALARY[01] = > 19076 <
// SALARY[02] = > 18000 <
// Record Isn: 0262
// PERSONNEL-ID = > 11100316 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > HEINZ <
// NAME = > RAMSER <
// MIDDLE-I = > E <
// INCOME = [ 1 ]
// SALARY[01] = > 28307 <
}
func BenchmarkConnection_simple(b *testing.B) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: BenchmarkConnection_simple")
for i := 0; i < 100; i++ {
// fmt.Print(".")
// if (i+1)%100 == 0 {
// fmt.Printf("%d/1000\n", i)
// }
err = readAll(b)
if err != nil {
return
}
}
}
func addEmployeeRecord(t *testing.T, storeRequest *StoreRequest, val string) error {
storeRecord16, rErr := storeRequest.CreateRecord()
if !assert.NoError(t, rErr) {
return rErr
}
err := storeRecord16.SetValue("PERSONNEL-ID", val)
if !assert.NoError(t, err) {
return err
}
err = storeRecord16.SetValue("FIRST-NAME", "THORSTEN "+val)
if !assert.NoError(t, err) {
return err
}
err = storeRecord16.SetValue("MIDDLE-I", "TKN")
if !assert.NoError(t, err) {
return err
}
err = storeRecord16.SetValue("NAME", "STORAGE_MAP")
if !assert.NoError(t, err) {
return err
}
// storeRecord16.DumpValues()
// fmt.Println("Stored Employees request")
adatypes.Central.Log.Debugf("Vehicles store started")
err = storeRequest.Store(storeRecord16)
if !assert.NoError(t, err) {
return err
}
return nil
}
func addVehiclesRecord(t *testing.T, storeRequest *StoreRequest, val string) error {
storeRecord, rErr := storeRequest.CreateRecord()
if !assert.NoError(t, rErr) {
return rErr
}
err := storeRecord.SetValue("REG-NUM", val)
if !assert.NoError(t, err) {
return err
}
err = storeRecord.SetValue("MAKE", "Concept "+val)
if !assert.NoError(t, err) {
return err
}
err = storeRecord.SetValue("MODEL", "Tesla")
if !assert.NoError(t, err) {
return err
}
err = storeRequest.Store(storeRecord)
if !assert.NoError(t, err) {
return err
}
lastIsn = storeRecord.Isn
return nil
}
const multipleMapRefName = "M16555"
const multipleMapRefName2 = "M19555"
func TestConnectionSimpleMultipleMapStore(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
initTestLogWithFile(t, "connection_map.log")
adatypes.Central.Log.Infof("TEST: %s", t.Name())
cErr := clearFile(16)
if !assert.NoError(t, cErr) {
return
}
cErr = clearFile(19)
if !assert.NoError(t, cErr) {
return
}
nr, cerr := checkStoreByFile(t, adabasModDBIDs, 16, multipleMapRefName)
assert.NoError(t, cerr)
assert.Equal(t, 0, nr)
nr, cerr = checkStoreByFile(t, adabasModDBIDs, 19, multipleMapRefName2)
assert.NoError(t, cerr)
assert.Equal(t, 0, nr)
adatypes.Central.Log.Infof("Prepare create test map")
dataRepository := &DatabaseURL{URL: *NewURLWithDbid(adabasModDBID), Fnr: 16}
perr := prepareCreateTestMap(massLoadSystransStore, massLoadSystrans, dataRepository)
if !assert.NoError(t, perr) {
return
}
dataRepository = &DatabaseURL{URL: *NewURLWithDbid(adabasModDBID), Fnr: 19}
vehicleMapName := mapVehicles + "Go"
perr = prepareCreateTestMap(vehicleMapName, vehicleSystransStore, dataRepository)
if !assert.NoError(t, perr) {
return
}
adatypes.Central.Log.Infof("Create connection...")
connection, err := NewConnection("acj;map;config=[" + adabasModDBIDs + ",250]")
if !assert.NoError(t, err) {
return
}
defer connection.Close()
storeRequest16, err := connection.CreateMapStoreRequest(massLoadSystransStore)
if !assert.NoError(t, err) {
return
}
recErr := storeRequest16.StoreFields("PERSONNEL-ID,FULL-NAME")
if !assert.NoError(t, recErr) {
return
}
err = addEmployeeRecord(t, storeRequest16, multipleMapRefName+"_0")
if err != nil {
return
}
storeRequest19, cErr := connection.CreateMapStoreRequest(vehicleMapName)
if !assert.NoError(t, cErr) {
return
}
recErr = storeRequest19.StoreFields("REG-NUM,CAR-DETAILS")
if !assert.NoError(t, recErr) {
return
}
err = addVehiclesRecord(t, storeRequest19, multipleMapRefName2+"_0")
if !assert.NoError(t, err) {
return
}
for i := 1; i < 10; i++ {
x := strconv.Itoa(i)
err = addEmployeeRecord(t, storeRequest16, multipleMapRefName+"_"+x)
if !assert.NoError(t, err) {
return
}
}
err = addVehiclesRecord(t, storeRequest19, multipleMapRefName2+"_1")
if !assert.NoError(t, err) {
return
}
fmt.Println("End transaction")
err = connection.EndTransaction()
if !assert.NoError(t, err) {
return
}
fmt.Println("Check stored data")
adatypes.Central.Log.Infof("Check stored data")
nr, cerr = checkStoreByFile(t, adabasModDBIDs, 16, multipleMapRefName)
assert.NoError(t, cerr)
assert.Equal(t, 10, nr)
nr, cerr = checkStoreByFile(t, adabasModDBIDs, 19, multipleMapRefName2)
assert.NoError(t, cerr)
assert.Equal(t, 2, nr)
connection.Close()
AddGlobalMapRepositoryReference(adabasModDBIDs + ",250")
a, _ := NewAdabas(1)
defer DelGlobalMapRepository(a, 250)
connection, err = NewConnection("acj;map")
if !assert.NoError(t, err) {
return
}
deleteRequest, derr := connection.CreateMapDeleteRequest(vehicleMapName)
if !assert.NoError(t, derr) {
return
}
err = deleteRequest.Delete(adatypes.Isn(lastIsn))
assert.NoError(t, err)
connection.Close()
}
func ExampleConnection_mapStore() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleConnection_mapStore")
if cErr := clearFile(16); cErr != nil {
return
}
if cErr := clearFile(19); cErr != nil {
fmt.Println("Error clearing 19", cErr)
return
}
dataRepository := &DatabaseURL{URL: *NewURLWithDbid(adabasModDBID), Fnr: 16}
if perr := prepareCreateTestMap(massLoadSystransStore, massLoadSystrans, dataRepository); perr != nil {
fmt.Println("Error creating map", massLoadSystransStore, perr)
return
}
dataRepository = &DatabaseURL{URL: *NewURLWithDbid(adabasModDBID), Fnr: 19}
vehicleMapName := mapVehicles + "Go"
if perr := prepareCreateTestMap(vehicleMapName, vehicleSystransStore, dataRepository); perr != nil {
return
}
adatypes.Central.Log.Infof("Create connection...")
connection, err := NewConnection("acj;map;config=[" + adabasModDBIDs + ",250]")
if err != nil {
return
}
defer connection.Close()
connection.Open()
storeRequest16, rErr := connection.CreateMapStoreRequest(massLoadSystransStore)
if rErr != nil {
return
}
err = storeRequest16.StoreFields("PERSONNEL-ID,NAME")
if err != nil {
fmt.Println("Error store", err)
return
}
record, err := storeRequest16.CreateRecord()
if err != nil {
fmt.Println("Error create record", err)
return
}
_ = record.SetValueWithIndex("PERSONNEL-ID", nil, "26555_0")
_ = record.SetValueWithIndex("NAME", nil, "WABER")
_ = record.SetValueWithIndex("FIRST-NAME", nil, "EMIL")
_ = record.SetValueWithIndex("MIDDLE-I", nil, "MERK")
err = storeRequest16.Store(record)
if err != nil {
fmt.Println("Error store record", err)
return
}
storeRequest19, rErr := connection.CreateMapStoreRequest(vehicleMapName)
if rErr != nil {
fmt.Println("Error create store request vehicle", rErr)
return
}
err = storeRequest19.StoreFields("REG-NUM,PERSONNEL-ID,CAR-DETAILS")
if err != nil {
fmt.Println("Error store fields", err)
return
}
record, err = storeRequest19.CreateRecord()
if err != nil {
fmt.Println("Create record", err)
return
}
err = record.SetValueWithIndex("REG-NUM", nil, "29555_0")
if err != nil {
fmt.Println("Error", err)
return
}
err = record.SetValueWithIndex("PERSONNEL-ID", nil, "WABER")
if err != nil {
fmt.Println("Error search in "+vehicleMapName, err)
return
}
err = record.SetValueWithIndex("MAKE", nil, "EMIL")
if err != nil {
fmt.Println("Error", err)
return
}
err = record.SetValueWithIndex("MODEL", nil, "MERK")
if err != nil {
fmt.Println("Error", err)
return
}
err = storeRequest19.Store(record)
if err != nil {
fmt.Println("Error", err)
return
}
err = connection.EndTransaction()
if err != nil {
fmt.Println("Error", err)
return
}
fmt.Println("Read file ..." + massLoadSystransStore)
err = dumpMapStoredData(adabasModDBIDs, massLoadSystransStore, "26555")
if err != nil {
fmt.Println("Error reading "+massLoadSystransStore, err)
return
}
fmt.Println("Read file ..." + vehicleMapName)
err = dumpMapStoredData(adabasModDBIDs, vehicleMapName, "29555")
if err != nil {
fmt.Println("Error reading "+vehicleMapName, err)
return
}
// Output: Clear file 16
// Success clearing file 16
// Clear file 19
// Success clearing file 19
// Read file ...EMPLDDM-GOLOAD-STORE
// Dump all result values
// Record Isn: 0001
// PERSONNEL-ID = > 26555_0 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > <
// NAME = > WABER <
// MIDDLE-I = > <
// Read file ...VEHICLESGo
// Dump all result values
// Record Isn: 0001
// REG-NUM = > 29555_0 <
// PERSONNEL-ID = > WABER <
// CAR-DETAILS = [ 1 ]
// MAKE = > EMIL <
// MODEL = > MERK <
// COLOR = > <
}
func dumpMapStoredData(target string, mapName string, search string) error {
connection, err := NewConnection("acj;map;config=[" + adabasModDBIDs + ",250]")
if err != nil {
return err
}
defer connection.Close()
readRequest, rrerr := connection.CreateMapReadRequest(mapName)
if rrerr != nil {
return rrerr
}
fields := "PERSONNEL-ID,FULL-NAME"
searchField := "PERSONNEL-ID"
switch mapName {
case mapVehicles:
fields = "AA,CD"
searchField = "AA"
case mapVehicles + "Go":
fields = "REG-NUM,PERSONNEL-ID,CAR-DETAILS"
searchField = "REG-NUM"
}
err = readRequest.QueryFields(fields)
if err != nil {
return err
}
result, rerr := readRequest.ReadLogicalWith(searchField + "=[" + search + "_:" + search + "_Z]")
if rerr != nil {
return rerr
}
for i, record := range result.Values {
record.Isn = adatypes.Isn(i + 1)
}
_ = result.DumpValues()
return nil
}
func ExampleConnection_readShortMap() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: func ExampleConnection_readShortMap()")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLSHORT")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("*")
if err != nil {
return
}
request.Limit = 0
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadLogicalWith("ID=[11100314:11100317]")
if err != nil {
fmt.Println("Error read logical", err)
return
}
_ = result.DumpValues()
// Output:Read logigcal data:
// Dump all result values
// Record Isn: 0393
// ID = > 11100314 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > WOLFGANG <
// NAME = > SCHMIDT <
// MIDDLE-NAME = > MARIA <
// Record Isn: 0261
// ID = > 11100315 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > GLORIA <
// NAME = > MERTEN <
// MIDDLE-NAME = > ELISABETH <
// Record Isn: 0262
// ID = > 11100316 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > HEINZ <
// NAME = > RAMSER <
// MIDDLE-NAME = > EWALD <
// Record Isn: 0263
// ID = > 11100317 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > ALFONS <
// NAME = > DORSCH <
// MIDDLE-NAME = > FRITZ <
}
func ExampleConnection_readLongMapIsn() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleAdabas_readFileDefinitionMap")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("*")
if err != nil {
fmt.Println("Error query fields", err)
return
}
request.Limit = 0
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadISN(1)
if err != nil {
fmt.Println("Error search value", err)
return
}
for _, v := range result.Values {
f, e := v.SearchValue("creation_time")
if e != nil {
fmt.Println("Error search value", e)
return
}
_ = f.SetValue(0)
f, e = v.SearchValue("Last_Updates[01]")
if e != nil || f == nil {
fmt.Println(e)
return
}
_ = f.SetValue(0)
}
fmt.Println(result.String())
// Output:Read logigcal data:
// Record Isn: 0001
// personnel-data = [ 1 ]
// personnel-id = > 50005800 <
// id-data = [ 1 ]
// personnel-no_-UQ_taken- = > 0 <
// id-card = > 0 <
// signature = > <
// full-name = [ 1 ]
// first-name = > Simone <
// middle-name = > <
// name = > Adam <
// mar-stat = > M <
// sex = > F <
// birth = > 718460 <
// private-address = [ 1 ]
// address-line[01] = [ 1 ]
// address-line[01,01] = > 26 Avenue Rhin Et Da <
// city[01] = > Joigny <
// post-code[01] = > 89300 <
// country[01] = > F <
// phone-email[01] = [ 1 ]
// area-code[01] = > 1033 <
// private-phone[01] = > 44864858 <
// private-fax[01] = > <
// private-mobile[01] = > <
// private-email[01] = [ 0 ]
// business-address = [ 0 ]
// dept = > VENT59 <
// job-title = > Chef de Service <
// income = [ 1 ]
// curr-code[01] = > EUR <
// salary_P9.2[01] = > 963 <
// bonus_P9.2[01] = [ 1 ]
// bonus_P9.2[01,01] = > 138 <
// total_income_-EUR- = > 0.000000 <
// leave-date = [ 1 ]
// leave-due = > 19 <
// leave-taken_N2.1 = > 5 <
// leave-booked = [ 1 ]
// leave-start[01] = > 20070801 <
// leave-end[01] = > 20070831 <
// language = [ 2 ]
// language[01] = > FRE <
// language[02] = > ENG <
// last_update_--TIMX- = > 0 <
// picture = > <
// documents = [ 0 ]
// creation_time = > 0 <
// Last_Updates = [ 1 ]
// Last_Updates[01] = > 0 <
}
func ExampleConnection_readLongMapRange() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleConnection_readLongMapRange")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("*")
if err != nil {
return
}
request.Limit = 0
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadLogicalWith("personnel-id=[50005800:50005801]")
if err != nil {
fmt.Println("Read error", err)
return
}
for _, v := range result.Values {
f, e := v.SearchValue("creation_time")
if e != nil {
fmt.Println("Search error", e)
return
}
_ = f.SetValue(0)
f, e = v.SearchValue("Last_Updates[01]")
if e != nil || f == nil {
fmt.Println(e)
return
}
_ = f.SetValue(0)
}
_ = result.DumpValues()
// Output:Read logigcal data:
// Dump all result values
// Record Isn: 0001
// personnel-data = [ 1 ]
// personnel-id = > 50005800 <
// id-data = [ 1 ]
// personnel-no_-UQ_taken- = > 0 <
// id-card = > 0 <
// signature = > <
// full-name = [ 1 ]
// first-name = > Simone <
// middle-name = > <
// name = > Adam <
// mar-stat = > M <
// sex = > F <
// birth = > 718460 <
// private-address = [ 1 ]
// address-line[01] = [ 1 ]
// address-line[01,01] = > 26 Avenue Rhin Et Da <
// city[01] = > Joigny <
// post-code[01] = > 89300 <
// country[01] = > F <
// phone-email[01] = [ 1 ]
// area-code[01] = > 1033 <
// private-phone[01] = > 44864858 <
// private-fax[01] = > <
// private-mobile[01] = > <
// private-email[01] = [ 0 ]
// business-address = [ 0 ]
// dept = > VENT59 <
// job-title = > Chef de Service <
// income = [ 1 ]
// curr-code[01] = > EUR <
// salary_P9.2[01] = > 963 <
// bonus_P9.2[01] = [ 1 ]
// bonus_P9.2[01,01] = > 138 <
// total_income_-EUR- = > 0.000000 <
// leave-date = [ 1 ]
// leave-due = > 19 <
// leave-taken_N2.1 = > 5 <
// leave-booked = [ 1 ]
// leave-start[01] = > 20070801 <
// leave-end[01] = > 20070831 <
// language = [ 2 ]
// language[01] = > FRE <
// language[02] = > ENG <
// last_update_--TIMX- = > 0 <
// picture = > <
// documents = [ 0 ]
// creation_time = > 0 <
// Last_Updates = [ 1 ]
// Last_Updates[01] = > 0 <
// Record Isn: 1251
// personnel-data = [ 1 ]
// personnel-id = > 50005801 <
// id-data = [ 1 ]
// personnel-no_-UQ_taken- = > 0 <
// id-card = > 0 <
// signature = > <
// full-name = [ 1 ]
// first-name = > वासुदेव <
// middle-name = > मूर्ती <
// name = > कुमार <
// mar-stat = > M <
// sex = > M <
// birth = > 721484 <
// private-address = [ 1 ]
// address-line[01] = [ 1 ]
// address-line[01,01] = > ह-1,दिशा स्क्यलैइन म <
// city[01] = > नोयडा <
// post-code[01] = > 201301 <
// country[01] = > IND <
// phone-email[01] = [ 1 ]
// area-code[01] = > 01189 <
// private-phone[01] = > 233449 <
// private-fax[01] = > <
// private-mobile[01] = > <
// private-email[01] = [ 0 ]
// business-address = [ 0 ]
// dept = > COMP02 <
// job-title = > सीनियर प्रोग्रामर <
// income = [ 1 ]
// curr-code[01] = > INR <
// salary_P9.2[01] = > 45000 <
// bonus_P9.2[01] = [ 5 ]
// bonus_P9.2[01,01] = > 5000 <
// bonus_P9.2[01,02] = > 5000 <
// bonus_P9.2[01,03] = > 5000 <
// bonus_P9.2[01,04] = > 5000 <
// bonus_P9.2[01,05] = > 5000 <
// total_income_-EUR- = > 0.000000 <
// leave-date = [ 1 ]
// leave-due = > 8 <
// leave-taken_N2.1 = > 7 <
// leave-booked = [ 1 ]
// leave-start[01] = > 20060915 <
// leave-end[01] = > 20060922 <
// language = [ 2 ]
// language[01] = > HIN <
// language[02] = > ENG <
// last_update_--TIMX- = > 0 <
// picture = > <
// documents = [ 0 ]
// creation_time = > 0 <
// Last_Updates = [ 1 ]
// Last_Updates[01] = > 0 <
}
func TestConnection_readAllMap(t *testing.T) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES")
if !assert.NoError(t, rerr) {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("*")
if !assert.NoError(t, err) {
return
}
request.Limit = 0
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadISN(1)
if !assert.NoError(t, err) {
return
}
//result.DumpValues()
if assert.Equal(t, 1, len(result.Values)) {
v, verr := result.Values[0].SearchValue("last_update_--TIMX-")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "0", v.String())
}
}
func TestConnection_readReference(t *testing.T) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("LOBPICTURE")
if !assert.NoError(t, rerr) {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("Filename,@Thumbnail")
if !assert.NoError(t, err) {
return
}
request.Limit = 0
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadISN(1)
if !assert.NoError(t, err) {
return
}
// result.DumpValues()
if assert.Equal(t, 1, len(result.Values)) {
v, verr := result.Values[0].SearchValue("Filename")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "106-0670_IMG.JPG", v.String())
v, verr = result.Values[0].SearchValue("@Thumbnail")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "/image/map/LOBPICTURE/1/Thumbnail", v.String())
}
result, err = request.ReadISN(2)
if !assert.NoError(t, err) {
return
}
// result.DumpValues()
if assert.Equal(t, 1, len(result.Values)) {
v, verr := result.Values[0].SearchValue("Filename")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "p1.jpg", v.String())
v, verr = result.Values[0].SearchValue("@Thumbnail")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "/image/map/LOBPICTURE/2/Thumbnail", v.String())
}
}
func TestConnection_readReferenceList(t *testing.T) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("LOBPICTURE")
if !assert.NoError(t, rerr) {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("Filename,@Thumbnail")
if !assert.NoError(t, err) {
return
}
request.Limit = 3
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadLogicalBy("Filename")
if !assert.NoError(t, err) {
return
}
// result.DumpValues()
if assert.Equal(t, 3, len(result.Values)) {
v, verr := result.Values[0].SearchValue("Filename")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "106-0670_IMG.JPG", v.String())
v, verr = result.Values[0].SearchValue("@Thumbnail")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "/image/map/LOBPICTURE/1/Thumbnail", v.String())
v, verr = result.Values[1].SearchValue("Filename")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "DSCF3544_2.JPG", v.String())
v, verr = result.Values[1].SearchValue("@Thumbnail")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "/image/map/LOBPICTURE/27/Thumbnail", v.String())
v, verr = result.Values[2].SearchValue("Filename")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "DSCN0529.JPG", v.String())
v, verr = result.Values[2].SearchValue("@Thumbnail")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "/image/map/LOBPICTURE/26/Thumbnail", v.String())
}
}
func ExampleConnection_mapReadUnicode() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleConnection_mapReadUnicode")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("PERSONNEL-ID,FULL-NAME")
if err != nil {
return
}
request.Start = 1025
request.Limit = 3
var result *Response
fmt.Println("Read using ISN order:")
result, err = request.ReadByISN()
if err != nil {
fmt.Println("Error reading ISN order", err)
return
}
_ = result.DumpValues()
// Output: Read using ISN order:
// Dump all result values
// Record Isn: 1025
// PERSONNEL-ID = > 30021215 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > SYLVIA <
// NAME = > BURTON <
// MIDDLE-I = > J <
// Record Isn: 1026
// PERSONNEL-ID = > 30021311 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > GERARD <
// NAME = > JOHNSTONE <
// MIDDLE-I = > E <
// Record Isn: 1027
// PERSONNEL-ID = > 30021312 <
// FULL-NAME = [ 1 ]
// FIRST-NAME = > NORMA <
// NAME = > FRANCIS <
// MIDDLE-I = > <
}
func ExampleConnection_mapReadUnicodeNew() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleConnection_mapReadUnicodeNew")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("personnel-id,full-name")
if err != nil {
return
}
request.Start = 1250
request.Limit = 3
var result *Response
fmt.Println("Read using ISN order:")
result, err = request.ReadByISN()
if err != nil {
fmt.Println("Error reading ISN order", err)
return
}
_ = result.DumpValues()
// Output: Read using ISN order:
// Dump all result values
// Record Isn: 1250
// personnel-data = [ 1 ]
// personnel-id = > 73002200 <
// full-name = [ 1 ]
// first-name = > Игорь <
// middle-name = > Петрович <
// name = > Михайлов <
// Record Isn: 1251
// personnel-data = [ 1 ]
// personnel-id = > 50005801 <
// full-name = [ 1 ]
// first-name = > वासुदेव <
// middle-name = > मूर्ती <
// name = > कुमार <
// Record Isn: 1252
// personnel-data = [ 1 ]
// personnel-id = > 50005501 <
// full-name = [ 1 ]
// first-name = > विनोद <
// middle-name = > अभगे <
// name = > अरविद <
}
func TestConnection_readGroup(t *testing.T) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if !assert.NoError(t, rerr) {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("FULL-ADDRESS")
if !assert.NoError(t, err) {
return
}
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadISN(1)
if !assert.NoError(t, err) {
return
}
// result.DumpValues()
v, verr := result.Values[0].SearchValue("CITY")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "JOIGNY ", v.String())
v, verr = result.Values[0].SearchValue("ZIP")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "89300 ", v.String())
v, verr = result.Values[0].SearchValue("COUNTRY")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "F ", v.String())
}
func ExampleConnection_mapReadDisjunctSearch() {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: ExampleConnection_mapReadDisjunctSearch")
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if cerr != nil {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("EMPLOYEES")
if rerr != nil {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("personnel-id")
if err != nil {
return
}
request.Limit = 0
var result *Response
fmt.Println("Read using ISN order:")
result, err = request.ReadLogicalWith("name=SMITH")
if err != nil {
fmt.Println("Error reading ISN order", err)
return
}
_ = result.DumpValues()
// Output: Read using ISN order:
// Dump all result values
// Record Isn: 0579
// personnel-data = [ 1 ]
// personnel-id = > 20009300 <
// Record Isn: 0634
// personnel-data = [ 1 ]
// personnel-id = > 20015400 <
// Record Isn: 0670
// personnel-data = [ 1 ]
// personnel-id = > 20018800 <
// Record Isn: 0727
// personnel-data = [ 1 ]
// personnel-id = > 20025200 <
// Record Isn: 0787
// personnel-data = [ 1 ]
// personnel-id = > 20000400 <
}
func TestConnectionAndSearchMap(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
if runtime.GOARCH == "arm" {
t.Skip("Not supported on this architecture")
return
}
initTestLogWithFile(t, "connection.log")
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
adatypes.Central.Log.Debugf("Created connection : %#v", connection)
request, err := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if assert.NoError(t, err) {
fmt.Println("Limit query data:")
request.QueryFields("FULL-NAME")
request.Limit = 0
fmt.Println("Read logigcal data:")
result, err := request.ReadLogicalWith("NAME>'ADAM' AND NAME<'AECKERLE'")
assert.NoError(t, err)
validateResult(t, "osandsearch", result)
}
}
func TestConnectionOsMap(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
if runtime.GOARCH == "arm" {
t.Skip("Not supported on this architecture")
return
}
initTestLogWithFile(t, "connection.log")
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[24,4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
adatypes.Central.Log.Debugf("Created connection : %#v", connection)
request, err := connection.CreateMapReadRequest("EMPLOYEES-NAT-DDM")
if assert.NoError(t, err) {
fmt.Println("Limit query data:")
err = request.QueryFields("*")
assert.NoError(t, err)
request.Limit = 20
fmt.Println("Read logigcal data:")
result, err := request.ReadLogicalBy("PERSONNEL-ID")
if !assert.NoError(t, err) {
return
}
_ = result.DumpValues()
fmt.Println("Check size ...", len(result.Values))
if assert.Equal(t, 20, len(result.Values)) {
ae := result.Values[1].HashFields["NAME"]
fmt.Println("Check SCHIRM ...")
assert.Equal(t, "SCHIRM", strings.TrimSpace(ae.String()))
ei64, xErr := ae.Int64()
assert.Error(t, xErr, "Error should be send if value is string")
assert.Equal(t, int64(0), ei64)
ae = result.Values[19].HashFields["NAME"]
fmt.Println("Check BLAU ...")
assert.Equal(t, "BLAU", strings.TrimSpace(ae.String()))
validateResult(t, "osallread", result)
}
}
}
func TestConnection_cyrillicMap(t *testing.T) {
err := initLogWithFile("connection_map.log")
if err != nil {
fmt.Println(err)
return
}
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[" + adabasStatDBIDs + ",4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
request, rerr := connection.CreateMapReadRequest("Cyrilic2")
if !assert.NoError(t, rerr) {
fmt.Println("Error create request", rerr)
return
}
err = request.QueryFields("*")
if !assert.NoError(t, err) {
return
}
request.Limit = 0
var result *Response
fmt.Println("Read logigcal data:")
result, err = request.ReadISN(1)
if !assert.NoError(t, err) {
return
}
_ = result.DumpValues()
if assert.Equal(t, 1, len(result.Values)) {
v, verr := result.Values[0].SearchValue("cyrilic")
if !assert.NoError(t, verr) {
return
}
assert.Equal(t, "Покупатели", v.String())
}
}
func TestConnectionMapCharset(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
if runtime.GOARCH == "arm" {
t.Skip("Not supported on this architecture")
return
}
initTestLogWithFile(t, "connection.log")
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[24,4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
adatypes.Central.Log.Debugf("Created connection : %#v", connection)
request, err := connection.CreateMapReadRequest("Cyrilic2")
if assert.NoError(t, err) {
fmt.Println("Limit query data:")
err = request.QueryFields("*")
assert.NoError(t, err)
request.Limit = 20
fmt.Println("Read logigcal data:")
result, err := request.ReadLogicalBy("ascii")
if !assert.NoError(t, err) {
return
}
_ = result.DumpValues()
fmt.Println("Check size ...", len(result.Values))
if assert.Equal(t, 20, len(result.Values)) {
ae := result.Values[1].HashFields["cyrilic"]
assert.Equal(t, "АлтайГАЗавтосервис", strings.TrimSpace(ae.String()))
aa := result.Values[1].HashFields["ascii"]
assert.Equal(t, "10", strings.TrimSpace(aa.String()))
ae = result.Values[19].HashFields["cyrilic"]
assert.Equal(t, "XXI Век-Авто", strings.TrimSpace(ae.String()))
aa = result.Values[19].HashFields["ascii"]
assert.Equal(t, "10H", strings.TrimSpace(aa.String()))
validateResult(t, "cyrilic2", result)
}
}
}
func TestConnectionMapFractional(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
if runtime.GOARCH == "arm" {
t.Skip("Not supported on this architecture")
return
}
initTestLogWithFile(t, "connection.log")
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[24,4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
adatypes.Central.Log.Debugf("Created connection : %#v", connection)
request, err := connection.CreateMapReadRequest("Fractional")
if assert.NoError(t, err) {
fmt.Println("Limit query data:")
err = request.QueryFields("*")
assert.NoError(t, err)
request.Limit = 7
fmt.Println("Read logigcal data:")
result, err := request.ReadByISN()
if !assert.NoError(t, err) {
return
}
// result.DumpValues()
fmt.Println("Check size ...", len(result.Values))
if assert.Equal(t, 7, len(result.Values)) {
ae := result.Values[1].HashFields["ALPHA10"]
assert.Equal(t, "ABC10", strings.TrimSpace(ae.String()))
aa := result.Values[1].HashFields["ALPHA3"]
assert.Equal(t, "ABC", strings.TrimSpace(aa.String()))
aa = result.Values[1].HashFields["FRACT1"]
assert.Equal(t, "10.44", strings.TrimSpace(aa.String()))
aa = result.Values[1].HashFields["FLOAT8"]
assert.Equal(t, "10.200000", strings.TrimSpace(aa.String()))
ae = result.Values[0].HashFields["ALPHA10"]
assert.Equal(t, "ABC1", strings.TrimSpace(ae.String()))
aa = result.Values[0].HashFields["FLOAT8"]
assert.Equal(t, "1.200000", strings.TrimSpace(aa.String()))
ae = result.Values[6].HashFields["ALPHA10"]
assert.Equal(t, "ABC1000000", strings.TrimSpace(ae.String()))
aa = result.Values[6].HashFields["ALPHA3"]
assert.Equal(t, "ABC", strings.TrimSpace(aa.String()))
aa = result.Values[6].HashFields["FRACT1"]
assert.Equal(t, "1000000.44", strings.TrimSpace(aa.String()))
aa = result.Values[6].HashFields["FLOAT8"]
assert.Equal(t, "1000000.200000", strings.TrimSpace(aa.String()))
validateResult(t, "fractional", result)
}
}
}
func TestConnectionMUsystemField(t *testing.T) {
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
if runtime.GOARCH == "arm" {
t.Skip("Not supported on this architecture")
return
}
initTestLogWithFile(t, "connection_map.log")
adatypes.Central.Log.Infof("TEST: %s", t.Name())
connection, cerr := NewConnection("acj;map;config=[23,4]")
if !assert.NoError(t, cerr) {
return
}
defer connection.Close()
adatypes.Central.Log.Debugf("Created connection : %#v", connection)
request, err := connection.CreateMapReadRequest("ADABAS_MAP")
if assert.NoError(t, err) {
fmt.Println("Limit query data:")
err = request.QueryFields("MAPPING")
assert.NoError(t, err)
request.Limit = 3
request.Multifetch = 1
fmt.Println("Read logigcal data:")
result, err := request.ReadByISN()
if !assert.NoError(t, err) {
return
}
// result.DumpValues()
fmt.Println("Check size ...", len(result.Values))
if assert.Equal(t, 3, len(result.Values)) {
validateResult(t, "ADABAS_MAP", result)
}
}
}
|
package dto
import (
"fmt"
)
//This structure will be returned by REST API to client.
type RestResponse struct {
Error string `json:",omitempty"`
TaskId int64
Data []Dto
}
func NewRestResponse(err string, taskId int64, data []Dto) *RestResponse {
rr := new(RestResponse)
rr.Error = err
rr.TaskId = taskId
rr.Data = data
return rr
}
func (r *RestResponse) String() string {
return fmt.Sprintf("Rest response with TaskId = %d with Error = %s and data:\n%s", r.TaskId, r.Error, r.Data)
}
|
package redis
import (
"context"
"github.com/go-redis/redis/v8"
)
func GetDB() (client redis.UniversalClient, err error) {
switch RedisConfig.Mode {
case "single":
client = redis.NewClient(&redis.Options{
Network: "tcp",
Addr: RedisConfig.Addr,
Password: RedisConfig.Password,
DB: RedisConfig.DbName,
})
case "cluster":
client = redis.NewClusterClient(&redis.ClusterOptions{
Addrs: RedisConfig.Addrs,
Password: RedisConfig.Password,
})
case "sentinel":
client = redis.NewFailoverClient(&redis.FailoverOptions{
MasterName: RedisConfig.Master,
SentinelAddrs: RedisConfig.Addrs,
Password: RedisConfig.Password,
DB: RedisConfig.DbName,
})
default:
client = redis.NewClient(&redis.Options{
Network: "tcp",
Addr: RedisConfig.Addr,
Password: RedisConfig.Password,
DB: RedisConfig.DbName,
})
}
statusCmd := client.Ping(context.TODO())
return client, statusCmd.Err()
}
|
package main
import (
"context"
"io"
"log"
"testing"
"concurrency"
)
var requests = concurrency.GenerateRequests(concurrency.Count)
func init() {
log.SetOutput(io.Discard)
}
func BenchmarkErrGroupPrealloc(b *testing.B) {
for n := 0; n < b.N; n++ {
DoAsync(context.TODO(), requests)
}
}
|
package c44_dsa_repeated_nonce
import (
"bufio"
"bytes"
"crypto/sha1"
"math/big"
"os"
"strings"
"testing"
"github.com/vodafon/cryptopals/set1/c1_hex_to_base64"
"github.com/vodafon/cryptopals/set6/c43_dsa_from_nonce"
)
func TestExploit(t *testing.T) {
texts := loadTexts("./testdata/44.txt")
dsa := c43_dsa_from_nonce.NewDSA()
exp := []byte("ca8f6f7c66fa362d40760d135b763eb8527d3d52")
x, err := Exploit(dsa, texts)
if err != nil {
t.Fatalf("Exploit error: %s\n", err)
}
hex := c1_hex_to_base64.EncodeHex(x.Bytes())
sum := sha1.Sum(hex)
res := c1_hex_to_base64.EncodeHex(sum[:])
if !bytes.Equal(exp, res) {
t.Errorf("Incorrect result. Expected %q, got %q\n", exp, res)
}
}
func loadTexts(filepath string) []Text {
file, err := os.Open(filepath)
if err != nil {
panic(err)
}
defer file.Close()
texts := []Text{}
i := 1
text := Text{}
scanner := bufio.NewScanner(file)
for scanner.Scan() {
bline := scanner.Text()
switch i % 4 {
case 1:
text.Msg = []byte(bline[5:])
case 2:
text.S = stringToBig(bline[3:], 10)
case 3:
text.R = stringToBig(bline[3:], 10)
case 0:
text.M = stringToBig(bline[3:], 16)
texts = append(texts, text)
text = Text{}
}
i += 1
}
if err := scanner.Err(); err != nil {
panic(err)
}
return texts
}
func stringToBig(src string, base int) *big.Int {
src = strings.TrimSpace(src)
r, ok := new(big.Int).SetString(src, base)
if !ok {
panic("bytesToBig failed")
}
return r
}
|
package tsrv
import (
"encoding/xml"
"github.com/thought-machine/finance-messaging/iso20022"
)
type Document01200101 struct {
XMLName xml.Name `xml:"urn:iso:std:iso:20022:tech:xsd:tsrv.012.001.01 Document"`
Message *UndertakingTerminationNotificationV01 `xml:"UdrtkgTermntnNtfctn"`
}
func (d *Document01200101) AddMessage() *UndertakingTerminationNotificationV01 {
d.Message = new(UndertakingTerminationNotificationV01)
return d.Message
}
// The UndertakingTerminationNotification message is sent to the applicant by the party that issued the undertaking to give notification of the termination or cancelation of the referenced undertaking.
type UndertakingTerminationNotificationV01 struct {
// Details of the termination notification.
UndertakingTerminationNotificationDetails *iso20022.UndertakingTerminationNotice1 `xml:"UdrtkgTermntnNtfctnDtls"`
// Digital signature of the notification.
DigitalSignature *iso20022.PartyAndSignature2 `xml:"DgtlSgntr,omitempty"`
}
func (u *UndertakingTerminationNotificationV01) AddUndertakingTerminationNotificationDetails() *iso20022.UndertakingTerminationNotice1 {
u.UndertakingTerminationNotificationDetails = new(iso20022.UndertakingTerminationNotice1)
return u.UndertakingTerminationNotificationDetails
}
func (u *UndertakingTerminationNotificationV01) AddDigitalSignature() *iso20022.PartyAndSignature2 {
u.DigitalSignature = new(iso20022.PartyAndSignature2)
return u.DigitalSignature
}
|
package pixelproxy
import (
"context"
"fmt"
"net/http"
"os"
"path/filepath"
"sync"
"time"
"github.com/danjacques/pixelproxy/applications/pixelproxy/storage"
"github.com/danjacques/pixelproxy/applications/pixelproxy/web"
"github.com/danjacques/pixelproxy/util"
"github.com/danjacques/pixelproxy/util/logging"
"github.com/danjacques/gopushpixels/device"
"github.com/danjacques/gopushpixels/discovery"
"github.com/danjacques/gopushpixels/protocol"
"github.com/danjacques/gopushpixels/proxy"
"github.com/danjacques/gopushpixels/replay"
"github.com/danjacques/gopushpixels/replay/streamfile"
"github.com/danjacques/gopushpixels/support/network"
"github.com/gorilla/mux"
"github.com/pkg/errors"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
"github.com/spf13/cobra"
"go.uber.org/zap"
)
// Application-level flag variables.
var (
app = util.Application{
Verbosity: zap.WarnLevel,
Production: true,
ColorizeLogs: true,
}
interfaceName = ""
discoveryAddress = ""
discoveryExpiration = time.Minute
proxyAddress = ""
proxyDiscoveryPeriod = time.Second
proxyGroupOffset = int32(0)
playbackMaxLagAge = 100 * time.Millisecond
playbackAutoResumeDelay = time.Duration(0)
httpAddr = ":80"
httpCacheAssets = true
storagePath = filepath.Join(os.TempDir(), "pixelproxy")
storageWriteCompression = streamfile.CompressionFlag(streamfile.Compression_SNAPPY)
storageWriteCompressionLevel = -1
enableSnapshot = false
snapshotSampleRate = 2 * time.Second
)
func init() {
// Register external monitoring.
proxy.RegisterMonitoring(prometheus.DefaultRegisterer)
replay.RegisterMonitoring(prometheus.DefaultRegisterer)
// Set up root command.
pf := rootCmd.PersistentFlags()
app.AddFlags(pf)
pf.StringVar(&interfaceName, "interface", interfaceName,
"Name of the network interface to use. If empty, an interface will be chosen.")
pf.StringVar(&discoveryAddress, "discovery_address", discoveryAddress,
"Local address to listen on for discovery. If empty, listen on default address.")
pf.DurationVar(&discoveryExpiration, "discovery_expiration", discoveryExpiration,
"Period of non-communication before expiring a discovered device.")
pf.StringVar(&proxyAddress, "proxy_address", proxyAddress,
"The network [ADDR][:PORT] that proxy devices should identify as. You probably "+
"do NOT want to supply a port, as that effectively restricts to a single proxy "+
"device.")
pf.DurationVar(&proxyDiscoveryPeriod, "proxy_discovery_period", proxyDiscoveryPeriod,
"Period in between proxy device discovery broadcasts.")
pf.Int32Var(&proxyGroupOffset, "proxy_group_offset", proxyGroupOffset,
"A fixed offset to add to a base device's group when calculating the proxy device's "+
"group identifier. This can be used to differentiate proxy devices while maintaining "+
"relative group ordering.")
pf.DurationVar(&playbackMaxLagAge, "playback_max_lag_age", playbackMaxLagAge,
"The maximum amount of time that a packet can lag behind realtime before we "+
"discard it. This is used as a fudge factor.")
pf.DurationVar(&playbackAutoResumeDelay, "playback_auto_resume_delay", playbackAutoResumeDelay,
"The amount of time after (a) playback has been paused, and (b) the proxy has received "+
"at least one packet since then that we automatically resume the playback stream.")
pf.StringVar(&httpAddr, "http_addr", httpAddr, "The HTTP [ADDR]:PORT to listen on.")
pf.BoolVar(&httpCacheAssets, "http_cache_assets", httpCacheAssets,
"Cache web assets after loading. Can be disabled for development.")
pf.StringVar(&storagePath, "storage_path", storagePath, "The file storage path.")
pf.Var(&storageWriteCompression, "storage_write_compression",
"Type of compression The file storage path, from: "+streamfile.CompressionFlagValues())
pf.IntVar(&storageWriteCompressionLevel, "storage_write_compression_level", storageWriteCompressionLevel,
"If enabled/supported, the compression level to use. <0 means default level, the higher "+
"the number the more CPU is used to achieve better compression.")
pf.BoolVar(&enableSnapshot, "enable_snapshot", enableSnapshot,
"Enable in-memory snapshot of data sent to devices, allowing previews.")
pf.DurationVar(&snapshotSampleRate, "snapshot_sample_rate", snapshotSampleRate,
"The rate at which pixel data will be snapshotted.")
}
var rootCmd = &cobra.Command{
Use: "pixelproxy",
Short: "Proxy application for PixelPushers",
Long: ``, // TODO: Fill in long descrpition.
Run: func(cmd *cobra.Command, args []string) {
app.Run(context.Background(), func(c context.Context) error {
return rootCmdRun(c, cmd, args)
})
},
}
// Execute runs the main application code.
func Execute() {
if err := rootCmd.Execute(); err != nil {
fmt.Println(err)
os.Exit(1)
}
}
func rootCmdRun(c context.Context, cmd *cobra.Command, args []string) (appErr error) {
// Resolve our discovery broadcast network addresses.
var discoveryAddr *network.ResolvedConn
if discoveryAddress != "" {
var err error
discoveryAddr, err = network.ResolveUDPAddress(network.AddressOptions{
Interface: interfaceName,
TargetAddress: discoveryAddress,
Multicast: true,
})
if err != nil {
logging.S(c).Errorf("Could not resolve discovery address: %s", err)
return err
}
} else {
discoveryAddr = discovery.DefaultListenerConn()
}
logging.S(c).Infof("Using discovery address %q.", discoveryAddr)
// Resolve our proxy network addresses.
proxyAddr, err := network.ResolveUDPAddress(network.AddressOptions{
Interface: interfaceName,
TargetAddress: proxyAddress,
Multicast: false,
})
if err != nil {
logging.S(c).Errorf("Could not resolve proxy network: %s", err)
return err
}
logging.S(c).Infof("Using proxy address %q.", proxyAddr)
// Initialize our file storage.
storage := storage.S{
Root: storagePath,
WriterCompression: storageWriteCompression.Value(),
WriterCompressionLevel: storageWriteCompressionLevel,
}
if err := storage.Prepare(c); err != nil {
logging.S(c).Errorf("Could not create storage root directory %q: %s", storage.Root, err)
return err
}
// Allow our processes to cancel the Context if something goes wrong.
c, cancelFunc := context.WithCancel(c)
defer cancelFunc()
// Roll our process errors into our return value, if applicable.
var errorMu sync.Mutex
errorCount := 0
defer func() {
if appErr == nil && errorCount > 0 {
appErr = errors.Errorf("Encountered %d internal error(s).", errorCount)
}
}()
// (Helper function to complete an operation.)
operationFinished := func(name string, err error) {
if err == nil {
logging.S(c).Debugf("Process %s has finished.", name)
return
}
if errors.Cause(err) == context.Canceled {
logging.S(c).Debugf("Process %s was cancelled.", name)
return
}
// Cancel any other processes.
cancelFunc()
logging.S(c).Errorf("Process %s encountered an error: %s", name, err)
errorMu.Lock()
defer errorMu.Unlock()
errorCount++
}
// Track registered devices.
var reg device.Registry
// A Router to use for routing packets to devices. It will contain
// registrations for all discovered devices.
router := device.Router{
Registry: ®,
Logger: logging.S(c),
}
defer router.Shutdown()
// We will start multiple goroutines. Each will release its WaitGroup when
// finished. We'll wait for that.
var processWG sync.WaitGroup
defer processWG.Wait()
// Runs a function in a goroutine, counting the error when finished.
startOperation := func(name string, fn func() error) {
processWG.Add(1)
logging.S(c).Debugf("Starting %s...", name)
go func() {
defer processWG.Done()
operationFinished(name, fn())
}()
}
// Manage proxy devices.
proxyManager := proxy.Manager{
AddressRegistry: proxy.AddressRegistry{
// TODO: If we open-source this, do something a little less silly.
Prefix: []byte{0xE1, 0x2E, 0xC7},
},
ProxyAddr: proxyAddr.Addr.IP,
GroupOffset: proxyGroupOffset,
Logger: logging.S(c),
}
defer func() {
operationFinished("Proxy manager", proxyManager.Close())
}()
// Keep a snapshot of proxy strip states.
var snapshots *device.SnapshotManager
if enableSnapshot {
// Our packets come from two places:
// 1) Packets sent to proxies, which are routed to devices.
// 2) Packets sent directly to devices through our Router.
//
// Note that the Proxy does NOT use the Router, so we need to intercept
// packets in both places to get the latest snapshots at all times.
snapshots = &device.SnapshotManager{
// Sample at a rate faster than our render refresh (currently 5s).
SampleRate: snapshotSampleRate,
}
// Listen for packets received by the proxy.
proxyManager.AddListener(proxy.ListenerFunc(func(d device.D, pkt *protocol.Packet, forwarded bool) {
// Only add this packet to the snapshot if it was forwarded to the device.
// If it was dropped (e.g., during playback), it isn't representative of
// the current device state.
if forwarded {
snapshots.HandlePacket(d, pkt)
}
}))
// Listen for packets sent to our Router. This occurs for playback packets.
router.AddListener(device.ListenerFunc(snapshots.HandlePacket))
}
// Discovery transmitter for our proxy devices.
proxyTransmitterSender := network.ResilientDatagramSender{
Factory: discovery.DefaultTransmitterConn().DatagramSender,
}
defer func() {
operationFinished("Proxy discovery transmitter", proxyTransmitterSender.Close())
}()
proxyTransmitter := discovery.Transmitter{
Logger: logging.S(c),
}
startOperation("Discovery broadcast", func() error {
return util.LoopUntil(c, proxyDiscoveryPeriod, func(c context.Context) error {
devices := proxyManager.ProxyDevices()
logging.S(c).Debugf("Broadcasting discovery for %d proxy device(s)...", len(devices))
for _, d := range devices {
if err := proxyTransmitter.Broadcast(&proxyTransmitterSender, d.DiscoveryHeaders()); err != nil {
logging.S(c).Warnf("Failed to broadcast discovery for proxy device %q: %s", d, err)
}
}
return nil
})
})
// Set up discovery.
discoveryConn, err := discoveryAddr.ListenMulticastUDP4()
if err != nil {
logging.S(c).Errorf("Failed to create discovery listener: %s", err)
return err
}
l := discovery.Listener{
Logger: logging.S(c),
// Filter any proxy device addresses, so we don't end up proxying our own
// proxies.
FilterFunc: func(dh *protocol.DiscoveryHeaders) bool {
return !proxyManager.IsProxyDeviceAddr(dh.HardwareAddr())
},
}
if err := l.Start(discoveryConn); err != nil {
logging.S(c).Errorf("Could not connect discovery listener to %q: %s", discoveryConn.LocalAddr(), err)
discoveryConn.Close()
return err
}
defer func() {
if err := l.Close(); err != nil {
logging.S(c).Warnf("Could not close discovery listener: %s", err)
}
}()
discoveryReg := discovery.Registry{
Expiration: discoveryExpiration,
DeviceRegistry: ®,
}
defer discoveryReg.Shutdown()
// Listen on our discovery address for advertised devices.
startOperation("Discovery listener", func() error {
return discovery.ListenAndRegister(c, &l, &discoveryReg, func(d device.D) error {
// Add the device to our proxy manager. This will cause a proxy device
// to be created for it.
if err := proxyManager.AddDevice(d); err != nil {
logging.S(c).Errorf("Could not create proxy for device %s: %s", d, err)
}
return nil
})
})
// Initialize and run our Controller. This will block for the lifetime of the
// application.
ctrl := Controller{
Router: &router,
DiscoveryRegistry: &discoveryReg,
ProxyManager: &proxyManager,
Snapshots: snapshots,
Storage: &storage,
ShutdownFunc: cancelFunc,
PlaybackMaxLagAge: playbackMaxLagAge,
AutoResumeDelay: playbackAutoResumeDelay,
}
// Start our HTTP server.
webMux := mux.NewRouter()
// Install profiling endpoints.
app.Profiler.AddHTTP(webMux)
// Setup our Prometheus HTTP handler.
webMux.Path("/metrics").Handler(promhttp.Handler())
webController := web.Controller{
Proxy: &ctrl,
CacheAssets: httpCacheAssets,
Logger: logging.L(c),
RenderRefreshInterval: time.Duration(2.5 * float64(snapshotSampleRate)),
}
if err := webController.Install(c, webMux); err != nil {
logging.S(c).Errorf("Failed to install HTTP routes: %s", err)
return err
}
webServer := http.Server{
Addr: httpAddr,
Handler: webMux,
}
startOperation("web server", func() error {
// Shutdown our web server when our Context is cancelled.
go func() {
<-c.Done()
if err := webServer.Shutdown(c); err != nil {
logging.S(c).Warnf("Error during web server shutdown: %s", err)
}
}()
logging.S(c).Infof("Serving HTTP on %q", webServer.Addr)
if err := webServer.ListenAndServe(); err != nil {
if errors.Cause(err) != http.ErrServerClosed {
return err
}
}
return nil
})
// Run our Controller.
if err := ctrl.Run(c); err != nil {
if errors.Cause(err) == context.Canceled {
logging.S(c).Debugf("Canceled while running Controller: %s", err)
} else {
logging.S(c).Errorf("Error while running Controller: %s", err)
}
return err
}
logging.S(c).Infof("Controller has stopped.")
return nil
}
|
// Copyright 2020 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 telemetry
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"time"
"github.com/pingcap/errors"
"github.com/pingcap/tidb/config"
"github.com/pingcap/tidb/kv"
"github.com/pingcap/tidb/sessionctx"
"github.com/pingcap/tidb/sessionctx/variable"
"github.com/pingcap/tidb/util/logutil"
clientv3 "go.etcd.io/etcd/client/v3"
"go.uber.org/zap"
)
const (
// OwnerKey is the telemetry owner path that is saved to etcd.
OwnerKey = "/tidb/telemetry/owner"
// Prompt is the prompt for telemetry owner manager.
Prompt = "telemetry"
// ReportInterval is the interval of the report.
ReportInterval = 6 * time.Hour
)
const (
etcdOpTimeout = 3 * time.Second
uploadTimeout = 60 * time.Second
apiEndpoint = "https://telemetry.pingcap.com/api/v1/tidb/report"
)
func getTelemetryGlobalVariable(ctx sessionctx.Context) (bool, error) {
val, err := ctx.GetSessionVars().GlobalVarsAccessor.GetGlobalSysVar(variable.TiDBEnableTelemetry)
return variable.TiDBOptOn(val), err
}
// IsTelemetryEnabled check whether telemetry enabled.
func IsTelemetryEnabled(ctx sessionctx.Context) (bool, error) {
if !config.GetGlobalConfig().EnableTelemetry {
return false, nil
}
enabled, err := getTelemetryGlobalVariable(ctx)
if err != nil {
return false, errors.Trace(err)
}
return enabled, nil
}
// PreviewUsageData returns a preview of the usage data that is going to be reported.
func PreviewUsageData(ctx sessionctx.Context, etcdClient *clientv3.Client) (string, error) {
if etcdClient == nil {
return "", nil
}
if enabled, err := IsTelemetryEnabled(ctx); err != nil || !enabled {
return "", err
}
trackingID, err := GetTrackingID(etcdClient)
if err != nil {
return "", errors.Trace(err)
}
// NOTE: trackingID may be empty. However, as a preview data, it is fine.
data := generateTelemetryData(ctx, trackingID)
prettyJSON, err := json.MarshalIndent(data, "", " ")
if err != nil {
return "", errors.Trace(err)
}
return string(prettyJSON), nil
}
func reportUsageData(ctx sessionctx.Context, etcdClient *clientv3.Client) (bool, error) {
if etcdClient == nil {
// silently ignore
return false, nil
}
enabled, err := IsTelemetryEnabled(ctx)
if err != nil {
return false, err
}
if !enabled {
return false, errors.Errorf("telemetry is disabled")
}
trackingID, err := GetTrackingID(etcdClient)
if err != nil {
return false, errors.Trace(err)
}
if len(trackingID) == 0 {
trackingID, err = ResetTrackingID(etcdClient)
if err != nil {
return false, errors.Trace(err)
}
}
data := generateTelemetryData(ctx, trackingID)
postReportTelemetryData()
rawJSON, err := json.Marshal(data)
if err != nil {
return false, errors.Trace(err)
}
// TODO: We should use the context from domain, so that when request is blocked for a long time it will not
// affect TiDB shutdown.
reqCtx := kv.WithInternalSourceType(context.Background(), kv.InternalTxnTelemetry)
reqCtx, cancel := context.WithTimeout(reqCtx, uploadTimeout)
defer cancel()
req, err := http.NewRequestWithContext(reqCtx, "POST", apiEndpoint, bytes.NewReader(rawJSON))
if err != nil {
return false, errors.Trace(err)
}
req.Header.Add("Content-Type", "application/json")
logutil.BgLogger().Info(fmt.Sprintf("Uploading telemetry data to %s", apiEndpoint))
resp, err := http.DefaultClient.Do(req)
if err != nil {
return false, errors.Trace(err)
}
err = resp.Body.Close() // We don't even want to know any response body. Just close it.
_ = err
if resp.StatusCode != http.StatusOK {
return false, errors.Errorf("Received non-Ok response when reporting usage data, http code: %d", resp.StatusCode)
}
return true, nil
}
// ReportUsageData generates the latest usage data and sends it to PingCAP. Status will be saved to etcd. Status update failures will be returned.
func ReportUsageData(ctx sessionctx.Context, etcdClient *clientv3.Client) error {
if etcdClient == nil {
// silently ignore
return nil
}
s := status{
CheckAt: time.Now().Format(time.RFC3339),
}
reported, err := reportUsageData(ctx, etcdClient)
if err != nil {
s.IsError = true
s.ErrorMessage = err.Error()
} else {
s.IsRequestSent = reported
}
return updateTelemetryStatus(s, etcdClient)
}
// InitialRun reports the Telmetry configuration and trigger an initial run
func InitialRun(ctx sessionctx.Context, etcdClient *clientv3.Client) error {
enabled, err := IsTelemetryEnabled(ctx)
if err != nil {
return err
}
logutil.BgLogger().Info("Telemetry configuration", zap.String("endpoint", apiEndpoint), zap.Duration("report_interval", ReportInterval), zap.Bool("enabled", enabled))
return ReportUsageData(ctx, etcdClient)
}
|
package dsp
// NewFBCombMS returns a new FBComb
func NewFBCombMS(ms MS) *FBComb {
return &FBComb{dl: NewDelayLineMS(ms)}
}
// FBComb is a feedback comb filter
type FBComb struct {
dl *DelayLine
last Float64
}
// Tick advances the filter's operation with the default duration
func (c *FBComb) Tick(in, gain Float64) Float64 {
return c.TickDuration(in, gain, -1)
}
// TickDuration advances the filter's operation with a specific duration
func (c *FBComb) TickDuration(in, gain, duration Float64) Float64 {
out := in + c.last
c.last = gain * tick(c.dl, in, duration)
return out
}
// NewFilteredFBComb returns a new FilteredFBComb
func NewFilteredFBCombMS(ms MS, poles int) *FilteredFBComb {
return &FilteredFBComb{dl: NewDelayLineMS(ms), f: NewFilter(LowPass, 4)}
}
// FilteredFBComb is a feedback comb filter
type FilteredFBComb struct {
dl *DelayLine
f *Filter
last Float64
}
// Tick advances the filter's operation with the default duration
func (c *FilteredFBComb) Tick(in, gain, cutoff, resonance Float64) Float64 {
return c.TickDuration(in, gain, -1, cutoff, resonance)
}
// TickDuration advances the filter's operation with a specific duration
func (c *FilteredFBComb) TickDuration(in, gain, duration, cutoff, resonance Float64) Float64 {
out := in + c.last
c.f.Cutoff = cutoff
c.f.Resonance = resonance
c.last = gain * c.f.Tick(tick(c.dl, out, duration))
return out
}
// NewFFComb returns a new FFComb
func NewFFCombMS(ms MS) *FFComb {
return &FFComb{dl: NewDelayLineMS(ms)}
}
// FFComb is a feedforward comb filter
type FFComb struct {
dl *DelayLine
last Float64
}
// Tick advances the filter's operation with the default duration
func (c *FFComb) Tick(in, gain Float64) Float64 {
return c.TickDuration(in, gain, -1)
}
// TickDuration advances the filter's operation with a specific duration
func (c *FFComb) TickDuration(in, gain, duration Float64) Float64 {
return in + gain*c.dl.TickDuration(in, duration)
}
func tick(dl *DelayLine, in, duration Float64) Float64 {
if duration < 0 {
return dl.Tick(in)
}
return dl.TickDuration(in, duration)
}
|
package mock
import (
"context"
"time"
"github.com/odpf/optimus/job"
"github.com/odpf/optimus/core/tree"
"github.com/google/uuid"
"github.com/odpf/optimus/models"
"github.com/odpf/optimus/store"
"github.com/stretchr/testify/mock"
)
type ReplayRepository struct {
mock.Mock
}
func (repo *ReplayRepository) GetByID(ctx context.Context, id uuid.UUID) (models.ReplaySpec, error) {
args := repo.Called(ctx, id)
return args.Get(0).(models.ReplaySpec), args.Error(1)
}
func (repo *ReplayRepository) Insert(ctx context.Context, replay *models.ReplaySpec) error {
return repo.Called(ctx, &models.ReplaySpec{
ID: replay.ID,
Job: replay.Job,
StartDate: replay.StartDate,
EndDate: replay.EndDate,
Status: replay.Status,
Message: replay.Message,
CreatedAt: replay.CreatedAt,
}).Error(0)
}
func (repo *ReplayRepository) UpdateStatus(ctx context.Context, replayID uuid.UUID, status string, message models.ReplayMessage) error {
return repo.Called(ctx, replayID, status, message).Error(0)
}
func (repo *ReplayRepository) GetByStatus(ctx context.Context, status []string) ([]models.ReplaySpec, error) {
args := repo.Called(ctx, status)
return args.Get(0).([]models.ReplaySpec), args.Error(1)
}
func (repo *ReplayRepository) GetByJobIDAndStatus(ctx context.Context, jobID uuid.UUID, status []string) ([]models.ReplaySpec, error) {
args := repo.Called(ctx, jobID, status)
return args.Get(0).([]models.ReplaySpec), args.Error(1)
}
func (repo *ReplayRepository) GetByProjectIDAndStatus(ctx context.Context, projectID uuid.UUID, status []string) ([]models.ReplaySpec, error) {
args := repo.Called(ctx, projectID, status)
return args.Get(0).([]models.ReplaySpec), args.Error(1)
}
func (repo *ReplayRepository) GetByProjectID(ctx context.Context, projectID uuid.UUID) ([]models.ReplaySpec, error) {
args := repo.Called(ctx, projectID)
return args.Get(0).([]models.ReplaySpec), args.Error(1)
}
type ReplaySpecRepoFactory struct {
mock.Mock
}
func (fac *ReplaySpecRepoFactory) New() store.ReplaySpecRepository {
return fac.Called().Get(0).(store.ReplaySpecRepository)
}
type ReplayManager struct {
mock.Mock
}
func (rm *ReplayManager) Replay(ctx context.Context, reqInput models.ReplayRequest) (string, error) {
args := rm.Called(ctx, reqInput)
return args.Get(0).(string), args.Error(1)
}
func (rm *ReplayManager) Init() {
rm.Called()
return
}
func (rm *ReplayManager) GetReplay(ctx context.Context, uuid uuid.UUID) (models.ReplaySpec, error) {
args := rm.Called(ctx, uuid)
return args.Get(0).(models.ReplaySpec), args.Error(1)
}
func (rm *ReplayManager) GetReplayList(ctx context.Context, projectUUID uuid.UUID) ([]models.ReplaySpec, error) {
args := rm.Called(ctx, projectUUID)
return args.Get(0).([]models.ReplaySpec), args.Error(1)
}
func (rm *ReplayManager) GetRunStatus(ctx context.Context, projectSpec models.ProjectSpec, startDate time.Time,
endDate time.Time, jobName string) ([]models.JobStatus, error) {
args := rm.Called(ctx, projectSpec, startDate, endDate, jobName)
return args.Get(0).([]models.JobStatus), args.Error(1)
}
type ReplayWorkerFactoryIndexed struct {
mock.Mock
Workers []interface{}
times int
}
func (rm *ReplayWorkerFactoryIndexed) New() job.ReplayWorker {
w := rm.Workers[rm.times]
rm.times++
rm.Called()
return w.(job.ReplayWorker)
}
type ReplayWorkerFactory struct {
mock.Mock
}
func (rm *ReplayWorkerFactory) New() job.ReplayWorker {
args := rm.Called()
return args.Get(0).(job.ReplayWorker)
}
type ReplayWorker struct {
mock.Mock
finish chan bool
}
func NewReplayWorker() *ReplayWorker {
return &ReplayWorker{
finish: make(chan bool, 0),
}
}
func (rm *ReplayWorker) Process(ctx context.Context, replayRequest models.ReplayRequest) error {
//mock processing time for concurrent replay call testing
args := rm.Called(ctx, replayRequest)
<-rm.finish
return args.Error(0)
}
func (rm *ReplayWorker) Close() error {
close(rm.finish)
return nil
}
type ReplayValidator struct {
mock.Mock
}
func (rv *ReplayValidator) Validate(ctx context.Context, replaySpecRepo store.ReplaySpecRepository,
replayRequest models.ReplayRequest, replayTree *tree.TreeNode) error {
args := rv.Called(ctx, replaySpecRepo, replayRequest, replayTree)
return args.Error(0)
}
type ReplaySyncer struct {
mock.Mock
}
func (rs *ReplaySyncer) Sync(context context.Context, runTimeout time.Duration) error {
args := rs.Called(context, runTimeout)
return args.Error(0)
}
|
package main
import "fmt"
func main() {
var name string
name = "Nabil Fawwaz Elqayyim"
fmt.Println(name)
var name2 = "Nabil"
fmt.Println(name2)
name3 := "Nabil"
fmt.Println(name3)
}
|
package main
import (
"fmt"
"github.com/boltdb/bolt"
"github.com/jordan-wright/email"
"log"
"net"
"strings"
)
type Mail struct {
Body string `json:"-"`
To string `json:"to"`
Id string `json:"id"`
From string `json:"-"`
Subject string `json:"-"`
MessageId string `json:"-"`
}
func (m *Mail) constructMessage() ([]byte, error) {
message := email.NewEmail()
message.From = m.From
message.To = []string{m.To}
message.Subject = m.Subject
message.HTML = []byte(m.Body)
return message.Bytes()
}
func (m *Mail) Send() {
var err error
var servers = make([]string, 0)
mailTokens := strings.Split(m.To, "@")
domain := mailTokens[len(mailTokens)-1]
err = Database.View(func(tx *bolt.Tx) error {
bucket := tx.Bucket([]byte("Messages"))
response := bucket.Get([]byte(m.MessageId))
if response == nil {
return fmt.Errorf("No message found with that id")
}
m.Body = string(response)
return nil
})
if err != nil {
EventQueue <- Event{RecipientId: m.Id, MessageId: m.MessageId, Status: "failed"}
return
}
data, err := m.constructMessage()
if err != nil {
log.Println(err)
EventQueue <- Event{RecipientId: m.Id, MessageId: m.MessageId, Status: "failed"}
// error handling here
return
}
Database.View(func(tx *bolt.Tx) error {
bucket := tx.Bucket([]byte("MXRecords"))
response := bucket.Get([]byte(domain))
if response == nil {
return nil
}
serversString := string(response)
servers = strings.Split(serversString, ",")
return nil
})
if len(servers) == 0 {
mxServers, err := net.LookupMX(domain)
if err != nil {
// error handler here
EventQueue <- Event{RecipientId: m.Id, MessageId: m.MessageId, Status: "failed"}
return
}
for _, server := range mxServers {
servers = append(servers, fmt.Sprintf("%s:25", strings.TrimRight(server.Host, ".")))
}
Database.Update(func(tx *bolt.Tx) error {
bucket := tx.Bucket([]byte("MXRecords"))
bucket.Put([]byte(domain), []byte(strings.Join(servers, ","))) // ignore the error since we don't want to die on a cache fail
return nil
})
}
for _, server := range servers {
err = SendMail(
30,
server,
m.From,
m.To,
data,
)
if err == nil {
break
}
}
if err == nil || err.Error() == "250 OK" {
// callback for recipient success
EventQueue <- Event{RecipientId: m.Id, MessageId: m.MessageId, Status: "success"}
} else {
// callback for recipient failure
EventQueue <- Event{RecipientId: m.Id, MessageId: m.MessageId, Status: "failed"}
log.Printf("Failed to sent message to %s: %s\n", m.To, err)
}
}
|
//go:build localtest
package uixt
import (
"bytes"
"fmt"
"os"
"testing"
)
func checkOCR(buff *bytes.Buffer) error {
service, err := newVEDEMImageService()
if err != nil {
return err
}
imageResult, err := service.GetImage(buff)
if err != nil {
return err
}
fmt.Println(fmt.Sprintf("imageResult: %v", imageResult))
return nil
}
func TestOCRWithScreenshot(t *testing.T) {
setupAndroid(t)
raw, err := driverExt.Driver.Screenshot()
if err != nil {
t.Fatal(err)
}
if err := checkOCR(raw); err != nil {
t.Fatal(err)
}
}
func TestOCRWithLocalFile(t *testing.T) {
imagePath := "/Users/debugtalk/Downloads/s1.png"
file, err := os.ReadFile(imagePath)
if err != nil {
t.Fatal(err)
}
buf := new(bytes.Buffer)
buf.Read(file)
if err := checkOCR(buf); err != nil {
t.Fatal(err)
}
}
|
package main
import (
"fmt"
"net/http"
"github.com/360EntSecGroup-Skylar/excelize"
"github.com/go-zoo/bone"
"github.com/codegangsta/negroni"
"gorest-xls/random"
"os"
"io/ioutil"
"strconv"
)
func main() {
mux := bone.New()
mux.Get("/api/v1/excel", http.HandlerFunc(ExcelHandler))
n := negroni.Classic()
n.UseHandler(mux)
n.Run(":3000")
}
func ExcelHandler(w http.ResponseWriter, r *http.Request) {
xlsx := excelize.NewFile()
xlsx.SetCellValue("Sheet1", "A1", "Test Data")
xlsx.SetCellValue("Sheet1", "A2", "X-Axis")
xlsx.SetCellValue("Sheet1", "B2", "Y-Axis")
xlsx.SetCellValue("Sheet1", "C2", "Z-Axis")
//create a dummy data
data := [][]uint32{
{10, 2, 12},
{20, 4, 55},
{30, 10, 15},
{40, 11, 11},
{50, 12, 17},
{60, 20, 17},
{70, 35, 15},
{80, 10, 45},
{90, 86, 55},
{100, 44, 60},
{110, 55, 90},
{120, 70, 100},
}
//start row ehere we put the data
row := 3
//loop over the data
for i := range data {
xlsx.SetCellValue("Sheet1", "A" + strconv.Itoa(row), data[i][0])
xlsx.SetCellValue("Sheet1", "B" + strconv.Itoa(row), data[i][1])
xlsx.SetCellValue("Sheet1", "C" + strconv.Itoa(row), data[i][2])
row++
}
//generate a temp filename
var name = "./" + random.Generate(10)
err := xlsx.SaveAs(name)
//remove the filename
defer os.Remove(name)
if err != nil {
fmt.Println(err)
}
//Read back the contents of the random named excel file
excel, err := ioutil.ReadFile(name)
if err != nil {
panic(err)
}
w.Header().Set("Content-Disposition", "attachment; filename=test.xlsx")
w.Header().Set("Content-Type", "application/xlsx")
w.Write(excel)
}
|
/*
Templates are mainly used to seperate data part and formatting part.
*/
package main
import (
"fmt"
"os"
"text/template"
)
type Entry struct {
Number int
Square int
}
func main() {
arguments := os.Args
if len(arguments) != 2 {
fmt.Println("please provide a required text file")
return
}
tFile := arguments[1]
var Enteries []Entry
data := [][]int{{-1, 1}, {-2, 4}, {-3, 9}, {-4, 16}, {-5, 25}, {-6, 36}}
for _, i := range data {
if len(i) == 2 {
temp := Entry{Number: i[0], Square: i[1]}
Enteries = append(Enteries, temp)
}
t := template.Must(template.ParseGlob(tFile))
t.Execute(os.Stdout, Enteries)
}
}
|
package combat
import "math"
//exponent represents the increase of difficulty between levels
//Disgea Level formula to the first 99 levels.
func NextLevel(level int) float64 {
exponent := 1
baseXP := 1000.0
//return math.Round( 0.04 * float64(level ^ 3) + 0.8 * float64(level ^ 2) + float64(2 * level))
return math.Round(baseXP*float64(level^exponent) + 0.8*float64(level^2) + float64(2*level))
}
//func NextLevel_(level int) float64 {
// exponent := 2
// baseXP := 1000.0
// return math.Floor(baseXP * float64(level^exponent))
//}
|
package middlewares
import (
"github.com/gofiber/fiber/v2"
"github.com/gofiber/fiber/v2/middleware/cors"
"github.com/gofiber/fiber/v2/middleware/logger"
"github.com/gofiber/fiber/v2/middleware/recover"
"github.com/gofiber/helmet/v2"
)
func SetupMiddleware(app *fiber.App) {
app.Use(helmet.New())
app.Use(recover.New())
app.Use(logger.New())
app.Use(cors.New())
}
|
package repositories
import (
"errors"
"log"
"github.com/jinzhu/gorm"
"github.com/kazetora/evermos-assignment/problem_1_ecommerce/models"
)
func isStockAvailable(db *gorm.DB, productID uint, qty int) (bool, error) {
var inventory models.Inventories
if err := db.Where("product_id = ?", productID).First(&inventory).Error; err != nil {
return false, err
}
if inventory.Quantity < qty {
return false, errors.New("Not enough stock")
}
return true, nil
}
func updateStock(db *gorm.DB, productID uint, qty int) error {
var inventory models.Inventories
if err := db.Where("product_id = ?", productID).First(&inventory).Error; err != nil {
return err
}
inventory.Quantity = inventory.Quantity - qty
if err := db.Save(&inventory).Error; err != nil {
log.Printf("Error updating inventory: %s", err.Error())
return err
}
return nil
}
// CreateNewOrder create new unprocessed order for user
func CreateNewOrder(db *gorm.DB, userID uint, productID uint, qty int) (*models.Orders, error) {
// check if the inventory can handle the quantity
if stockAvailable, err := isStockAvailable(db, productID, qty); err != nil || !stockAvailable {
log.Println(err.Error())
return nil, errors.New("Cannot continue with the transaction")
}
order := models.Orders{
UserID: userID,
Items: []models.LineItems{
models.LineItems{
ProductID: productID,
Quantity: qty,
},
},
}
createRes := db.Create(&order)
if createRes.Error != nil {
return nil, createRes.Error
}
// update inventory
if err := updateStock(db, productID, qty); err != nil {
return nil, err
}
return &order, nil
}
// UpdateOrderLineItems update line item in order.
// If the same product id exists in current line items, update the quantity
func UpdateOrderLineItems(db *gorm.DB, orderID uint, productID uint, qty int) (*models.Orders, error) {
// check if the inventory can handle the quantity
if stockAvailable, err := isStockAvailable(db, productID, qty); err != nil || !stockAvailable {
log.Println(err.Error())
return nil, errors.New("Cannot continue with the transaction")
}
// check if the same item exist in order's line items
var findItem models.LineItems
queryRes := db.Where("order_id = ?", orderID).First(&findItem)
if queryRes.RecordNotFound() {
// create new line item for the order
findItem.OrderID = orderID
findItem.ProductID = productID
findItem.Quantity = qty
if err := db.Create(&findItem).Error; err != nil {
return nil, err
}
} else {
// update the quantity
findItem.Quantity = qty
if err := db.Save(&findItem).Error; err != nil {
return nil, err
}
}
var ret models.Orders
if err := db.Where("id = ?", orderID).Error; err != nil {
return nil, err
}
// update inventory
if err := updateStock(db, productID, qty); err != nil {
return nil, err
}
return &ret, nil
}
|
package models
import (
"database/sql"
"encoding/json"
"strconv"
// is nedded for sql querys
_ "github.com/lib/pq"
)
// Domain : model for the domain struct
type Domain struct {
ID int `json:"id"`
Domain string `json:"domain"`
Data Response `json:"data"`
}
// DomainCollection : return domain collection
type DomainCollection struct {
Domains []Domain `json:"items"`
Prev string `json:"prev"`
Next string `json:"next"`
Rows int `json:"rows"`
}
// Migrate : create the table domains in database
func Migrate(db *sql.DB) error {
sql := `
CREATE TABLE IF NOT EXISTS domains(
id SERIAL PRIMARY KEY,
domain VARCHAR(256) NOT NULL,
data JSON NOT NULL,
UNIQUE (domain)
);`
_, err := db.Exec(sql)
return err
}
// GetDomains : return domain collection
func GetDomains(db *sql.DB, action string, id string) (DomainCollection, error) {
var sql = ""
switch action {
case "prev":
sql = "SELECT * FROM domains WHERE id < $1 ORDER BY id ASC LIMIT 10"
break
case "next":
sql = "SELECT * FROM domains WHERE id > $1 ORDER BY id ASC LIMIT 10"
break
default:
sql = "SELECT * FROM domains WHERE id > $1 ORDER BY id ASC LIMIT 10"
}
stmt, err := db.Prepare(sql)
if err != nil {
return DomainCollection{}, err
}
defer stmt.Close()
rows, err := stmt.Query(id)
if err != nil {
return DomainCollection{}, err
}
result := DomainCollection{}
for rows.Next() {
domain := Domain{}
err := rows.Scan(&domain.ID, &domain.Domain, &domain.Data)
if err != nil {
return DomainCollection{}, err
}
result.Domains = append(result.Domains, domain)
}
rowsNumber := len(result.Domains)
if rowsNumber > 0 {
result.Prev = strconv.Itoa(result.Domains[0].ID)
result.Next = strconv.Itoa(result.Domains[rowsNumber-1].ID)
result.Rows = rowsNumber
}
return result, nil
}
// CreateDomain : create domain into database
func CreateDomain(db *sql.DB, domain string, data Response) (int64, error) {
sql := "INSERT INTO domains (domain, data) VALUES($1, $2)"
stmt, err := db.Prepare(sql)
if err != nil {
return 0, err
}
dataJSONEencode, err := json.Marshal(data)
if err != nil {
return 0, err
}
defer stmt.Close()
result, err := stmt.Exec(domain, dataJSONEencode)
if err != nil {
return 0, err
}
return result.RowsAffected()
}
// UpdateDomain : update domain in database
func UpdateDomain(db *sql.DB, id int, data Response) (int64, error) {
sql := "UPDATE domains SET (data) = ($1) WHERE id = $2"
stmt, err := db.Prepare(sql)
if err != nil {
return 0, err
}
defer stmt.Close()
dataJSONEencode, _ := json.Marshal(data)
result, err := stmt.Exec(dataJSONEencode, id)
if err != nil {
return 0, err
}
return result.RowsAffected()
}
// CheckIfDomainExists : check if a domain already have been registered
func CheckIfDomainExists(db *sql.DB, domain string) (Domain, error) {
sql := "SELECT id, domain, data FROM domains WHERE domain = $1"
stmt, err := db.Prepare(sql)
if err != nil {
return Domain{}, err
}
defer stmt.Close()
rows, err := stmt.Query(domain)
if err != nil {
return Domain{}, err
}
result := Domain{}
for rows.Next() {
err := rows.Scan(&result.ID, &result.Domain, &result.Data)
if err != nil {
return result, err
}
}
return result, err
}
|
package main
import (
"strconv"
"encoding/json"
"encoding/gob"
"bytes"
)
const (
ENCODE_TYPE_JSON = "json"
ENCODE_TYPE_GOB = "gob"
)
type User struct {
Id int `json:"id"`
Name string `json:"name"`
Social string `json:"social"`
UserAccount UserAccountInterface `json:"-"`
}
func (u *User) SaveToDB() (error) {
switch u.Social {
case "vk":
u.UserAccount = &UserAccountVk{}
case "fb":
u.UserAccount = &UserAccountFb{}
}
return localDb.PutGob(USER_DB_BUCKET, strconv.Itoa(u.Id), u)
}
func getUserListFromDB(encodeType string) (res []User, err error) {
byteMap := map[string][]byte{}
localDb.GetBucketList(USER_DB_BUCKET, byteMap)
for _, v := range byteMap {
user := User{}
switch encodeType {
case ENCODE_TYPE_JSON:
err := json.Unmarshal(v, &user)
if err != nil {
return nil, err
}
case ENCODE_TYPE_GOB:
buf := bytes.NewBuffer(v)
dec := gob.NewDecoder(buf)
err = dec.Decode(&user)
if err != nil {
return nil, err
}
}
res = append(res, user)
}
return
}
|
package leetcode
import (
"reflect"
"sort"
"testing"
)
func TestSubdomainVisits(t *testing.T) {
ans1 := subdomainVisits([]string{"9001 discuss.leetcode.com"})
sort.Strings(ans1)
if !reflect.DeepEqual(ans1,
[]string{
"9001 com",
"9001 discuss.leetcode.com",
"9001 leetcode.com",
}) {
t.Fatal()
}
ans2 := subdomainVisits([]string{
"900 google.mail.com",
"50 yahoo.com",
"1 intel.mail.com",
"5 wiki.org",
})
sort.Strings(ans2)
if !reflect.DeepEqual(ans2,
[]string{
"1 intel.mail.com",
"5 org",
"5 wiki.org",
"50 yahoo.com",
"900 google.mail.com",
"901 mail.com",
"951 com",
}) {
t.Fatal()
}
}
|
//OneWire support.
package embd
import (
"log"
"os"
)
// W1Bus interface is used to interact with the OneWire bus.
type W1Bus interface {
// List devices on the bus
ListDevices() (devices []string, err error)
// Open a device
Open(address string) (device W1Device, err error)
// Close releases the resources associated with the bus.
Close() error
}
// W1Device interface is user to interact with the OneWire device.
type W1Device interface {
// Get file
File() *os.File
// Open file
OpenFile() error
// Close file
CloseFile() error
// ReadByte reads a byte from the device.
ReadByte() (value byte, err error)
// ReadByte number of bytes from the device.
ReadBytes(number int) (value []byte, err error)
// WriteByte writes a byte to the device.
WriteByte(value byte) error
// WriteBytes writes a slice bytes to the device.
WriteBytes(value []byte) error
// Close releases the resources associated with the device.
Close() error
}
// W1Driver interface interacts with the host descriptors to allow us
// control of OneWire communication.
type W1Driver interface {
Bus(l byte) W1Bus
// Close releases the resources associated with the driver.
Close() error
}
var w1DriverInitialized bool
var w1DriverInstance W1Driver
// InitW1 initializes the W1 driver.
func InitW1() error {
if w1DriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.W1Driver == nil {
return ErrFeatureNotSupported
}
w1DriverInstance = desc.W1Driver()
w1DriverInitialized = true
return nil
}
// CloseW1 releases resources associated with the OneWire driver.
func CloseW1() error {
log.Println("Closing w1 driver")
return w1DriverInstance.Close()
}
// NewW1Bus returns a W1Bus.
func NewW1Bus(l byte) W1Bus {
if err := InitW1(); err != nil {
panic(err)
}
return w1DriverInstance.Bus(l)
}
|
package main
// Go Hello World
import "fmt"
func main() {
fmt.Println("\nhello world\n")
}
|
package contract
type BaseRequest struct {
}
type BaseResponse struct {
StatusCode StatusCode `json:"status_code"`
StatusInfo *StatusInfo `json:"status_info"`
}
type StatusInfo struct {
Time int64 `json:"time"`
Message string `json:"message"`
}
type StatusCode int32
const (
SUCCESS StatusCode = 1
FAILURE StatusCode = 2
UNKNOWN StatusCode = 3
)
|
package email
import (
"github.com/shopspring/decimal"
"time"
"github.com/quickfixgo/quickfix"
"github.com/quickfixgo/quickfix/enum"
"github.com/quickfixgo/quickfix/field"
"github.com/quickfixgo/quickfix/fix41"
"github.com/quickfixgo/quickfix/tag"
)
//Email is the fix41 Email type, MsgType = C
type Email struct {
fix41.Header
*quickfix.Body
fix41.Trailer
Message *quickfix.Message
}
//FromMessage creates a Email from a quickfix.Message instance
func FromMessage(m *quickfix.Message) Email {
return Email{
Header: fix41.Header{&m.Header},
Body: &m.Body,
Trailer: fix41.Trailer{&m.Trailer},
Message: m,
}
}
//ToMessage returns a quickfix.Message instance
func (m Email) ToMessage() *quickfix.Message {
return m.Message
}
//New returns a Email initialized with the required fields for Email
func New(emailthreadid field.EmailThreadIDField, emailtype field.EmailTypeField, subject field.SubjectField) (m Email) {
m.Message = quickfix.NewMessage()
m.Header = fix41.NewHeader(&m.Message.Header)
m.Body = &m.Message.Body
m.Trailer.Trailer = &m.Message.Trailer
m.Header.Set(field.NewMsgType("C"))
m.Set(emailthreadid)
m.Set(emailtype)
m.Set(subject)
return
}
//A RouteOut is the callback type that should be implemented for routing Message
type RouteOut func(msg Email, sessionID quickfix.SessionID) quickfix.MessageRejectError
//Route returns the beginstring, message type, and MessageRoute for this Message type
func Route(router RouteOut) (string, string, quickfix.MessageRoute) {
r := func(msg *quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError {
return router(FromMessage(msg), sessionID)
}
return "FIX.4.1", "C", r
}
//SetClOrdID sets ClOrdID, Tag 11
func (m Email) SetClOrdID(v string) {
m.Set(field.NewClOrdID(v))
}
//SetLinesOfText sets LinesOfText, Tag 33
func (m Email) SetLinesOfText(f LinesOfTextRepeatingGroup) {
m.SetGroup(f)
}
//SetOrderID sets OrderID, Tag 37
func (m Email) SetOrderID(v string) {
m.Set(field.NewOrderID(v))
}
//SetOrigTime sets OrigTime, Tag 42
func (m Email) SetOrigTime(v time.Time) {
m.Set(field.NewOrigTime(v))
}
//SetEmailType sets EmailType, Tag 94
func (m Email) SetEmailType(v enum.EmailType) {
m.Set(field.NewEmailType(v))
}
//SetRawDataLength sets RawDataLength, Tag 95
func (m Email) SetRawDataLength(v int) {
m.Set(field.NewRawDataLength(v))
}
//SetRawData sets RawData, Tag 96
func (m Email) SetRawData(v string) {
m.Set(field.NewRawData(v))
}
//SetNoRelatedSym sets NoRelatedSym, Tag 146
func (m Email) SetNoRelatedSym(f NoRelatedSymRepeatingGroup) {
m.SetGroup(f)
}
//SetSubject sets Subject, Tag 147
func (m Email) SetSubject(v string) {
m.Set(field.NewSubject(v))
}
//SetEmailThreadID sets EmailThreadID, Tag 164
func (m Email) SetEmailThreadID(v string) {
m.Set(field.NewEmailThreadID(v))
}
//GetClOrdID gets ClOrdID, Tag 11
func (m Email) GetClOrdID() (v string, err quickfix.MessageRejectError) {
var f field.ClOrdIDField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetLinesOfText gets LinesOfText, Tag 33
func (m Email) GetLinesOfText() (LinesOfTextRepeatingGroup, quickfix.MessageRejectError) {
f := NewLinesOfTextRepeatingGroup()
err := m.GetGroup(f)
return f, err
}
//GetOrderID gets OrderID, Tag 37
func (m Email) GetOrderID() (v string, err quickfix.MessageRejectError) {
var f field.OrderIDField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetOrigTime gets OrigTime, Tag 42
func (m Email) GetOrigTime() (v time.Time, err quickfix.MessageRejectError) {
var f field.OrigTimeField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetEmailType gets EmailType, Tag 94
func (m Email) GetEmailType() (v enum.EmailType, err quickfix.MessageRejectError) {
var f field.EmailTypeField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetRawDataLength gets RawDataLength, Tag 95
func (m Email) GetRawDataLength() (v int, err quickfix.MessageRejectError) {
var f field.RawDataLengthField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetRawData gets RawData, Tag 96
func (m Email) GetRawData() (v string, err quickfix.MessageRejectError) {
var f field.RawDataField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetNoRelatedSym gets NoRelatedSym, Tag 146
func (m Email) GetNoRelatedSym() (NoRelatedSymRepeatingGroup, quickfix.MessageRejectError) {
f := NewNoRelatedSymRepeatingGroup()
err := m.GetGroup(f)
return f, err
}
//GetSubject gets Subject, Tag 147
func (m Email) GetSubject() (v string, err quickfix.MessageRejectError) {
var f field.SubjectField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetEmailThreadID gets EmailThreadID, Tag 164
func (m Email) GetEmailThreadID() (v string, err quickfix.MessageRejectError) {
var f field.EmailThreadIDField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//HasClOrdID returns true if ClOrdID is present, Tag 11
func (m Email) HasClOrdID() bool {
return m.Has(tag.ClOrdID)
}
//HasLinesOfText returns true if LinesOfText is present, Tag 33
func (m Email) HasLinesOfText() bool {
return m.Has(tag.LinesOfText)
}
//HasOrderID returns true if OrderID is present, Tag 37
func (m Email) HasOrderID() bool {
return m.Has(tag.OrderID)
}
//HasOrigTime returns true if OrigTime is present, Tag 42
func (m Email) HasOrigTime() bool {
return m.Has(tag.OrigTime)
}
//HasEmailType returns true if EmailType is present, Tag 94
func (m Email) HasEmailType() bool {
return m.Has(tag.EmailType)
}
//HasRawDataLength returns true if RawDataLength is present, Tag 95
func (m Email) HasRawDataLength() bool {
return m.Has(tag.RawDataLength)
}
//HasRawData returns true if RawData is present, Tag 96
func (m Email) HasRawData() bool {
return m.Has(tag.RawData)
}
//HasNoRelatedSym returns true if NoRelatedSym is present, Tag 146
func (m Email) HasNoRelatedSym() bool {
return m.Has(tag.NoRelatedSym)
}
//HasSubject returns true if Subject is present, Tag 147
func (m Email) HasSubject() bool {
return m.Has(tag.Subject)
}
//HasEmailThreadID returns true if EmailThreadID is present, Tag 164
func (m Email) HasEmailThreadID() bool {
return m.Has(tag.EmailThreadID)
}
//LinesOfText is a repeating group element, Tag 33
type LinesOfText struct {
*quickfix.Group
}
//SetText sets Text, Tag 58
func (m LinesOfText) SetText(v string) {
m.Set(field.NewText(v))
}
//GetText gets Text, Tag 58
func (m LinesOfText) GetText() (v string, err quickfix.MessageRejectError) {
var f field.TextField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//HasText returns true if Text is present, Tag 58
func (m LinesOfText) HasText() bool {
return m.Has(tag.Text)
}
//LinesOfTextRepeatingGroup is a repeating group, Tag 33
type LinesOfTextRepeatingGroup struct {
*quickfix.RepeatingGroup
}
//NewLinesOfTextRepeatingGroup returns an initialized, LinesOfTextRepeatingGroup
func NewLinesOfTextRepeatingGroup() LinesOfTextRepeatingGroup {
return LinesOfTextRepeatingGroup{
quickfix.NewRepeatingGroup(tag.LinesOfText,
quickfix.GroupTemplate{quickfix.GroupElement(tag.Text)})}
}
//Add create and append a new LinesOfText to this group
func (m LinesOfTextRepeatingGroup) Add() LinesOfText {
g := m.RepeatingGroup.Add()
return LinesOfText{g}
}
//Get returns the ith LinesOfText in the LinesOfTextRepeatinGroup
func (m LinesOfTextRepeatingGroup) Get(i int) LinesOfText {
return LinesOfText{m.RepeatingGroup.Get(i)}
}
//NoRelatedSym is a repeating group element, Tag 146
type NoRelatedSym struct {
*quickfix.Group
}
//SetRelatdSym sets RelatdSym, Tag 46
func (m NoRelatedSym) SetRelatdSym(v string) {
m.Set(field.NewRelatdSym(v))
}
//SetSymbolSfx sets SymbolSfx, Tag 65
func (m NoRelatedSym) SetSymbolSfx(v enum.SymbolSfx) {
m.Set(field.NewSymbolSfx(v))
}
//SetSecurityID sets SecurityID, Tag 48
func (m NoRelatedSym) SetSecurityID(v string) {
m.Set(field.NewSecurityID(v))
}
//SetIDSource sets IDSource, Tag 22
func (m NoRelatedSym) SetIDSource(v enum.IDSource) {
m.Set(field.NewIDSource(v))
}
//SetSecurityType sets SecurityType, Tag 167
func (m NoRelatedSym) SetSecurityType(v enum.SecurityType) {
m.Set(field.NewSecurityType(v))
}
//SetMaturityMonthYear sets MaturityMonthYear, Tag 200
func (m NoRelatedSym) SetMaturityMonthYear(v string) {
m.Set(field.NewMaturityMonthYear(v))
}
//SetMaturityDay sets MaturityDay, Tag 205
func (m NoRelatedSym) SetMaturityDay(v int) {
m.Set(field.NewMaturityDay(v))
}
//SetPutOrCall sets PutOrCall, Tag 201
func (m NoRelatedSym) SetPutOrCall(v enum.PutOrCall) {
m.Set(field.NewPutOrCall(v))
}
//SetStrikePrice sets StrikePrice, Tag 202
func (m NoRelatedSym) SetStrikePrice(value decimal.Decimal, scale int32) {
m.Set(field.NewStrikePrice(value, scale))
}
//SetOptAttribute sets OptAttribute, Tag 206
func (m NoRelatedSym) SetOptAttribute(v string) {
m.Set(field.NewOptAttribute(v))
}
//SetSecurityExchange sets SecurityExchange, Tag 207
func (m NoRelatedSym) SetSecurityExchange(v string) {
m.Set(field.NewSecurityExchange(v))
}
//SetIssuer sets Issuer, Tag 106
func (m NoRelatedSym) SetIssuer(v string) {
m.Set(field.NewIssuer(v))
}
//SetSecurityDesc sets SecurityDesc, Tag 107
func (m NoRelatedSym) SetSecurityDesc(v string) {
m.Set(field.NewSecurityDesc(v))
}
//GetRelatdSym gets RelatdSym, Tag 46
func (m NoRelatedSym) GetRelatdSym() (v string, err quickfix.MessageRejectError) {
var f field.RelatdSymField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetSymbolSfx gets SymbolSfx, Tag 65
func (m NoRelatedSym) GetSymbolSfx() (v enum.SymbolSfx, err quickfix.MessageRejectError) {
var f field.SymbolSfxField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetSecurityID gets SecurityID, Tag 48
func (m NoRelatedSym) GetSecurityID() (v string, err quickfix.MessageRejectError) {
var f field.SecurityIDField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetIDSource gets IDSource, Tag 22
func (m NoRelatedSym) GetIDSource() (v enum.IDSource, err quickfix.MessageRejectError) {
var f field.IDSourceField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetSecurityType gets SecurityType, Tag 167
func (m NoRelatedSym) GetSecurityType() (v enum.SecurityType, err quickfix.MessageRejectError) {
var f field.SecurityTypeField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetMaturityMonthYear gets MaturityMonthYear, Tag 200
func (m NoRelatedSym) GetMaturityMonthYear() (v string, err quickfix.MessageRejectError) {
var f field.MaturityMonthYearField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetMaturityDay gets MaturityDay, Tag 205
func (m NoRelatedSym) GetMaturityDay() (v int, err quickfix.MessageRejectError) {
var f field.MaturityDayField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetPutOrCall gets PutOrCall, Tag 201
func (m NoRelatedSym) GetPutOrCall() (v enum.PutOrCall, err quickfix.MessageRejectError) {
var f field.PutOrCallField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetStrikePrice gets StrikePrice, Tag 202
func (m NoRelatedSym) GetStrikePrice() (v decimal.Decimal, err quickfix.MessageRejectError) {
var f field.StrikePriceField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetOptAttribute gets OptAttribute, Tag 206
func (m NoRelatedSym) GetOptAttribute() (v string, err quickfix.MessageRejectError) {
var f field.OptAttributeField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetSecurityExchange gets SecurityExchange, Tag 207
func (m NoRelatedSym) GetSecurityExchange() (v string, err quickfix.MessageRejectError) {
var f field.SecurityExchangeField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetIssuer gets Issuer, Tag 106
func (m NoRelatedSym) GetIssuer() (v string, err quickfix.MessageRejectError) {
var f field.IssuerField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//GetSecurityDesc gets SecurityDesc, Tag 107
func (m NoRelatedSym) GetSecurityDesc() (v string, err quickfix.MessageRejectError) {
var f field.SecurityDescField
if err = m.Get(&f); err == nil {
v = f.Value()
}
return
}
//HasRelatdSym returns true if RelatdSym is present, Tag 46
func (m NoRelatedSym) HasRelatdSym() bool {
return m.Has(tag.RelatdSym)
}
//HasSymbolSfx returns true if SymbolSfx is present, Tag 65
func (m NoRelatedSym) HasSymbolSfx() bool {
return m.Has(tag.SymbolSfx)
}
//HasSecurityID returns true if SecurityID is present, Tag 48
func (m NoRelatedSym) HasSecurityID() bool {
return m.Has(tag.SecurityID)
}
//HasIDSource returns true if IDSource is present, Tag 22
func (m NoRelatedSym) HasIDSource() bool {
return m.Has(tag.IDSource)
}
//HasSecurityType returns true if SecurityType is present, Tag 167
func (m NoRelatedSym) HasSecurityType() bool {
return m.Has(tag.SecurityType)
}
//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200
func (m NoRelatedSym) HasMaturityMonthYear() bool {
return m.Has(tag.MaturityMonthYear)
}
//HasMaturityDay returns true if MaturityDay is present, Tag 205
func (m NoRelatedSym) HasMaturityDay() bool {
return m.Has(tag.MaturityDay)
}
//HasPutOrCall returns true if PutOrCall is present, Tag 201
func (m NoRelatedSym) HasPutOrCall() bool {
return m.Has(tag.PutOrCall)
}
//HasStrikePrice returns true if StrikePrice is present, Tag 202
func (m NoRelatedSym) HasStrikePrice() bool {
return m.Has(tag.StrikePrice)
}
//HasOptAttribute returns true if OptAttribute is present, Tag 206
func (m NoRelatedSym) HasOptAttribute() bool {
return m.Has(tag.OptAttribute)
}
//HasSecurityExchange returns true if SecurityExchange is present, Tag 207
func (m NoRelatedSym) HasSecurityExchange() bool {
return m.Has(tag.SecurityExchange)
}
//HasIssuer returns true if Issuer is present, Tag 106
func (m NoRelatedSym) HasIssuer() bool {
return m.Has(tag.Issuer)
}
//HasSecurityDesc returns true if SecurityDesc is present, Tag 107
func (m NoRelatedSym) HasSecurityDesc() bool {
return m.Has(tag.SecurityDesc)
}
//NoRelatedSymRepeatingGroup is a repeating group, Tag 146
type NoRelatedSymRepeatingGroup struct {
*quickfix.RepeatingGroup
}
//NewNoRelatedSymRepeatingGroup returns an initialized, NoRelatedSymRepeatingGroup
func NewNoRelatedSymRepeatingGroup() NoRelatedSymRepeatingGroup {
return NoRelatedSymRepeatingGroup{
quickfix.NewRepeatingGroup(tag.NoRelatedSym,
quickfix.GroupTemplate{quickfix.GroupElement(tag.RelatdSym), quickfix.GroupElement(tag.SymbolSfx), quickfix.GroupElement(tag.SecurityID), quickfix.GroupElement(tag.IDSource), quickfix.GroupElement(tag.SecurityType), quickfix.GroupElement(tag.MaturityMonthYear), quickfix.GroupElement(tag.MaturityDay), quickfix.GroupElement(tag.PutOrCall), quickfix.GroupElement(tag.StrikePrice), quickfix.GroupElement(tag.OptAttribute), quickfix.GroupElement(tag.SecurityExchange), quickfix.GroupElement(tag.Issuer), quickfix.GroupElement(tag.SecurityDesc)})}
}
//Add create and append a new NoRelatedSym to this group
func (m NoRelatedSymRepeatingGroup) Add() NoRelatedSym {
g := m.RepeatingGroup.Add()
return NoRelatedSym{g}
}
//Get returns the ith NoRelatedSym in the NoRelatedSymRepeatinGroup
func (m NoRelatedSymRepeatingGroup) Get(i int) NoRelatedSym {
return NoRelatedSym{m.RepeatingGroup.Get(i)}
}
|
package internal
import (
"reflect"
"testing"
"github.com/5xxxx/pie/driver"
"go.mongodb.org/mongo-driver/bson"
)
func TestDefaultCondition(t *testing.T) {
tests := []struct {
name string
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := DefaultCondition(); !reflect.DeepEqual(got, tt.want) {
t.Errorf("DefaultCondition() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_A(t *testing.T) {
type fields struct {
d bson.D
}
tests := []struct {
name string
fields fields
want bson.A
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.A(); !reflect.DeepEqual(got, tt.want) {
t.Errorf("A() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_And(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
filter driver.Condition
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.And(tt.args.filter); !reflect.DeepEqual(got, tt.want) {
t.Errorf("And() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Eq(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
value interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Eq(tt.args.key, tt.args.value); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Eq() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Exists(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
exists bool
filter []driver.Condition
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Exists(tt.args.key, tt.args.exists, tt.args.filter...); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Exists() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Expr(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
filter driver.Condition
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Expr(tt.args.filter); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Expr() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Filters(t *testing.T) {
type fields struct {
d bson.D
}
tests := []struct {
name string
fields fields
want bson.D
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got, _ := f.Filters(); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Filters() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Gt(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
gt interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Gt(tt.args.key, tt.args.gt); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Gt() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Gte(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
gte interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Gte(tt.args.key, tt.args.gte); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Gte() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_ID(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
id interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.ID(tt.args.id); !reflect.DeepEqual(got, tt.want) {
t.Errorf("ID() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_In(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
in interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.In(tt.args.key, tt.args.in); !reflect.DeepEqual(got, tt.want) {
t.Errorf("In() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Lt(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
lt interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Lt(tt.args.key, tt.args.lt); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Lt() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Lte(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
lte interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Lte(tt.args.key, tt.args.lte); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Lte() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Ne(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
ne interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Ne(tt.args.key, tt.args.ne); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Ne() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Nin(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
nin interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Nin(tt.args.key, tt.args.nin); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Nin() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Nor(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
filter driver.Condition
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Nor(tt.args.filter); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Nor() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Not(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
not interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Not(tt.args.key, tt.args.not); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Not() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Or(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
filter driver.Condition
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Or(tt.args.filter); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Or() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Regex(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
value string
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Regex(tt.args.key, tt.args.value); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Regex() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_RegexFilter(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
pattern string
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.RegexFilter(tt.args.key, tt.args.pattern); !reflect.DeepEqual(got, tt.want) {
t.Errorf("RegexFilter() = %v, want %v", got, tt.want)
}
})
}
}
func Test_filter_Type(t *testing.T) {
type fields struct {
d bson.D
}
type args struct {
key string
t interface{}
}
tests := []struct {
name string
fields fields
args args
want driver.Condition
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &filter{
d: tt.fields.d,
}
if got := f.Type(tt.args.key, tt.args.t); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Type() = %v, want %v", got, tt.want)
}
})
}
}
|
package inventoryd
import (
"context"
"encoding/base64"
"errors"
"log"
"strconv"
"strings"
)
// Register時のパラメータ
// OMA-TS-LightweightM2M-V1_0_2-20180209-A 5.3.1参照
// BingindModeはU/UQ/S/SQ/USがあるが、Uしか使わない
const (
lwm2mVersion string = "1.0"
lwm2mBindingMode string = "U"
)
// Register : Register Operation
// OMA-TS-LightweightM2M-V1_0_2-20180209-A 5.3.1 Register参照
func (lwm2m *Lwm2m) Register() error {
log.Print("Registering...")
err := lwm2m.connect()
if err != nil {
return err
}
ctx, cancel := context.WithTimeout(context.Background(), lwm2mRegisterTimeout)
defer cancel()
registerCh := make(chan int)
lwm2m.Connection.SendRequest(CoapCodePost, lwm2m.buildRegisterOptions(lwm2m.getLifetime()), lwm2m.registerLinkFormat(), registerCh)
select {
case <-ctx.Done():
// タイムアウトした場合
lwm2m.close()
return errors.New("Register処理がタイムアウトしました")
case <-registerCh:
// Registerが正常に終了した場合
lwm2m.registered = true
log.Printf("Register finished. Location is %s\n", lwm2m.Location)
}
return nil
}
// connect : DTLS + Coap接続する
func (lwm2m *Lwm2m) connect() error {
identity := lwm2m.getIdentity()
psk := lwm2m.getSecretKey()
uri := lwm2m.getDMServerURI()
host := strings.Replace(uri, "coaps://", "", 1)
// 接続が残っていたら閉じる
if lwm2m.Connection != nil {
lwm2m.close()
}
coap := &Coap{}
conn, err := DtlsDial(host, identity, psk)
if err != nil {
log.Print(err)
return errors.New("DTLSの接続に失敗しました")
}
coap.Initialize(conn, lwm2m.ReceiveMessage)
lwm2m.Connection = coap
return nil
}
// close : 接続を閉じる
func (lwm2m *Lwm2m) close() {
lwm2m.Connection.Close()
lwm2m.Connection = nil
lwm2m.registered = false
}
// Update : Update Operation
// OMA-TS-LightweightM2M-V1_0_2-20180209-A 5.3.2 Update参照
func (lwm2m *Lwm2m) Update() error {
// Register状態でなければRegisterする
if lwm2m.Connection == nil {
err := lwm2m.Register()
if err != nil {
return err
}
return nil
}
log.Print("Updating...")
ctx, cancel := context.WithTimeout(context.Background(), lwm2mUpdateTimeout)
defer cancel()
updateCh := make(chan int)
lwm2m.Connection.SendRequest(CoapCodePost, lwm2m.buildUpdateOptions(), []byte{}, updateCh)
select {
case <-ctx.Done():
// タイムアウトした場合
lwm2m.close()
return errors.New("Update処理がタイムアウトしました")
case <-updateCh:
// Updateが正常に終了した場合
log.Print("Update finished")
}
return nil
}
// RegisterDone : Register 終了メッセージの処理
func (lwm2m *Lwm2m) RegisterDone(message *CoapMessage) {
locationPathIndex := 0
for i := range message.Options {
if message.Options[i].No == coapOptionNoLocationPath {
if locationPathIndex == 0 {
locationPathIndex++
} else if locationPathIndex == 1 {
lwm2m.Location = string(message.Options[i].Value)
locationPathIndex++
}
}
}
}
// UpdateDone : Update 終了メッセージの処理
func (lwm2m *Lwm2m) UpdateDone(message *CoapMessage) {
// 処理必要なし
}
// buildRegisterOptions : Register Operationに使用するオプションを生成する
func (lwm2m *Lwm2m) buildRegisterOptions(lifetime int) []CoapOption {
ret := []CoapOption{
CoapOption{coapOptionNoURIPath, []byte("rd")},
CoapOption{coapOptionNoContentFormat, []byte{coapContentFormatLinkFormat}},
CoapOption{coapOptionNoURIQuery, []byte("lwm2m=" + lwm2mVersion)},
CoapOption{coapOptionNoURIQuery, []byte("ep=" + lwm2m.endpointClientName)},
CoapOption{coapOptionNoURIQuery, []byte("b=" + lwm2mBindingMode)},
CoapOption{coapOptionNoURIQuery, []byte("lt=" + strconv.Itoa(lifetime))}}
return ret
}
// registerLinkFormat : Registerに使用するリンクフォーマットを生成する
// LinkFormatの説明 : RFC6690
// rt(Resource Type) : oma.lwm2m
// ct(Content Type) : 11543(application/vnd.oma.lwm2m+json)
// 参照 : https://www.iana.org/assignments/core-parameters/core-parameters.xhtml
func (lwm2m *Lwm2m) registerLinkFormat() []byte {
return []byte("</>;rt=\"oma.lwm2m\";ct=" + strconv.Itoa(coapContentFormatLwm2mJSON) + ",<" + strings.Join(lwm2m.instanceIDList(), ">,<") + ">")
}
// buildUpdateOptions : Update Operationに使用するオプションを生成する
func (lwm2m *Lwm2m) buildUpdateOptions() []CoapOption {
ret := []CoapOption{
CoapOption{coapOptionNoURIPath, []byte("rd")},
CoapOption{coapOptionNoURIPath, []byte(lwm2m.Location)}}
return ret
}
// instanceIDList : 登録インスタンスのリストを取得する
// objectID: 0(Security)はRegister時のインスタンスに含めない
// The Security Object ID:0 MUST NOT be part of the Registration Objects and Object Instances list.
// OMA-TS-LightweightM2M-V1_0_2-20180209-A 5.3.1 Register参照
func (lwm2m *Lwm2m) instanceIDList() []string {
ret := make([]string, 0)
objectIDs, code := lwm2m.handler.ListObjectIDs()
if code != CoapCodeContent {
return []string{}
}
for _, objectID := range objectIDs {
if objectID == 0 {
continue
}
definition := lwm2m.definitions.findObjectDefinitionByID(objectID)
instanceIDs, code := lwm2m.handler.ListInstanceIDs(&Lwm2mObject{ID: objectID, Definition: definition})
if code != CoapCodeContent {
continue
}
for _, instanceID := range instanceIDs {
ret = append(ret, "/"+strconv.Itoa((int)(objectID))+"/"+strconv.Itoa((int)(instanceID)))
}
}
return ret
}
// getIdentity : Identityを取得する
func (lwm2m *Lwm2m) getIdentity() []byte {
resource := lwm2m.findResource(lwm2mObjectIDSecurity, lwm2m.dmSecurityInstanceID, lwm2mResourceIDSecurityIdentity)
identityStr, code := lwm2m.handler.ReadResource(resource)
if code != CoapCodeContent {
return []byte{}
}
identity, err := base64.StdEncoding.DecodeString(identityStr)
if err != nil {
return []byte{}
}
return identity
}
// getSecretKey : Secret Key(PSK)を取得する
func (lwm2m *Lwm2m) getSecretKey() []byte {
resource := lwm2m.findResource(lwm2mObjectIDSecurity, lwm2m.dmSecurityInstanceID, lwm2mResourceIDSecuritySecretKey)
secretKeyStr, code := lwm2m.handler.ReadResource(resource)
if code != CoapCodeContent {
return []byte{}
}
secretKey, err := base64.StdEncoding.DecodeString(secretKeyStr)
if err != nil {
return []byte{}
}
return secretKey
}
// getLifetime : lifetimeを取得する
// 取得できない場合は60とする
func (lwm2m *Lwm2m) getLifetime() int {
resource := lwm2m.findResource(lwm2mObjectIDServer, lwm2m.dmServerInstanceID, lwm2mResourceIDServerLifetime)
lifetimeStr, code := lwm2m.handler.ReadResource(resource)
if code != CoapCodeContent {
return lwm2mDefaultLifetime
}
lifetime, err := strconv.Atoi(lifetimeStr)
if err != nil {
return lwm2mDefaultLifetime
}
return lifetime
}
// getDMServerURI : Device management serverのURIを取得する
// 取得できない場合はデフォルト(coaps://jp.inventory.soracom.io:5684)とする
func (lwm2m *Lwm2m) getDMServerURI() string {
resource := lwm2m.findResource(lwm2mObjectIDSecurity, lwm2m.dmSecurityInstanceID, lwm2mResourceIDSecurityURI)
dmServerURIStr, code := lwm2m.handler.ReadResource(resource)
if code != CoapCodeContent {
return lwm2mDefaultDMServerURL
}
return dmServerURIStr
}
|
package main
import (
"fmt"
)
func main() {
var t int
fmt.Scanf("%d\n", &t)
for i:=0; i<t; i++ {
var w, h, n uint64
fmt.Scanf("%d %d %d\n", &w, &h, &n)
var f uint64
f = 1
for (w % 2 == 0) || (h % 2 == 0) {
f *= 2
if f >= n { break }
if w % 2 == 0 {
w /= 2
} else if h % 2 == 0 {
h /= 2
}
}
if f >= n {
fmt.Println("YES")
} else {
fmt.Println("NO")
}
}
}
|
package main
type WordDescription struct {
Tf float64
Idf float64
Rank float64
}
|
////////////////////////////////////////////////////////////////////////////////
// //
// Copyright 2019 Dell, 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 transformer
import (
"fmt"
"errors"
"strings"
"regexp"
"runtime"
"github.com/Azure/sonic-mgmt-common/translib/db"
"github.com/Azure/sonic-mgmt-common/translib/tlerr"
"github.com/openconfig/goyang/pkg/yang"
"github.com/openconfig/gnmi/proto/gnmi"
"github.com/openconfig/ygot/ygot"
"github.com/openconfig/ygot/ytypes"
"github.com/Azure/sonic-mgmt-common/translib/ocbinds"
log "github.com/golang/glog"
"sync"
)
func initRegex() {
rgpKeyExtract = regexp.MustCompile(`\[([^\[\]]*)\]`)
rgpIpv6 = regexp.MustCompile(`(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)(%.+)?`)
rgpMac = regexp.MustCompile(`([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$`)
rgpIsMac = regexp.MustCompile(`^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$`)
rgpSncKeyExtract = regexp.MustCompile(`\[([^\[\]]*)\]`)
}
/* Create db key from data xpath(request) */
func keyCreate(keyPrefix string, xpath string, data interface{}, dbKeySep string) string {
_, ok := xYangSpecMap[xpath]
if ok {
if xYangSpecMap[xpath].yangEntry != nil {
yangEntry := xYangSpecMap[xpath].yangEntry
delim := dbKeySep
if len(xYangSpecMap[xpath].delim) > 0 {
delim = xYangSpecMap[xpath].delim
xfmrLogInfoAll("key concatenater(\"%v\") found for xpath %v ", delim, xpath)
}
if len(keyPrefix) > 0 { keyPrefix += delim }
keyVal := ""
for i, k := range (strings.Split(yangEntry.Key, " ")) {
if i > 0 { keyVal = keyVal + delim }
fieldXpath := xpath + "/" + k
fVal, err := unmarshalJsonToDbData(yangEntry.Dir[k], fieldXpath, k, data.(map[string]interface{})[k])
if err != nil {
log.Warningf("Couldn't unmarshal Json to DbData: path(\"%v\") error (\"%v\").", fieldXpath, err)
}
if ((strings.Contains(fVal, ":")) &&
(strings.HasPrefix(fVal, OC_MDL_PFX) || strings.HasPrefix(fVal, IETF_MDL_PFX) || strings.HasPrefix(fVal, IANA_MDL_PFX))) {
// identity-ref/enum has module prefix
fVal = strings.SplitN(fVal, ":", 2)[1]
}
keyVal += fVal
}
keyPrefix += string(keyVal)
}
}
return keyPrefix
}
/* Copy redis-db source to destn map */
func mapCopy(destnMap map[string]map[string]db.Value, srcMap map[string]map[string]db.Value) {
mapCopyMutex.Lock()
for table, tableData := range srcMap {
_, ok := destnMap[table]
if !ok {
destnMap[table] = make(map[string]db.Value)
}
for rule, ruleData := range tableData {
_, ok = destnMap[table][rule]
if !ok {
destnMap[table][rule] = db.Value{Field: make(map[string]string)}
}
for field, value := range ruleData.Field {
destnMap[table][rule].Field[field] = value
}
}
}
mapCopyMutex.Unlock()
}
var mapMergeMutex = &sync.Mutex{}
/* Merge redis-db source to destn map */
func mapMerge(destnMap map[string]map[string]db.Value, srcMap map[string]map[string]db.Value, oper int) {
mapMergeMutex.Lock()
for table, tableData := range srcMap {
_, ok := destnMap[table]
if !ok {
destnMap[table] = make(map[string]db.Value)
}
for rule, ruleData := range tableData {
_, ok = destnMap[table][rule]
if !ok {
destnMap[table][rule] = db.Value{Field: make(map[string]string)}
} else {
if (oper == DELETE) {
if ((len(destnMap[table][rule].Field) == 0) && (len(ruleData.Field) > 0)) {
continue;
}
if ((len(destnMap[table][rule].Field) > 0) && (len(ruleData.Field) == 0)) {
destnMap[table][rule] = db.Value{Field: make(map[string]string)};
}
}
}
for field, value := range ruleData.Field {
dval := destnMap[table][rule]
if dval.IsPopulated() && dval.Has(field) && strings.HasSuffix(field, "@") {
attrList := dval.GetList(field)
attrList = append(attrList, value)
dval.SetList(field, attrList)
} else {
destnMap[table][rule].Field[field] = value
}
}
}
}
mapMergeMutex.Unlock()
}
func parentXpathGet(xpath string) string {
path := ""
if len(xpath) > 0 {
p := strings.Split(xpath, "/")
path = strings.Join(p[:len(p)-1], "/")
}
return path
}
func parentUriGet(uri string) string {
parentUri := ""
if len(uri) > 0 {
uriList := splitUri(uri)
if len(uriList) > 2 {
parentUriList := uriList[:len(uriList)-1]
parentUri = strings.Join(parentUriList, "/")
parentUri = "/" + parentUri
}
}
return parentUri
}
func yangTypeGet(entry *yang.Entry) string {
if entry != nil && entry.Node != nil {
return entry.Node.Statement().Keyword
}
return ""
}
func dbKeyToYangDataConvert(uri string, requestUri string, xpath string, tableName string, dbDataMap *map[db.DBNum]map[string]map[string]db.Value, dbKey string, dbKeySep string, txCache interface{}) (map[string]interface{}, string, error) {
var err error
if len(uri) == 0 && len(xpath) == 0 && len(dbKey) == 0 {
err = fmt.Errorf("Insufficient input")
return nil, "", err
}
if _, ok := xYangSpecMap[xpath]; ok {
if xYangSpecMap[xpath].yangEntry == nil {
log.Warningf("Yang Entry not available for xpath %v", xpath)
return nil, "", nil
}
}
keyNameList := yangKeyFromEntryGet(xYangSpecMap[xpath].yangEntry)
id := xYangSpecMap[xpath].keyLevel
keyDataList := strings.SplitN(dbKey, dbKeySep, id)
uriWithKey := fmt.Sprintf("%v", xpath)
uriWithKeyCreate := true
if len(keyDataList) == 0 {
keyDataList = append(keyDataList, dbKey)
}
/* if uri contins key, use it else use xpath */
if strings.Contains(uri, "[") {
if strings.HasSuffix(uri, "]") || strings.HasSuffix(uri, "]/") {
uriXpath, _, _ := XfmrRemoveXPATHPredicates(uri)
if uriXpath == xpath {
uriWithKeyCreate = false
}
}
uriWithKey = fmt.Sprintf("%v", uri)
}
if len(xYangSpecMap[xpath].xfmrKey) > 0 {
var dbs [db.MaxDB]*db.DB
inParams := formXfmrInputRequest(nil, dbs, db.MaxDB, nil, uri, requestUri, GET, dbKey, dbDataMap, nil, nil, txCache)
inParams.table = tableName
rmap, err := keyXfmrHandlerFunc(inParams, xYangSpecMap[xpath].xfmrKey)
if err != nil {
return nil, "", err
}
if uriWithKeyCreate {
for k, v := range rmap {
uriWithKey += fmt.Sprintf("[%v=%v]", k, v)
}
}
return rmap, uriWithKey, nil
}
if len(keyNameList) == 0 {
return nil, "", nil
}
rmap := make(map[string]interface{})
if len(keyNameList) > 1 {
log.Warningf("No key transformer found for multi element yang key mapping to a single redis key string, for uri %v", uri)
errStr := fmt.Sprintf("Error processing key for list %v", uri)
err = fmt.Errorf("%v", errStr)
return rmap, uriWithKey, err
}
keyXpath := xpath + "/" + keyNameList[0]
xyangSpecInfo, ok := xYangSpecMap[keyXpath]
if !ok || xyangSpecInfo == nil {
errStr := fmt.Sprintf("Failed to find key xpath %v in xYangSpecMap or is nil, needed to fetch the yangEntry data-type", keyXpath)
err = fmt.Errorf("%v", errStr)
return rmap, uriWithKey, err
}
yngTerminalNdDtType := xyangSpecInfo.yangEntry.Type.Kind
resVal, _, err := DbToYangType(yngTerminalNdDtType, keyXpath, keyDataList[0])
if err != nil {
err = fmt.Errorf("Failure in converting Db value type to yang type for field %v", keyXpath)
return rmap, uriWithKey, err
} else {
rmap[keyNameList[0]] = resVal
}
if uriWithKeyCreate {
uriWithKey += fmt.Sprintf("[%v=%v]", keyNameList[0], resVal)
}
return rmap, uriWithKey, nil
}
func contains(sl []string, str string) bool {
for _, v := range sl {
if v == str {
return true
}
}
return false
}
func isSubtreeRequest(targetUriPath string, nodePath string) bool {
if len(targetUriPath) > 0 && len(nodePath) > 0 {
return strings.HasPrefix(targetUriPath, nodePath)
}
return false
}
func getYangPathFromUri(uri string) (string, error) {
var path *gnmi.Path
var err error
path, err = ygot.StringToPath(uri, ygot.StructuredPath, ygot.StringSlicePath)
if err != nil {
log.Warningf("Error in uri to path conversion: %v", err)
return "", err
}
yangPath, yperr := ygot.PathToSchemaPath(path)
if yperr != nil {
log.Warningf("Error in Gnmi path to Yang path conversion: %v", yperr)
return "", yperr
}
return yangPath, err
}
func yangKeyFromEntryGet(entry *yang.Entry) []string {
var keyList []string
keyList = append(keyList, strings.Split(entry.Key, " ")...)
return keyList
}
func isSonicYang(path string) bool {
return strings.HasPrefix(path, "/sonic")
}
func hasIpv6AddString(val string) bool {
return rgpIpv6.MatchString(val)
}
func hasMacAddString(val string) bool {
return rgpMac.MatchString(val)
}
func isMacAddString(val string) bool {
return rgpIsMac.MatchString(val)
}
func getYangTerminalNodeTypeName(xpathPrefix string, keyName string) string {
keyXpath := xpathPrefix + "/" + keyName
xfmrLogInfoAll("getYangTerminalNodeTypeName keyXpath: %v ", keyXpath)
dbInfo, ok := xDbSpecMap[keyXpath]
if ok {
yngTerminalNdTyName := dbInfo.dbEntry.Type.Name
xfmrLogInfoAll("yngTerminalNdTyName: %v", yngTerminalNdTyName)
return yngTerminalNdTyName
}
return ""
}
func sonicKeyDataAdd(dbIndex db.DBNum, keyNameList []string, xpathPrefix string, keyStr string, resultMap map[string]interface{}) {
var dbOpts db.Options
var keyValList []string
xfmrLogInfoAll("sonicKeyDataAdd keyNameList:%v, keyStr:%v", keyNameList, keyStr)
dbOpts = getDBOptions(dbIndex)
keySeparator := dbOpts.KeySeparator
/* num of key separators will be less than number of keys */
if len(keyNameList) == 1 && keySeparator == ":" {
yngTerminalNdTyName := getYangTerminalNodeTypeName(xpathPrefix, keyNameList[0])
if yngTerminalNdTyName == "mac-address" && isMacAddString(keyStr) {
keyValList = strings.SplitN(keyStr, keySeparator, len(keyNameList))
} else if (yngTerminalNdTyName == "ip-address" || yngTerminalNdTyName == "ip-prefix" || yngTerminalNdTyName == "ipv6-prefix" || yngTerminalNdTyName == "ipv6-address") && hasIpv6AddString(keyStr) {
keyValList = strings.SplitN(keyStr, keySeparator, len(keyNameList))
} else {
keyValList = strings.SplitN(keyStr, keySeparator, -1)
xfmrLogInfoAll("Single key non ipv6/mac address for : separator")
}
} else if (strings.Count(keyStr, keySeparator) == len(keyNameList)-1) {
/* number of keys will match number of key values */
keyValList = strings.SplitN(keyStr, keySeparator, len(keyNameList))
} else {
/* number of dbKey values more than number of keys */
if keySeparator == ":" && (hasIpv6AddString(keyStr)|| hasMacAddString(keyStr)) {
xfmrLogInfoAll("Key Str has ipv6/mac address with : separator")
if len(keyNameList) == 2 {
valList := strings.SplitN(keyStr, keySeparator, -1)
/* IPV6 address is first entry */
yngTerminalNdTyName := getYangTerminalNodeTypeName(xpathPrefix, keyNameList[0])
if yngTerminalNdTyName == "ip-address" || yngTerminalNdTyName == "ip-prefix" || yngTerminalNdTyName == "ipv6-prefix" || yngTerminalNdTyName == "ipv6-address" || yngTerminalNdTyName == "mac-address"{
keyValList = append(keyValList, strings.Join(valList[:len(valList)-2], keySeparator))
keyValList = append(keyValList, valList[len(valList)-1])
} else {
yngTerminalNdTyName := getYangTerminalNodeTypeName(xpathPrefix, keyNameList[1])
if yngTerminalNdTyName == "ip-address" || yngTerminalNdTyName == "ip-prefix" || yngTerminalNdTyName == "ipv6-prefix" || yngTerminalNdTyName == "ipv6-address" || yngTerminalNdTyName == "mac-address" {
keyValList = append(keyValList, valList[0])
keyValList = append(keyValList, strings.Join(valList[1:], keySeparator))
} else {
xfmrLogInfoAll("No ipv6 or mac address found in value. Cannot split value ")
}
}
xfmrLogInfoAll("KeyValList has %v", keyValList)
} else {
xfmrLogInfoAll("Number of keys : %v", len(keyNameList))
}
} else {
keyValList = strings.SplitN(keyStr, keySeparator, -1)
xfmrLogInfoAll("Split all keys KeyValList has %v", keyValList)
}
}
xfmrLogInfoAll("yang keys list - %v, xpathprefix - %v, DB-key string - %v, DB-key list after db key separator split - %v, dbIndex - %v", keyNameList, xpathPrefix, keyStr, keyValList, dbIndex)
if len(keyNameList) != len(keyValList) {
return
}
for i, keyName := range keyNameList {
keyXpath := xpathPrefix + "/" + keyName
dbInfo, ok := xDbSpecMap[keyXpath]
var resVal interface{}
resVal = keyValList[i]
if !ok || dbInfo == nil {
log.Warningf("xDbSpecMap entry not found or is nil for xpath %v, hence data-type conversion cannot happen", keyXpath)
} else {
yngTerminalNdDtType := dbInfo.dbEntry.Type.Kind
var err error
resVal, _, err = DbToYangType(yngTerminalNdDtType, keyXpath, keyValList[i])
if err != nil {
log.Warningf("Data-type conversion unsuccessfull for xpath %v", keyXpath)
resVal = keyValList[i]
}
}
resultMap[keyName] = resVal
}
}
func yangToDbXfmrFunc(funcName string) string {
return ("YangToDb_" + funcName)
}
func uriWithKeyCreate (uri string, xpathTmplt string, data interface{}) (string, error) {
var err error
if _, ok := xYangSpecMap[xpathTmplt]; ok {
yangEntry := xYangSpecMap[xpathTmplt].yangEntry
if yangEntry != nil {
for _, k := range (strings.Split(yangEntry.Key, " ")) {
keyXpath := xpathTmplt + "/" + k
if _, keyXpathEntryOk := xYangSpecMap[keyXpath]; !keyXpathEntryOk {
log.Warningf("No entry found in xYangSpec map for xapth %v", keyXpath)
err = fmt.Errorf("No entry found in xYangSpec map for xapth %v", keyXpath)
break
}
keyYangEntry := xYangSpecMap[keyXpath].yangEntry
if keyYangEntry == nil {
log.Warningf("Yang Entry not available for xpath %v", keyXpath)
err = fmt.Errorf("Yang Entry not available for xpath %v", keyXpath)
break
}
keyVal, keyValErr := unmarshalJsonToDbData(keyYangEntry, keyXpath, k, data.(map[string]interface{})[k])
if keyValErr != nil {
log.Warningf("unmarshalJsonToDbData() didn't unmarshal for key %v with xpath %v", k, keyXpath)
err = keyValErr
break
}
if ((strings.Contains(keyVal, ":")) && (strings.HasPrefix(keyVal, OC_MDL_PFX) || strings.HasPrefix(keyVal, IETF_MDL_PFX) || strings.HasPrefix(keyVal, IANA_MDL_PFX))) {
// identity-ref/enum has module prefix
keyVal = strings.SplitN(keyVal, ":", 2)[1]
}
uri += fmt.Sprintf("[%v=%v]", k, keyVal)
}
} else {
err = fmt.Errorf("Yang Entry not available for xpath %v", xpathTmplt)
}
} else {
err = fmt.Errorf("No entry in xYangSpecMap for xpath %v", xpathTmplt)
}
return uri, err
}
func xpathRootNameGet(path string) string {
if len(path) > 0 {
pathl := strings.Split(path, "/")
return ("/" + pathl[1])
}
return ""
}
func dbToYangXfmrFunc(funcName string) string {
return ("DbToYang_" + funcName)
}
func uriModuleNameGet(uri string) (string, error) {
var err error
result := ""
if len(uri) == 0 {
log.Warning("Empty uri string supplied")
err = fmt.Errorf("Empty uri string supplied")
return result, err
}
urislice := strings.Split(uri, ":")
if len(urislice) == 1 {
log.Warningf("uri string %s does not have module name", uri)
err = fmt.Errorf("uri string does not have module name: %v", uri)
return result, err
}
moduleNm := strings.Split(urislice[0], "/")
result = moduleNm[1]
if len(strings.Trim(result, " ")) == 0 {
log.Warning("Empty module name")
err = fmt.Errorf("No module name found in uri %s", uri)
}
xfmrLogInfo("module name = %v", result)
return result, err
}
func formXfmrInputRequest(d *db.DB, dbs [db.MaxDB]*db.DB, cdb db.DBNum, ygRoot *ygot.GoStruct, uri string, requestUri string, oper int, key string, dbDataMap *RedisDbMap, subOpDataMap map[int]*RedisDbMap, param interface{}, txCache interface{}) XfmrParams {
var inParams XfmrParams
inParams.d = d
inParams.dbs = dbs
inParams.curDb = cdb
inParams.ygRoot = ygRoot
inParams.uri = uri
inParams.requestUri = requestUri
inParams.oper = oper
inParams.key = key
inParams.dbDataMap = dbDataMap
inParams.subOpDataMap = subOpDataMap
inParams.param = param // generic param
inParams.txCache = txCache.(*sync.Map)
inParams.skipOrdTblChk = new(bool)
inParams.isVirtualTbl = new(bool)
inParams.pCascadeDelTbl = new([]string)
return inParams
}
func findByValue(m map[string]string, value string) string {
for key, val := range m {
if val == value {
return key
}
}
return ""
}
func findByKey(m map[string]string, key string) string {
if val, found := m[key]; found {
return val
}
return ""
}
func findInMap(m map[string]string, str string) string {
// Check if str exists as a value in map m.
if val := findByKey(m, str); val != "" {
return val
}
// Check if str exists as a key in map m.
if val := findByValue(m, str); val != "" {
return val
}
// str doesn't exist in map m.
return ""
}
func getDBOptions(dbNo db.DBNum) db.Options {
var opt db.Options
switch dbNo {
case db.ApplDB, db.CountersDB:
opt = getDBOptionsWithSeparator(dbNo, "", ":", ":")
case db.FlexCounterDB, db.AsicDB, db.ConfigDB, db.StateDB, db.ErrorDB, db.UserDB:
opt = getDBOptionsWithSeparator(dbNo, "", "|", "|")
}
return opt
}
func getDBOptionsWithSeparator(dbNo db.DBNum, initIndicator string, tableSeparator string, keySeparator string) db.Options {
return(db.Options {
DBNo : dbNo,
InitIndicator : initIndicator,
TableNameSeparator: tableSeparator,
KeySeparator : keySeparator,
})
}
func getXpathFromYangEntry(entry *yang.Entry) string {
xpath := ""
if entry != nil {
xpath = entry.Name
entry = entry.Parent
for {
if entry.Parent != nil {
xpath = entry.Name + "/" + xpath
entry = entry.Parent
} else {
// This is the module entry case
xpath = "/" + entry.Name + ":" + xpath
break
}
}
}
return xpath
}
func stripAugmentedModuleNames(xpath string) string {
if !strings.HasPrefix(xpath, "/") {
xpath = "/" + xpath
}
pathList := strings.Split(xpath, "/")
pathList = pathList[1:]
for i, pvar := range pathList {
if (i > 0) && strings.Contains(pvar, ":") {
pvar = strings.Split(pvar,":")[1]
pathList[i] = pvar
}
}
path := "/" + strings.Join(pathList, "/")
return path
}
func XfmrRemoveXPATHPredicates(uri string) (string, []string, error) {
var uriList []string
var pathList []string
uriList = SplitPath(uri)
// Strip keys for xpath creation
for _, path := range uriList {
si := strings.Index(path, "[")
if si != -1 {
pathList = append(pathList, path[:si])
} else {
pathList = append(pathList, path)
}
}
inPath := strings.Join(pathList, "/")
if !strings.HasPrefix(uri, "..") {
inPath = "/" + inPath
}
xpath := stripAugmentedModuleNames(inPath)
return xpath, uriList, nil
}
func replacePrefixWithModuleName(xpath string) (string) {
//Input xpath is after removing the xpath Predicates
var moduleNm string
if _, ok := xYangSpecMap[xpath]; ok {
moduleNm = xYangSpecMap[xpath].dbEntry.Prefix.Parent.NName()
pathList := strings.Split(xpath, ":")
if len(moduleNm) > 0 && len(pathList) == 2 {
xpath = "/" + moduleNm + ":" + pathList[1]
}
}
return xpath
}
/* Extract key vars, create db key and xpath */
func xpathKeyExtract(d *db.DB, ygRoot *ygot.GoStruct, oper int, path string, requestUri string, dbDataMap *map[db.DBNum]map[string]map[string]db.Value, subOpDataMap map[int]*RedisDbMap, txCache interface{}, xfmrTblKeyCache map[string]tblKeyCache) (xpathTblKeyExtractRet, error) {
xfmrLogInfoAll("In uri(%v), reqUri(%v), oper(%v)", path, requestUri, oper)
var retData xpathTblKeyExtractRet
keyStr := ""
curPathWithKey := ""
cdb := db.ConfigDB
var dbs [db.MaxDB]*db.DB
var err error
var isUriForListInstance bool
var pathList []string
retData.xpath = ""
retData.tableName = ""
retData.dbKey = ""
retData.isVirtualTbl = false
isUriForListInstance = false
retData.xpath, pathList, _ = XfmrRemoveXPATHPredicates(path)
xpathInfo, ok := xYangSpecMap[retData.xpath]
if !ok {
log.Warningf("No entry found in xYangSpecMap for xpath %v.", retData.xpath)
return retData, err
}
// for SUBSCRIBE reuestUri = path
requestUriYangType := yangTypeGet(xpathInfo.yangEntry)
if requestUriYangType == YANG_LIST {
if strings.HasSuffix(path, "]") { //uri is for list instance
isUriForListInstance = true
}
}
cdb = xpathInfo.dbIndex
dbOpts := getDBOptions(cdb)
keySeparator := dbOpts.KeySeparator
if len(xpathInfo.delim) > 0 {
keySeparator = xpathInfo.delim
}
xpathList := strings.Split(retData.xpath, "/")
xpathList = xpathList[1:]
yangXpath := ""
xfmrLogInfoAll("path elements are : %v", pathList)
for i, k := range pathList {
curPathWithKey += "/" + k
callKeyXfmr := true
yangXpath += "/" + xpathList[i]
xpathInfo, ok := xYangSpecMap[yangXpath]
if ok {
yangType := yangTypeGet(xpathInfo.yangEntry)
/* when deleting a specific element from leaf-list query uri is of the form
/prefix-path/leafList-field-name[leafList-field-name=value].
Here the syntax is like a list-key instance enclosed in square
brackets .So avoid list key instance like processing for such a case
*/
if yangType == YANG_LEAF_LIST {
break
}
if strings.Contains(k, "[") {
if len(keyStr) > 0 {
keyStr += keySeparator
}
if len(xYangSpecMap[yangXpath].xfmrKey) > 0 {
if xfmrTblKeyCache != nil {
if tkCache, _ok := xfmrTblKeyCache[curPathWithKey]; _ok {
if len(tkCache.dbKey) != 0 {
keyStr = tkCache.dbKey
callKeyXfmr = false
}
}
}
if callKeyXfmr {
xfmrFuncName := yangToDbXfmrFunc(xYangSpecMap[yangXpath].xfmrKey)
inParams := formXfmrInputRequest(d, dbs, cdb, ygRoot, curPathWithKey, requestUri, oper, "", nil, subOpDataMap, nil, txCache)
if oper == GET {
ret, err := XlateFuncCall(xfmrFuncName, inParams)
if err != nil {
retData.dbKey,retData.tableName,retData.xpath = "","",""
return retData, err
}
if ret != nil {
keyStr = ret[0].Interface().(string)
}
} else {
ret, err := keyXfmrHandler(inParams, xYangSpecMap[yangXpath].xfmrKey)
if err != nil {
retData.dbKey,retData.tableName,retData.xpath = "","",""
return retData, err
}
keyStr = ret
}
if xfmrTblKeyCache != nil {
if _, _ok := xfmrTblKeyCache[curPathWithKey]; !_ok {
xfmrTblKeyCache[curPathWithKey] = tblKeyCache{}
}
tkCache := xfmrTblKeyCache[curPathWithKey]
tkCache.dbKey = keyStr
xfmrTblKeyCache[curPathWithKey] = tkCache
}
}
} else if xYangSpecMap[yangXpath].keyName != nil {
keyStr += *xYangSpecMap[yangXpath].keyName
} else {
/* multi-leaf yang key together forms a single key-string in redis.
There should be key-transformer, if not then the yang key leaves
will be concatenated with respective default DB type key-delimiter
*/
for idx, kname := range rgpKeyExtract.FindAllString(k, -1) {
if idx > 0 { keyStr += keySeparator }
keyl := strings.TrimRight(strings.TrimLeft(kname, "["), "]")
keys := strings.Split(keyl, "=")
keyStr += keys[1]
}
}
} else if len(xYangSpecMap[yangXpath].xfmrKey) > 0 {
if xfmrTblKeyCache != nil {
if tkCache, _ok := xfmrTblKeyCache[curPathWithKey]; _ok {
if len(tkCache.dbKey) != 0 {
keyStr = tkCache.dbKey
callKeyXfmr = false
}
}
}
if callKeyXfmr {
xfmrFuncName := yangToDbXfmrFunc(xYangSpecMap[yangXpath].xfmrKey)
inParams := formXfmrInputRequest(d, dbs, cdb, ygRoot, curPathWithKey, requestUri, oper, "", nil, subOpDataMap, nil, txCache)
if oper == GET {
ret, err := XlateFuncCall(xfmrFuncName, inParams)
if err != nil {
retData.dbKey,retData.tableName,retData.xpath = "","",""
return retData, err
}
if ret != nil {
keyStr = ret[0].Interface().(string)
}
} else {
ret, err := keyXfmrHandler(inParams, xYangSpecMap[yangXpath].xfmrKey)
if ((yangType != YANG_LIST) && (err != nil)) {
retData.dbKey,retData.tableName,retData.xpath = "","",""
return retData, err
}
keyStr = ret
}
if xfmrTblKeyCache != nil {
if _, _ok := xfmrTblKeyCache[curPathWithKey]; !_ok {
xfmrTblKeyCache[curPathWithKey] = tblKeyCache{}
}
tkCache := xfmrTblKeyCache[curPathWithKey]
tkCache.dbKey = keyStr
xfmrTblKeyCache[curPathWithKey] = tkCache
}
}
} else if xYangSpecMap[yangXpath].keyName != nil {
keyStr += *xYangSpecMap[yangXpath].keyName
}
}
}
curPathWithKey = strings.TrimSuffix(curPathWithKey, "/")
if !strings.HasPrefix(curPathWithKey, "/") {
curPathWithKey = "/" + curPathWithKey
}
retData.dbKey = keyStr
tblPtr := xpathInfo.tableName
if tblPtr != nil && *tblPtr != XFMR_NONE_STRING {
retData.tableName = *tblPtr
} else if xpathInfo.xfmrTbl != nil {
inParams := formXfmrInputRequest(d, dbs, cdb, ygRoot, curPathWithKey, requestUri, oper, "", nil, subOpDataMap, nil, txCache)
if oper == GET {
inParams.dbDataMap = dbDataMap
}
retData.tableName, err = tblNameFromTblXfmrGet(*xpathInfo.xfmrTbl, inParams, xfmrTblKeyCache)
if inParams.isVirtualTbl != nil {
retData.isVirtualTbl = *(inParams.isVirtualTbl)
}
if err != nil && oper != GET {
return retData, err
}
}
if ((oper == SUBSCRIBE) && (strings.TrimSpace(keyStr) == "") && (requestUriYangType == YANG_LIST) && (!isUriForListInstance)) {
keyStr="*"
}
retData.dbKey = keyStr
xfmrLogInfoAll("Return uri(%v), xpath(%v), key(%v), tableName(%v), isVirtualTbl:%v", path, retData.xpath, keyStr, retData.tableName, retData.isVirtualTbl)
return retData, err
}
func dbTableFromUriGet(d *db.DB, ygRoot *ygot.GoStruct, oper int, uri string, requestUri string, subOpDataMap map[int]*RedisDbMap, txCache interface{}, xfmrTblKeyCache map[string]tblKeyCache) (string, error) {
tableName := ""
var err error
cdb := db.ConfigDB
var dbs [db.MaxDB]*db.DB
xPath, _, _ := XfmrRemoveXPATHPredicates(uri)
xpathInfo, ok := xYangSpecMap[xPath]
if !ok {
log.Warningf("No entry found in xYangSpecMap for xpath %v.", xPath)
return tableName, err
}
tblPtr := xpathInfo.tableName
if tblPtr != nil && *tblPtr != XFMR_NONE_STRING {
tableName = *tblPtr
} else if xpathInfo.xfmrTbl != nil {
inParams := formXfmrInputRequest(d, dbs, cdb, ygRoot, uri, requestUri, oper, "", nil, subOpDataMap, nil, txCache)
tableName, err = tblNameFromTblXfmrGet(*xpathInfo.xfmrTbl, inParams, xfmrTblKeyCache)
}
return tableName, err
}
func sonicXpathKeyExtract(path string) (string, string, string) {
xfmrLogInfoAll("In uri(%v)", path)
xpath, keyStr, tableName, fldNm := "", "", "", ""
var err error
lpath := path
xpath, _, err = XfmrRemoveXPATHPredicates(path)
if err != nil {
return xpath, keyStr, tableName
}
if xpath != "" {
fldPth := strings.Split(xpath, "/")
if len(fldPth) > SONIC_FIELD_INDEX {
fldNm = fldPth[SONIC_FIELD_INDEX]
xfmrLogInfoAll("Field Name : %v", fldNm)
}
}
pathsubStr := strings.Split(path , "/")
if len(pathsubStr) > SONIC_TABLE_INDEX {
if strings.Contains(pathsubStr[2], "[") {
tableName = strings.Split(pathsubStr[SONIC_TABLE_INDEX], "[")[0]
} else {
tableName = pathsubStr[SONIC_TABLE_INDEX]
}
dbInfo, ok := xDbSpecMap[tableName]
cdb := db.ConfigDB
if !ok {
xfmrLogInfoAll("No entry in xDbSpecMap for xpath %v in order to fetch DB index", tableName)
return xpath, keyStr, tableName
}
cdb = dbInfo.dbIndex
dbOpts := getDBOptions(cdb)
if dbInfo.keyName != nil {
keyStr = *dbInfo.keyName
} else {
/* chomp off the field portion to avoid processing specific item delete in leaf-list
eg. /sonic-acl:sonic-acl/ACL_TABLE/ACL_TABLE_LIST[aclname=MyACL2_ACL_IPV4]/ports[ports=Ethernet12]
*/
if fldNm != "" {
pathLst := splitUri(path)
xfmrLogInfoAll("pathList after uri split %v", pathLst)
lpath = "/" + strings.Join(pathLst[:SONIC_FIELD_INDEX-1], "/")
xfmrLogInfoAll("path after removing the field portion %v", lpath)
}
for i, kname := range rgpSncKeyExtract.FindAllString(lpath, -1) {
if i > 0 {
keyStr += dbOpts.KeySeparator
}
val := strings.Split(kname, "=")[1]
keyStr += strings.TrimRight(val, "]")
}
}
}
xfmrLogInfoAll("Return uri(%v), xpath(%v), key(%v), tableName(%v)", path, xpath, keyStr, tableName)
return xpath, keyStr, tableName
}
func getYangMdlToSonicMdlList(moduleNm string) []string {
var sncMdlList []string
if len(xDbSpecTblSeqnMap) == 0 {
xfmrLogInfo("xDbSpecTblSeqnMap is empty.")
return sncMdlList
}
if strings.HasPrefix(moduleNm, SONIC_MDL_PFX) {
sncMdlList = append(sncMdlList, moduleNm)
} else {
//can be optimized if there is a way to know sonic modules, a given OC-Yang spans over
for sncMdl := range(xDbSpecTblSeqnMap) {
sncMdlList = append(sncMdlList, sncMdl)
}
}
return sncMdlList
}
func yangFloatIntToGoType(t yang.TypeKind, v float64) (interface{}, error) {
switch t {
case yang.Yint8:
return int8(v), nil
case yang.Yint16:
return int16(v), nil
case yang.Yint32:
return int32(v), nil
case yang.Yuint8:
return uint8(v), nil
case yang.Yuint16:
return uint16(v), nil
case yang.Yuint32:
return uint32(v), nil
}
return nil, fmt.Errorf("unexpected YANG type %v", t)
}
func unmarshalJsonToDbData(schema *yang.Entry, fieldXpath string, fieldName string, value interface{}) (string, error) {
var data string
switch v := value.(type) {
case string:
return fmt.Sprintf("%v", v), nil
}
ykind := schema.Type.Kind
if ykind == yang.Yleafref {
ykind = getLeafrefRefdYangType(ykind, fieldXpath)
}
switch ykind {
case yang.Ystring, yang.Ydecimal64, yang.Yint64, yang.Yuint64,
yang.Yenum, yang.Ybool, yang.Ybinary, yang.Yidentityref, yang.Yunion:
data = fmt.Sprintf("%v", value)
case yang.Yint8, yang.Yint16, yang.Yint32,
yang.Yuint8, yang.Yuint16, yang.Yuint32:
pv, err := yangFloatIntToGoType(ykind, value.(float64))
if err != nil {
errStr := fmt.Sprintf("error parsing %v for schema %s: %v", value, schema.Name, err)
return "", tlerr.InternalError{Format: errStr}
}
data = fmt.Sprintf("%v", pv)
default:
// TODO - bitset, empty
data = fmt.Sprintf("%v", value)
}
return data, nil
}
func copyYangXpathSpecData(dstNode *yangXpathInfo, srcNode *yangXpathInfo) {
if dstNode != nil && srcNode != nil {
*dstNode = *srcNode
}
}
func isJsonDataEmpty(jsonData string) bool {
return string(jsonData) == "{}"
}
func getFileNmLineNumStr() string {
_, AbsfileName, lineNum, _ := runtime.Caller(2)
fileNmElems := strings.Split(AbsfileName, "/")
fileNm := fileNmElems[len(fileNmElems)-1]
fNmLnoStr := fmt.Sprintf("[%v:%v]", fileNm, lineNum)
return fNmLnoStr
}
func xfmrLogInfo(format string, args ...interface{}) {
fNmLnoStr := getFileNmLineNumStr()
log.Infof(fNmLnoStr + format, args...)
}
func xfmrLogInfoAll(format string, args ...interface{}) {
if log.V(5) {
fNmLnoStr := getFileNmLineNumStr()
log.Infof(fNmLnoStr + format, args...)
}
}
func formXfmrDbInputRequest(oper int, d db.DBNum, tableName string, key string, field string, value string) XfmrDbParams {
var inParams XfmrDbParams
inParams.oper = oper
inParams.dbNum = d
inParams.tableName = tableName
inParams.key = key
inParams.fieldName = field
inParams.value = value
return inParams
}
func hasKeyValueXfmr(tblName string) bool {
if specTblInfo, ok := xDbSpecMap[tblName]; ok {
for _, lname := range specTblInfo.listName {
listXpath := tblName + "/" + lname
if specListInfo, ok := xDbSpecMap[listXpath]; ok {
for _, key := range specListInfo.keyList {
keyXpath := tblName + "/" + key
if specKeyInfo, ok := xDbSpecMap[keyXpath]; ok {
if specKeyInfo.xfmrValue != nil {
return true
}
}
}
}
}
}
return false
}
func dbKeyValueXfmrHandler(oper int, dbNum db.DBNum, tblName string, dbKey string) (string, error) {
var err error
var keyValList []string
xfmrLogInfoAll("dbKeyValueXfmrHandler: oper(%v), db(%v), tbl(%v), dbKey(%v)",
oper, dbNum, tblName, dbKey)
if specTblInfo, ok := xDbSpecMap[tblName]; ok {
for _, lname := range specTblInfo.listName {
listXpath := tblName + "/" + lname
keyMap := make(map[string]interface{})
if specListInfo, ok := xDbSpecMap[listXpath]; ok && len(specListInfo.keyList) > 0 {
sonicKeyDataAdd(dbNum, specListInfo.keyList, tblName, dbKey, keyMap)
if len(keyMap) == len(specListInfo.keyList) {
for _, kname := range specListInfo.keyList {
keyXpath := tblName + "/" + kname
curKeyVal := fmt.Sprintf("%v", keyMap[kname])
if kInfo, ok := xDbSpecMap[keyXpath]; ok && xDbSpecMap[keyXpath].xfmrValue != nil {
inParams := formXfmrDbInputRequest(oper, dbNum, tblName, dbKey, kname, curKeyVal)
curKeyVal, err = valueXfmrHandler(inParams, *kInfo.xfmrValue)
if err != nil {
log.Warningf("value-xfmr: keypath(\"%v\") value (\"%v\"):err(%v).",
keyXpath, curKeyVal, err)
return "", err
}
}
keyValList = append(keyValList, curKeyVal)
}
}
}
}
}
dbOpts := getDBOptions(dbNum)
retKey := strings.Join(keyValList, dbOpts.KeySeparator)
xfmrLogInfoAll("dbKeyValueXfmrHandler: tbl(%v), dbKey(%v), retKey(%v), keyValList(%v)",
tblName, dbKey, retKey, keyValList)
return retKey, nil
}
func dbDataXfmrHandler(resultMap map[int]map[db.DBNum]map[string]map[string]db.Value) error {
xfmrLogInfoAll("Received resultMap(%v)", resultMap)
for oper, dbDataMap := range resultMap {
for dbNum, tblData := range dbDataMap {
for tblName, data := range tblData {
if specTblInfo, ok := xDbSpecMap[tblName]; ok && specTblInfo.hasXfmrFn {
skipKeySet := make(map[string]bool)
for dbKey, fldData := range data {
if _, ok := skipKeySet[dbKey]; !ok {
for fld, val := range fldData.Field {
fldName := fld
if strings.HasSuffix(fld, "@") {
fldName = strings.Split(fld, "@")[0]
}
/* check & invoke value-xfmr */
fldXpath := tblName + "/" + fldName
if fInfo, ok := xDbSpecMap[fldXpath]; ok && fInfo.xfmrValue != nil {
inParams := formXfmrDbInputRequest(oper, dbNum, tblName, dbKey, fld, val)
retVal, err := valueXfmrHandler(inParams, *fInfo.xfmrValue)
if err != nil {
log.Warningf("value-xfmr:fldpath(\"%v\") val(\"%v\"):err(\"%v\").",
fldXpath, val, err)
return err
}
resultMap[oper][dbNum][tblName][dbKey].Field[fld] = retVal
}
}
/* split tblkey and invoke value-xfmr if present */
if hasKeyValueXfmr(tblName) {
retKey, err := dbKeyValueXfmrHandler(oper, dbNum, tblName, dbKey)
if err != nil {
return err
}
/* cache processed keys */
skipKeySet[retKey] = true
if dbKey != retKey {
resultMap[oper][dbNum][tblName][retKey] = resultMap[oper][dbNum][tblName][dbKey]
delete(resultMap[oper][dbNum][tblName], dbKey)
}
}
}
}
}
}
}
}
xfmrLogInfoAll("Transformed resultMap(%v)", resultMap)
return nil
}
func formXlateFromDbParams(d *db.DB, dbs [db.MaxDB]*db.DB, cdb db.DBNum, ygRoot *ygot.GoStruct, uri string, requestUri string, xpath string, oper int, tbl string, tblKey string, dbDataMap *RedisDbMap, txCache interface{}, resultMap map[string]interface{}, validate bool) xlateFromDbParams {
var inParamsForGet xlateFromDbParams
inParamsForGet.d = d
inParamsForGet.dbs = dbs
inParamsForGet.curDb = cdb
inParamsForGet.ygRoot = ygRoot
inParamsForGet.uri = uri
inParamsForGet.requestUri = requestUri
inParamsForGet.xpath = xpath
inParamsForGet.oper = oper
inParamsForGet.tbl = tbl
inParamsForGet.tblKey = tblKey
inParamsForGet.dbDataMap = dbDataMap
inParamsForGet.txCache = txCache
inParamsForGet.resultMap = resultMap
inParamsForGet.validate = validate
return inParamsForGet
}
func formXlateToDbParam(d *db.DB, ygRoot *ygot.GoStruct, oper int, uri string, requestUri string, xpathPrefix string, keyName string, jsonData interface{}, resultMap map[int]RedisDbMap, result map[string]map[string]db.Value, txCache interface{}, tblXpathMap map[string]map[string]map[string]bool, subOpDataMap map[int]*RedisDbMap, pCascadeDelTbl *[]string, xfmrErr *error, name string, value interface{}, tableName string) xlateToParams {
var inParamsForSet xlateToParams
inParamsForSet.d = d
inParamsForSet.ygRoot = ygRoot
inParamsForSet.oper = oper
inParamsForSet.uri = uri
inParamsForSet.requestUri = requestUri
inParamsForSet.xpath = xpathPrefix
inParamsForSet.keyName = keyName
inParamsForSet.jsonData = jsonData
inParamsForSet.resultMap = resultMap
inParamsForSet.result = result
inParamsForSet.txCache = txCache.(*sync.Map)
inParamsForSet.tblXpathMap = tblXpathMap
inParamsForSet.subOpDataMap = subOpDataMap
inParamsForSet.pCascadeDelTbl = pCascadeDelTbl
inParamsForSet.xfmrErr = xfmrErr
inParamsForSet.name = name
inParamsForSet.value = value
inParamsForSet.tableName = tableName
return inParamsForSet
}
func xlateUnMarshallUri(ygRoot *ygot.GoStruct, uri string) (*interface{}, error) {
if len(uri) == 0 {
errMsg := errors.New("Error: URI is empty")
log.Warning(errMsg)
return nil, errMsg
}
path, err := ygot.StringToPath(uri, ygot.StructuredPath, ygot.StringSlicePath)
if err != nil {
return nil, err
}
for _, p := range path.Elem {
if strings.Contains(p.Name, ":") {
pathSlice := strings.Split(p.Name, ":")
p.Name = pathSlice[len(pathSlice)-1]
}
}
deviceObj := (*ygRoot).(*ocbinds.Device)
ygNode, _, errYg := ytypes.GetOrCreateNode(ocbSch.RootSchema(), deviceObj, path)
if errYg != nil {
log.Warning("Error in creating the target object: ", errYg)
return nil, errYg
}
return &ygNode, nil
}
func splitUri(uri string) []string {
pathList := SplitPath(uri)
xfmrLogInfoAll("uri: %v ", uri)
xfmrLogInfoAll("uri path elems: %v", pathList)
return pathList
}
func dbTableExists(d *db.DB, tableName string, dbKey string, oper int) (bool, error) {
var err error
// Read the table entry from DB
if len(tableName) > 0 {
if hasKeyValueXfmr(tableName) {
if oper == GET { //value tranformer callback decides based on oper type
oper = CREATE
}
retKey, err := dbKeyValueXfmrHandler(oper, d.Opts.DBNo, tableName, dbKey)
if err != nil {
return false, err
}
xfmrLogInfoAll("dbKeyValueXfmrHandler() returned db key %v", retKey)
dbKey = retKey
}
dbTblSpec := &db.TableSpec{Name: tableName}
if strings.Contains(dbKey, "*") {
keys, derr := d.GetKeysByPattern(dbTblSpec, dbKey)
if derr != nil {
log.Warningf("Failed to get keys for tbl(%v) dbKey pattern %v error: %v", tableName, dbKey, derr)
err = tlerr.NotFound("Resource not found")
return false, err
}
xfmrLogInfoAll("keys for table %v are %v", tableName, keys)
if len(keys) > 0 {
return true, nil
} else {
log.Warningf("dbKey %v does not exist in DB for table %v", dbKey, tableName)
err = tlerr.NotFound("Resource not found")
return false, err
}
} else {
existingEntry, derr := d.GetEntry(dbTblSpec, db.Key{Comp: []string{dbKey}})
if derr != nil {
log.Warningf("GetEntry failed for table: %v, key: %v err: %v", tableName, dbKey, derr)
err = tlerr.NotFound("Resource not found")
return false, err
}
return existingEntry.IsPopulated(), err
}
} else {
log.Warning("Empty table name received")
return false, nil
}
}
func dbTableExistsInDbData(dbNo db.DBNum, table string, dbKey string, dbData RedisDbMap) bool {
xfmrLogInfoAll("received Db no - %v, table - %v, dbkey - %v", dbNo, table, dbKey)
if _, exists := dbData[dbNo][table][dbKey]; exists {
return true
} else {
return false
}
}
func leafListInstExists(leafListInDbVal string, checkLeafListInstVal string) bool {
/*function to check if leaf-list DB value contains the given instance*/
exists := false
xfmrLogInfoAll("received value of leaf-list in DB - %v, Value to be checked if exists in leaf-list - %v", leafListInDbVal, checkLeafListInstVal)
leafListItemLst := strings.Split(leafListInDbVal, ",")
for idx := range(leafListItemLst) {
if leafListItemLst[idx] == checkLeafListInstVal {
exists = true
xfmrLogInfoAll("Leaf-list instance exists")
break
}
}
return exists
}
func extractLeafListInstFromUri(uri string) (string, error) {
/*function to extract leaf-list instance value coming as part of uri
Handling [ ] in value*/
xfmrLogInfoAll("received uri - %v", uri)
var leafListInstVal string
yangType := ""
err := fmt.Errorf("Unable to extract leaf-list instance value for uri - %v", uri)
xpath, _, xerr := XfmrRemoveXPATHPredicates(uri)
if !isSonicYang(uri) {
specInfo, ok := xYangSpecMap[xpath]
if !ok {
return leafListInstVal, xerr
}
yangType = yangTypeGet(specInfo.yangEntry)
if !(yangType == YANG_LEAF_LIST) {
return leafListInstVal, err
}
} else {
tokens:= strings.Split(xpath, "/")
fieldName := ""
tableName := ""
if len(tokens) > SONIC_FIELD_INDEX {
fieldName = tokens[SONIC_FIELD_INDEX]
tableName = tokens[SONIC_TABLE_INDEX]
}
dbSpecField := tableName + "/" + fieldName
_, ok := xDbSpecMap[dbSpecField]
if ok {
yangType := xDbSpecMap[dbSpecField].fieldType
// terminal node case
if !(yangType == YANG_LEAF_LIST) {
return leafListInstVal, err
}
}
}
//Check if uri has Leaf-list value
if ((strings.HasSuffix(uri, "]")) || (strings.HasSuffix(uri, "]/"))) {
xpathList := strings.Split(xpath, "/")
ll_name := xpathList[len(xpathList)-1]
ll_inx := strings.LastIndex(uri,ll_name)
if ll_inx != -1 {
ll_value := uri[ll_inx:]
ll_value = strings.TrimSuffix(ll_value, "]")
valueLst := strings.SplitN(ll_value, "=", 2)
leafListInstVal = valueLst[1]
if ((strings.Contains(leafListInstVal, ":")) && (strings.HasPrefix(leafListInstVal, OC_MDL_PFX) || strings.HasPrefix(leafListInstVal, IETF_MDL_PFX) || strings.HasPrefix(leafListInstVal, IANA_MDL_PFX))) {
// identity-ref/enum has module prefix
leafListInstVal = strings.SplitN(leafListInstVal, ":", 2)[1]
xfmrLogInfoAll("Leaf-list instance value after removing identityref prefix - %v", leafListInstVal)
}
xfmrLogInfoAll("Leaf-list instance value to be returned - %v", leafListInstVal)
return leafListInstVal, nil
}
}
return leafListInstVal, err
}
|
package piscine
func BasicJoin(strs []string) string {
//empty string
strJoin := ""
for _, element := range strs {
strJoin = strJoin + element
}
return strJoin
}
|
package relay
import (
"context"
"crypto/tls"
"fmt"
"strings"
"sync"
"time"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
"github.com/batchcorp/collector-schemas/build/go/protos/services"
"github.com/batchcorp/plumber-schemas/build/go/protos/records"
sqsTypes "github.com/batchcorp/plumber/backends/awssqs/types"
azuresbTypes "github.com/batchcorp/plumber/backends/azure-servicebus/types"
mongoTypes "github.com/batchcorp/plumber/backends/cdcmongo/types"
postgresTypes "github.com/batchcorp/plumber/backends/cdcpostgres/types"
gcpTypes "github.com/batchcorp/plumber/backends/gcppubsub/types"
kafkaTypes "github.com/batchcorp/plumber/backends/kafka/types"
kubemqTypes "github.com/batchcorp/plumber/backends/kubemq-queue/types"
mqttTypes "github.com/batchcorp/plumber/backends/mqtt/types"
natsJetStreamTypes "github.com/batchcorp/plumber/backends/nats-jetstream/types"
natsStreamingTypes "github.com/batchcorp/plumber/backends/nats-streaming/types"
natsTypes "github.com/batchcorp/plumber/backends/nats/types"
nsqTypes "github.com/batchcorp/plumber/backends/nsq/types"
rabbitTypes "github.com/batchcorp/plumber/backends/rabbitmq/types"
rpubsubTypes "github.com/batchcorp/plumber/backends/rpubsub/types"
rstreamsTypes "github.com/batchcorp/plumber/backends/rstreams/types"
"github.com/batchcorp/plumber/prometheus"
"github.com/batchcorp/plumber/validate"
)
const (
// DefaultNumWorkers is the number of goroutine relay workers to launch
DefaultNumWorkers = 10
// QueueFlushInterval is how often to flush messages to GRPC collector if we don't reach the batch size
QueueFlushInterval = 10 * time.Second
// DefaultBatchSize is the number of messages to send to GRPC collector in each batch
DefaultBatchSize = 100 // number of messages to batch
// MaxGRPCRetries is the number of times we will attempt a GRPC call before giving up
MaxGRPCRetries = 5
// MaxGRPCMessageSize is the maximum message size for GRPC client in bytes
MaxGRPCMessageSize = 1024 * 1024 * 100 // 100MB
// GRPCRetrySleep determines how long we sleep between GRPC call retries
GRPCRetrySleep = time.Second * 5
)
var (
ErrMissingConfig = errors.New("Relay config cannot be nil")
ErrMissingToken = errors.New("Token cannot be empty")
ErrMissingServiceShutdownCtx = errors.New("ServiceShutdownCtx cannot be nil")
ErrMissingGRPCAddress = errors.New("GRPCAddress cannot be empty")
ErrMissingRelayCh = errors.New("RelayCh cannot be nil")
ErrMissingMessage = errors.New("msg cannot be nil")
ErrMissingMessageValue = errors.New("msg.Value cannot be nil")
ErrMissingMessageOptions = errors.New("msg.Options cannot be nil")
)
type IRelayBackend interface {
Relay() error
}
type Relay struct {
*Config
Workers map[int32]struct{}
WorkersMutex *sync.RWMutex
log *logrus.Entry
}
type Config struct {
Token string
GRPCAddress string
NumWorkers int32
BatchSize int32
RelayCh chan interface{}
ErrorCh chan *records.ErrorRecord
DisableTLS bool
Timeout time.Duration // general grpc timeout (used for all grpc calls)
Type string
ServiceShutdownCtx context.Context
MainShutdownFunc context.CancelFunc
MainShutdownCtx context.Context
DeadLetter bool
}
// New creates a new instance of the Relay
func New(relayCfg *Config) (*Relay, error) {
if err := validateConfig(relayCfg); err != nil {
return nil, errors.Wrap(err, "unable to complete relay config validation")
}
// Verify grpc connection & token
if err := TestConnection(relayCfg); err != nil {
return nil, errors.Wrap(err, "unable to complete connection test")
}
return &Relay{
Config: relayCfg,
Workers: make(map[int32]struct{}),
WorkersMutex: &sync.RWMutex{},
log: logrus.WithField("pkg", "relay"),
}, nil
}
func validateConfig(cfg *Config) error {
if cfg == nil {
return ErrMissingConfig
}
if cfg.Token == "" {
return ErrMissingToken
}
if cfg.GRPCAddress == "" {
cfg.GRPCAddress = validate.GRPCCollectorAddress
}
if cfg.Timeout == 0 {
cfg.Timeout = validate.GRPCDefaultTimeoutSeconds * time.Second
}
if cfg.RelayCh == nil {
return ErrMissingRelayCh
}
if cfg.ServiceShutdownCtx == nil {
return ErrMissingServiceShutdownCtx
}
if cfg.NumWorkers <= 0 {
logrus.Warningf("NumWorkers cannot be <= 0 - setting to default '%d'", DefaultNumWorkers)
cfg.NumWorkers = DefaultNumWorkers
}
if cfg.BatchSize == 0 {
cfg.BatchSize = DefaultBatchSize
}
return nil
}
func TestConnection(cfg *Config) error {
conn, ctx, err := NewConnection(cfg.GRPCAddress, cfg.Token, cfg.Timeout, cfg.DisableTLS, false)
if err != nil {
return errors.Wrap(err, "unable to create new connection")
}
// Call the Test method to verify connectivity
c := services.NewGRPCCollectorClient(conn)
if _, err := c.Test(ctx, &services.TestRequest{}); err != nil {
return errors.Wrap(err, "unable to complete Test request")
}
return nil
}
func NewConnection(address, token string, timeout time.Duration, disableTLS, noCtx bool) (*grpc.ClientConn, context.Context, error) {
opts := []grpc.DialOption{
grpc.WithBlock(),
}
if !disableTLS {
opts = append(opts, grpc.WithTransportCredentials(credentials.NewTLS(
&tls.Config{
InsecureSkipVerify: true,
},
)))
} else {
opts = append(opts, grpc.WithInsecure())
}
dialContext, _ := context.WithTimeout(context.Background(), timeout)
conn, err := grpc.DialContext(dialContext, address, opts...)
if err != nil {
return nil, nil, fmt.Errorf("unable to connect to grpc address '%s': %s", address, err)
}
var ctx context.Context
if !noCtx {
ctx, _ = context.WithTimeout(context.Background(), timeout)
} else {
ctx = context.Background()
}
md := metadata.Pairs("streamdal-token", token)
outCtx := metadata.NewOutgoingContext(ctx, md)
return conn, outCtx, nil
}
// WaitForShutdown will wait for service shutdown context to be canceled. It will then start constantly polling
// the workers map until it is empty. When the workers map is empty, MainShutdownFunc() is called allowing the
// application to exit gracefully and ensuring we have sent all relay messages to the grpc-collector
func (r *Relay) WaitForShutdown() {
// Don't start looping until we are in shutdown mode
<-r.ServiceShutdownCtx.Done()
r.log.Debugf("Waiting for relay workers to shut down")
for {
r.WorkersMutex.RLock()
if len(r.Workers) == 0 {
r.WorkersMutex.RUnlock()
r.log.Debug("All relay workers shutdown, exiting application")
r.MainShutdownFunc()
return
}
r.WorkersMutex.RUnlock()
time.Sleep(time.Millisecond * 100)
}
}
// removeWorker removes a worker from the workers map so we can track when all workers have shut down
func (r *Relay) removeWorker(id int32) {
r.WorkersMutex.Lock()
defer r.WorkersMutex.Unlock()
delete(r.Workers, id)
}
// addWorker adds a worker ID to the workers map
func (r *Relay) addWorker(id int32) {
r.WorkersMutex.Lock()
defer r.WorkersMutex.Unlock()
r.Workers[id] = struct{}{}
}
func (r *Relay) StartWorkers(shutdownCtx context.Context) error {
for i := int32(0); i != r.Config.NumWorkers; i++ {
r.log.WithField("workerId", i).Debug("starting worker")
conn, outboundCtx, err := NewConnection(r.Config.GRPCAddress, r.Config.Token, r.Config.Timeout, r.Config.DisableTLS, true)
if err != nil {
return fmt.Errorf("unable to create new gRPC connection for worker %d: %s", i, err)
}
go r.Run(i, conn, outboundCtx, shutdownCtx)
}
return nil
}
// Run is a GRPC worker that runs as a goroutine. outboundCtx is used for sending GRPC requests as it will contain
// metadata, specifically "batch-token". shutdownCtx is passed from the main plumber app to shut down workers
// TODO: This should also read from errorCh
func (r *Relay) Run(id int32, conn *grpc.ClientConn, outboundCtx, shutdownCtx context.Context) {
llog := r.log.WithField("relayId", id)
r.addWorker(id)
llog.Debug("Relayer started")
queue := make([]interface{}, 0)
// This functions as an escape-vale -- if we are pumping messages *REALLY*
// fast - we will hit max queue size; if we are pumping messages slowly,
// the ticker will be hit and the queue will be flushed, regardless of size.
flushTicker := time.NewTicker(QueueFlushInterval)
// These are only here to provide immediate feedback that stats are enabled
prometheus.Incr(r.Config.Type+"-relay-consumer", 0)
prometheus.Incr(r.Config.Type+"-relay-producer", 0)
var quit bool
for {
select {
case msg := <-r.Config.RelayCh:
queue = append(queue, msg)
// Max queue size reached
if len(queue) >= int(r.Config.BatchSize) {
llog.Debugf("%d: max queue size reached - flushing!", id)
r.flush(outboundCtx, conn, queue...)
// Reset queue; since we passed by variadic, the underlying slice can be updated
queue = make([]interface{}, 0)
// Reset ticker (so time-based flush doesn't occur)
flushTicker.Reset(QueueFlushInterval)
// queue is empty, safe to quit
if quit {
llog.Debug("queue empty, worker exiting")
r.removeWorker(id)
return
}
}
case <-flushTicker.C:
if len(queue) != 0 {
llog.Debugf("%d: flush ticker hit and queue not empty - flushing!", id)
r.flush(outboundCtx, conn, queue...)
// Reset queue; same as above - safe to delete queue contents
queue = make([]interface{}, 0)
}
// queue is empty, safe to quit
if quit {
llog.Debug("queue empty, worker exiting")
r.removeWorker(id)
return
}
case <-shutdownCtx.Done():
if quit == true {
// Prevent log spam
time.Sleep(time.Millisecond * 50)
continue
}
llog.Debug("Shutdown signal received")
// If queue is empty, quit immediately
if len(queue) == 0 {
llog.Debug("queue empty, worker exiting")
r.removeWorker(id)
return
}
quit = true
}
}
}
func (r *Relay) flush(ctx context.Context, conn *grpc.ClientConn, messages ...interface{}) {
if len(messages) < 1 {
r.log.Error("asked to flush empty message queue - bug?")
return
}
// We only care about the first message since plumber can only be using
// one message bus type at a time
var err error
// TODO: Need to get away from the switch type flow ~ds 09.11.21
switch v := messages[0].(type) {
case *kubemqTypes.RelayMessage:
r.log.Debugf("flushing %d kubemq message(s)", len(messages))
err = r.handleKubeMQ(ctx, conn, messages)
case *sqsTypes.RelayMessage:
r.log.Debugf("flushing %d sqs message(s)", len(messages))
err = r.handleSQS(ctx, conn, messages)
case *rabbitTypes.RelayMessage:
r.log.Debugf("flushing %d rabbit message(s)", len(messages))
err = r.handleRabbit(ctx, conn, messages)
case *kafkaTypes.RelayMessage:
r.log.Debugf("flushing %d kafka message(s)", len(messages))
err = r.handleKafka(ctx, conn, messages)
case *azuresbTypes.RelayMessage:
r.log.Debugf("flushing %d azure message(s)", len(messages))
err = r.handleAzure(ctx, conn, messages)
case *gcpTypes.RelayMessage:
r.log.Debugf("flushing %d gcp message(s)", len(messages))
err = r.handleGCP(ctx, conn, messages)
case *mongoTypes.RelayMessage:
r.log.Debugf("flushing %d mongo message(s)", len(messages))
err = r.handleCDCMongo(ctx, conn, messages)
case *rpubsubTypes.RelayMessage:
r.log.Debugf("flushing %d redis-pubsub message(s)", len(messages))
err = r.handleRedisPubSub(ctx, conn, messages)
case *mqttTypes.RelayMessage:
r.log.Debugf("flushing %d mqtt message(s)", len(messages))
err = r.handleMQTT(ctx, conn, messages)
case *rstreamsTypes.RelayMessage:
r.log.Debugf("flushing %d redis-streams message(s)", len(messages))
err = r.handleRedisStreams(ctx, conn, messages)
case *postgresTypes.RelayMessage:
r.log.Debugf("flushing %d cdc-postgres message(s)", len(messages))
err = r.handleCdcPostgres(ctx, conn, messages)
case *nsqTypes.RelayMessage:
r.log.Debugf("flushing %d nsq message(s)", len(messages))
err = r.handleNSQ(ctx, conn, messages)
case *natsTypes.RelayMessage:
r.log.Debugf("flushing %d nats message(s)", len(messages))
err = r.handleNATS(ctx, conn, messages)
case *natsStreamingTypes.RelayMessage:
r.log.Debugf("flushing %d nats message(s)", len(messages))
err = r.handleNATSStreaming(ctx, conn, messages)
case *natsJetStreamTypes.RelayMessage:
r.log.Debugf("flushing %d nats message(s)", len(messages))
err = r.handleNATSJetStream(ctx, conn, messages)
default:
r.log.WithField("type", v).Error("received unknown message type - skipping")
return
}
if err != nil {
r.log.WithField("err", err).Error("unable to handle message")
return
}
numMsgs := len(messages)
prometheus.Incr(r.Config.Type+"-relay-producer", numMsgs)
prometheus.IncrPromCounter("plumber_relay_total", numMsgs)
}
// CallWithRetry will retry a GRPC call until it succeeds or reaches a maximum number of retries defined by MaxGRPCRetries
func (r *Relay) CallWithRetry(ctx context.Context, method string, publish func(ctx context.Context) error) error {
var err error
for i := 1; i <= MaxGRPCRetries; i++ {
err = publish(ctx)
if err != nil {
prometheus.IncrPromCounter("plumber_grpc_errors", 1)
// Paused collection, retries will fail, exit early
if strings.Contains(err.Error(), "collection is paused") {
return err
}
r.log.Debugf("unable to complete %s call [retry %d/%d]", method, i, 5)
time.Sleep(GRPCRetrySleep)
continue
}
r.log.Debugf("successfully handled %s message", strings.Replace(method, "Add", "", 1))
return nil
}
return fmt.Errorf("unable to complete %s call [reached max retries (%d)]: %s", method, MaxGRPCRetries, err)
}
|
package main
import "fmt"
func computePowerSet(nums []int, pos int, setSoFar []int, results [][]int) [][]int {
if pos >= len(nums) {
resultSet := make([]int, len(setSoFar))
copy(resultSet, setSoFar)
return append(results, resultSet)
}
// Case 1: move forward, excluding nums[pos]
tempSetWithoutPos := make([]int, len(setSoFar))
copy(tempSetWithoutPos, setSoFar)
newResults := computePowerSet(nums, pos+1, tempSetWithoutPos, results)
// Case 2: move forwawrd, including nums[pos]
tempSetWithPos := []int{}
tempSetWithPos = append(tempSetWithPos, setSoFar...)
tempSetWithPos = append(tempSetWithPos, nums[pos])
newResults = computePowerSet(nums, pos+1, tempSetWithPos, newResults)
return newResults
}
func subsets(nums []int) [][]int {
return computePowerSet(nums, 0, []int{}, [][]int{})
}
func test1() {
results := subsets([]int{1, 2, 3})
fmt.Printf("power set: %v\n", results)
}
func test2() {
results := subsets([]int{})
fmt.Printf("power set: %v\n", results)
}
func test3() {
results := subsets([]int{1})
fmt.Printf("power set: %v\n", results)
}
func main() {
test1()
test2()
test3()
}
|
package main
import (
"fmt"
)
//go中的字符串都是采用UTF-8编码，字符串是用一对双引号（""）或者反引号（``）括起来的。
//不赋值时，默认为空字符串。
func main() {
var emptyString string = "asdfdf"
fmt.Printf(emptyString)
var s string = "hello"
//在go中字符串是不可变的，如下会报错
// s[0] = 'c'
//如果想改需要转化成byte数组
c := []byte(s) // 将字符串 s 转换为 []byte 类型
c[0] = 'c'
s2 := string(c) // 再转换回 string 类型
fmt.Printf("%s\n", s2)
//字符串虽不能修改，但可以做切片操作。
s = "hello"
s = "c" + s[1:]
fmt.Printf("%s\n", s)
}
|
// Copyright 2017 Google Inc. 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 distributor
import (
"encoding/json"
"os"
"strings"
"golang.org/x/net/context"
"golang.org/x/oauth2/google"
"google.golang.org/api/compute/v1"
"google.golang.org/appengine"
"google.golang.org/appengine/log"
"google.golang.org/appengine/memcache"
)
const cachekey = "LoadNodeList"
// LoadNode is a struct that contains the only fields we need from LoadNode's.
type LoadNode struct {
Name string `json:"Name"`
IP string `json:"ip"`
}
func List(c context.Context) ([]LoadNode, error) {
lns, err := getFromCache(c)
if err == nil {
return lns, nil
}
lns, err = getFromProject(c)
if err = cache(c, lns); err != nil {
log.Warningf(c, "Could not cache the VM list: "+err.Error())
}
return lns, nil
}
func getFromCache(c context.Context) ([]LoadNode, error) {
var lns []LoadNode
item, err := memcache.Get(c, cachekey)
if err != nil {
return nil, err
}
err = json.Unmarshal(item.Value, &lns)
return lns, err
}
func getFromProject(c context.Context) ([]LoadNode, error) {
client, err := google.DefaultClient(c, compute.ComputeScope)
if err != nil {
return nil, err
}
srv, err := compute.New(client)
if err != nil {
return nil, err
}
ins, err := srv.Instances.List(appengine.AppID(c), os.Getenv("ZONE")).Do()
if err != nil {
return nil, err
}
log.Debugf(c, "Response from service: %v", ins.Items)
var lns []LoadNode
for _, i := range ins.Items {
if strings.Index(i.Name, "gke-"+os.Getenv("LOAD_CLUSTER")+"-") != 0 {
continue
}
lns = append(lns, LoadNode{i.Name, publicIP(i)})
}
return lns, nil
}
func publicIP(instance *compute.Instance) string {
for _, network := range instance.NetworkInterfaces {
for _, cfg := range network.AccessConfigs {
if cfg.Name == "external-nat" {
return cfg.NatIP
}
}
}
return ""
}
func cache(c context.Context, lns []LoadNode) error {
b, err := json.Marshal(lns)
if err != nil {
return err
}
item := &memcache.Item{
Key: cachekey,
Value: b,
}
return memcache.Set(c, item)
}
|
package quantum
// A CircuitGen generates exhaustive lists of circuits.
//
// It is not safe to call methods on a CircuitGen from
// multiple Goroutines concurrently.
type CircuitGen struct {
numBits int
basis []Gate
hasher CircuitHasher
cache [][]Circuit
cacheRemaining int
}
// NewCircuitGen creates a new circuit generator.
//
// The maxCache argument specifies how many circuits the
// generator may store in memory to increase efficiency
// and reduce duplicates.
func NewCircuitGen(numBits int, basis []Gate, maxCache int) *CircuitGen {
return &CircuitGen{
numBits: numBits,
basis: basis,
hasher: NewCircuitHasher(numBits),
cache: [][]Circuit{[]Circuit{Circuit{}}},
cacheRemaining: maxCache,
}
}
// GenerateSlice uses the circuit cache to provide an
// in-memory list of all the circuits of a given size.
//
// If all the circuits do not fit into memory, this
// returns nil.
func (c *CircuitGen) GenerateSlice(numGates int) []Circuit {
for len(c.cache) <= numGates && c.cacheRemaining > 0 {
c.extendCache()
}
if numGates >= len(c.cache) {
return nil
}
return c.cache[numGates]
}
// Generate generates a (possibly redundant) sequence of
// circuits of a given size.
func (c *CircuitGen) Generate(numGates int) (<-chan Circuit, int) {
for len(c.cache) <= numGates && c.cacheRemaining > 0 {
c.extendCache()
}
ch := make(chan Circuit, 10)
if numGates < len(c.cache) {
go func() {
defer close(ch)
for _, circ := range c.cache[numGates] {
ch <- circ
}
}()
return ch, len(c.cache[numGates])
}
subCh, subCount := c.Generate(numGates - len(c.cache) + 1)
go func() {
defer close(ch)
for subCirc := range subCh {
for _, circ := range c.cache[len(c.cache)-1] {
ch <- append(append(Circuit{}, subCirc...), circ...)
}
}
}()
return ch, subCount * len(c.cache[len(c.cache)-1])
}
func (c *CircuitGen) extendCache() bool {
var next []Circuit
found := map[CircuitHash]bool{}
for _, prevCirc := range c.cache[len(c.cache)-1] {
for _, gate := range c.basis {
circ := append(Circuit{gate}, prevCirc...)
hash := c.hasher.Hash(circ)
if !found[hash] {
found[hash] = true
next = append(next, circ)
c.cacheRemaining -= 1
if c.cacheRemaining == 0 {
return false
}
}
}
}
c.cache = append(c.cache, next)
return true
}
// A BackwardsMap keeps track of the latter half of
// circuits for a bidirectional search.
type BackwardsMap struct {
hasher CircuitHasher
backHasher CircuitHasher
goal CircuitHash
m map[CircuitHash]Gate
}
// NewBackwardsMap creates a BackwardsMap that operates
// with respect to the end state achieved by a goal.
//
// It uses the hasher c for internal logic.
func NewBackwardsMap(c CircuitHasher, goal Gate) *BackwardsMap {
return &BackwardsMap{
hasher: c,
backHasher: c.Prefix(goal),
goal: c.Hash(goal),
m: map[CircuitHash]Gate{},
}
}
// AddCircuit adds the circuit to the reverse mapping.
// Circuits should be added in order of size.
func (b *BackwardsMap) AddCircuit(c Circuit) {
backHash := b.backHasher.Hash(c.Inverse())
if _, ok := b.m[backHash]; !ok {
b.m[backHash] = c[0]
}
}
// Lookup finds the shortest suffix to complete the given
// prefix of the solution.
//
// If no circuit is found, nil is returned.
func (b *BackwardsMap) Lookup(prefix Gate) Circuit {
var res Circuit
hasher := b.hasher.Prefix(prefix)
h := hasher.Hash(Circuit{})
for h != b.goal {
if g, ok := b.m[h]; !ok {
return nil
} else {
res = append(res, g)
hasher = hasher.Prefix(g)
h = hasher.Hash(Circuit{})
}
}
return res
}
|
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
package operations
import (
"testing"
"github.com/Azure/aks-engine/pkg/armhelpers"
. "github.com/Azure/aks-engine/pkg/test"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
log "github.com/sirupsen/logrus"
)
func TestOperations(t *testing.T) {
RunSpecsWithReporters(t, "operations", "Server Suite")
}
var _ = Describe("Scale down vms operation tests", func() {
It("Should return error messages for failing vms", func() {
mockClient := armhelpers.MockAKSEngineClient{}
mockClient.FailGetVirtualMachine = true
errs := ScaleDownVMs(&mockClient, log.NewEntry(log.New()), "sid", "rg", "vm1", "vm2", "vm3", "vm5")
Expect(errs.Len()).To(Equal(4))
for e := errs.Front(); e != nil; e = e.Next() {
output := e.Value.(*VMScalingErrorDetails)
Expect(output.Name).To(ContainSubstring("vm"))
Expect(output.Error).To(Not(BeNil()))
}
})
It("Should return nil for errors if all deletes successful", func() {
mockClient := armhelpers.MockAKSEngineClient{}
errs := ScaleDownVMs(&mockClient, log.NewEntry(log.New()), "sid", "rg", "k8s-agent-F8EADCCF-0", "k8s-agent-F8EADCCF-3", "k8s-agent-F8EADCCF-2", "k8s-agent-F8EADCCF-4")
Expect(errs).To(BeNil())
})
})
|
package spec
type AReq struct {
X int `json:"x"`
Y int `json:"y"`
}
type ARes struct {
StatusCode string `json:"statusCode"`
Result int `json:"result"`
}
type LogAReq struct {
LogTime JSONTime `json:"logTime"`
Info string `json:"info"`
Req string `json:"requestBody"`
}
type LogARes struct {
LogTime JSONTime `json:"logTime"`
Info string `json:"info"`
Res string `json:"responseBody"`
Overhead int64 `json:"overhead"`
}
|
package objs
type Configuration struct {
// 시스템
DataRetentionDays int `form:"data_retention_days"`
// 로그인
MaxFailedLoginAttempts int `form:"max_failed_login_attempts"`
LoginFailureBlockTime int `form:"login_failure_block_time"`
}
|
package models
import (
"time"
"github.com/jinzhu/gorm"
)
//Login 登录
type Login struct {
UserName string
Password string
}
//QueryBill 查询流水
type QueryBill struct {
InBill bool //元征账户进账流水
StartTime int64 //开始时间
EndTime int64 //结束时间
}
//IncomeStatement 收入流水
type IncomeStatement struct {
gorm.Model
OrderType int64 `json:"order_type" gorm:"column:order_type;index:income_statement"` // 订单类型，0:支付宝，1:微信
AlipaySeller string `json:"-" gorm:"column:alipay_seller"` // 商家账户
BuyerLogonID string `json:"buyer_logon_id" gorm:"column:buyer_logon_id"` // 买家支付宝账号
BuyerPayAmount float64 `json:"buyer_pay_amount" gorm:"column:buyer_pay_amount"` // 买家实付金额，单位为元，两位小数。
BuyerUserID string `json:"buyer_user_id" gorm:"column:buyer_user_id"` // 买家在支付宝的用户id
BuyerUserType string `json:"buyer_user_type" gorm:"column:buyer_user_type"` // 买家用户类型。CORPORATE:企业用户；PRIVATE:个人用户。
InvoiceAmount float64 `json:"invoice_amount" gorm:"column:invoice_amount"` // 交易中用户支付的可开具发票的金额，单位为元，两位小数。
OutTradeNo string `json:"out_trade_no" gorm:"column:out_trade_no"` // 商家订单号
PointAmount float64 `json:"point_amount" gorm:"column:point_amount"` // 积分支付的金额，单位为元，两位小数。
ReceiptAmount float64 `json:"receipt_amount" gorm:"column:receipt_amount"` // 实收金额，单位为元，两位小数
SendPayDate int64 `json:"send_pay_date" gorm:"column:send_pay_date"` // 本次交易打款给卖家的时间
TotalAmount float64 `json:"total_amount" gorm:"column:total_amount"` // 交易的订单金额
Fees float64 `json:"fees" gorm:"column:fees"` //交易手续费
Arrears float64 `json:"arrears" gorm:"column:arrears"` // 欠款详情
TradeNo string `json:"trade_no" gorm:"column:trade_no;index:income_statement;unique_index"` // 支付宝交易号
SubAccountNo string `json:"sub_account_no" gorm:"column:sub_account_no"` //分账信息编号
PayerName string `json:"payer_name" gorm:"column:payer_name"` // 付款方
AutoTransfer uint8 `json:"auto_transfer" gorm:"column:auto_transfer"` //是否自动打款 0否，1是，默认是1
Hash string `json:"hash" gorm:"column:hash"` //上链Hash
BlockchainStatus uint8 `json:"blockchain_status" gorm:"column:blockchain_status"` //交易流水是否上链
OnchainTime int64 `json:"on_chain_time" gorm:"column:on_chain_time"` //交易流水上链时间
OnchainNum int64 `json:"on_chain_num" gorm:"column:on_chain_num"` // 重试上链次数
//AuthTradePayMode string // 预授权支付模式，该参数仅在信用预授权支付场景下返回。信用预授权支付：CREDIT_PREAUTH_PAY
}
//ExpensesBill 支出流水
type ExpensesBill struct {
gorm.Model
OrderType int64 `json:"order_type" gorm:"column:order_type;index:expenses_bill"` // 订单类型，0:支付宝，1:微信
AlipaySeller string `json:"-" gorm:"column:alipay_seller"` // 商家账户
BuyerLogonID string `json:"buyer_logon_id" gorm:"column:buyer_logon_id"` // 买家支付宝账号
BuyerPayAmount float64 `json:"buyer_pay_amount" gorm:"column:buyer_pay_amount"` // 买家实付金额，单位为元，两位小数。
BuyerUserID string `json:"buyer_user_id" gorm:"column:buyer_user_id"` // 买家在支付宝的用户id
BuyerUserType string `json:"buyer_user_type" gorm:"column:buyer_user_type"` // 买家用户类型。CORPORATE:企业用户；PRIVATE:个人用户。
InvoiceAmount float64 `json:"invoice_amount" gorm:"column:invoice_amount"` // 交易中用户支付的可开具发票的金额，单位为元，两位小数。
OutTradeNo string `json:"out_trade_no" gorm:"column:out_trade_no"` // 商家订单号
PointAmount float64 `json:"point_amount" gorm:"column:point_amount"` // 积分支付的金额，单位为元，两位小数。
ReceiptAmount float64 `json:"receipt_amount" gorm:"column:receipt_amount"` // 实收金额，单位为元，两位小数
SendPayDate int64 `json:"send_pay_date" gorm:"column:send_pay_date"` // 本次交易打款给卖家的时间
TotalAmount float64 `json:"total_amount" gorm:"column:total_amount"` // 交易的订单金额
Fees float64 `json:"fees" gorm:"column:fees"` //交易手续费
Arrears float64 `json:"arrears" gorm:"column:arrears"` // 欠款详情
TradeNo string `json:"trade_no" gorm:"column:trade_no;index:expenses_bill;unique_index"` // 支付宝交易号
SubAccountNo string `json:"sub_account_no" gorm:"column:sub_account_no"` //分账信息编号
PayerName string `json:"payer_name" gorm:"column:payer_name"` // 付款方
AutoTransfer uint8 `json:"auto_transfer" gorm:"column:auto_transfer"` //是否自动打款 0否，1是，默认是1
Hash string `json:"hash" gorm:"column:hash"` //上链Hash
TradeStatus uint8 `json:"trade_status" gorm:"column:trade_status"` // 交易状态
//AuthTradePayMode string // 预授权支付模式，该参数仅在信用预授权支付场景下返回。信用预授权支付：CREDIT_PREAUTH_PAY
}
//UserBill 用户分账信息
type UserBill struct {
gorm.Model
OrderType int64 `json:"order_type" gorm:"column:order_type"` // 订单类型，0:支付宝，1:微信
BillId uint `json:"bill_id" gorm:"column:bill_id"` // 支出流水ID
Name string `json:"name,omitempty" gorm:"column:name"` // 用户姓名
BankCard string `json:"bank_card,omitempty" gorm:"column:bank_card"` // 用户银行卡
WeChat string `json:"wechat,omitempty" gorm:"column:wechat"` // 用户微信
Alipay string `json:"alipay,omitempty" gorm:"column:alipay"` // 用户支付宝
Telephone string `json:"telephone,omitempty" gorm:"column:telephone"` // 用户电话
Address string `json:"address" gorm:"column:address"` // 用户地址
OrderId string `json:"order_id" gorm:"column:order_id"` // 支付宝交易流水
TradeNo string `json:"trade_no" gorm:"column:trade_no"` // 分账的交易信息编号
Money float64 `json:"money" gorm:"column:money"` // 这笔交易分到的钱
Arrears float64 `json:"arrears" gorm:"column:arrears"` // 欠款详情
Rflag bool `json:"rflag" gorm:"column:rflag"` // 是否更新过打钱后的交易信息，false为未更新，true为已更新。
TransferDetails string `json:"transfer_details" gorm:"column:transfer_details"` // 打钱后的交易信息详情，Rflag为true，该字段有值。
Radio float64 `json:"radio" gorm:"column:radio"` // 分账比例
SubWay int64 `json:"sub_way" gorm:"column:sub_way"` // 分账方式：1为定额，0为比例
PaySwitch int64 `json:"pay_switch" gorm:"column:pay_switch"` // 分账开关是否打开
TradeStatus uint8 `json:"trade_status" gorm:"column:trade_status"` // 分账状态
PayDate time.Time `json:"pay_date" gorm:"column:pay_date"` // 付款完成时间
OnchainTime int64 `json:"on_chain_time" gorm:"column:on_chain_time"` // 交易流水上链时间
OnchainNum int64 `json:"on_chain_num" gorm:"column:on_chain_num"` // 重试上链次数
}
// 交易状态
const (
InitState = iota //初始化状态（暂不用）
NotOnchain //未上链
Onchain //已完成
Transfering //转账中(流水)
NotTransferOnChain //准备转账和上链
Paying //付款中
PayFailed //付款失败
PayOK //付款完成
TransferOnChaining //用户转账后正在上链
TransferOnChainFail //用户转账后上链失败
TransferOnChainOK //用户转账后上链成功
TransferOK //转账完成
RefundFailed //退款失败
RefundOK //退款成功
)
|
package engine
import (
"github.com/pkg/errors"
"helm.sh/helm/v3/pkg/chart"
"helm.sh/helm/v3/pkg/chartutil"
"helm.sh/helm/v3/pkg/engine"
)
type State struct {
ReleaseName string
Namespace string
Chrt *chart.Chart
Values chartutil.Values // final values used for rendering
IsUpgrade bool
Capabilities *chartutil.Capabilities
Engine *engine.EngineInstance
}
func (state *State) Init() error {
if state.Engine != nil {
return nil
}
options := chartutil.ReleaseOptions{
Name: state.ReleaseName,
Namespace: state.Namespace,
Revision: 1,
IsInstall: !state.IsUpgrade,
IsUpgrade: state.IsUpgrade,
}
valuesToRender, err := chartutil.ToRenderValues(state.Chrt, state.Values, options, state.Capabilities)
if err != nil {
return errors.Wrap(err, "failed to initialize engine")
}
state.Engine = new(engine.Engine).NewInstance(state.Chrt, valuesToRender) // reuse engine
return nil
}
|
package routers
import (
"github.com/astaxie/beego"
"github.com/astaxie/beego/context/param"
)
func init() {
beego.GlobalControllerRouter["mall/controllers:CommentController"] = append(beego.GlobalControllerRouter["mall/controllers:CommentController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:CommentController"] = append(beego.GlobalControllerRouter["mall/controllers:CommentController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:CommentController"] = append(beego.GlobalControllerRouter["mall/controllers:CommentController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:CommentController"] = append(beego.GlobalControllerRouter["mall/controllers:CommentController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:CommentController"] = append(beego.GlobalControllerRouter["mall/controllers:CommentController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:LoginController"] = append(beego.GlobalControllerRouter["mall/controllers:LoginController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:LogoutController"] = append(beego.GlobalControllerRouter["mall/controllers:LogoutController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:MonitorController"] = append(beego.GlobalControllerRouter["mall/controllers:MonitorController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:MonitorController"] = append(beego.GlobalControllerRouter["mall/controllers:MonitorController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:MonitorController"] = append(beego.GlobalControllerRouter["mall/controllers:MonitorController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:MonitorController"] = append(beego.GlobalControllerRouter["mall/controllers:MonitorController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:MonitorController"] = append(beego.GlobalControllerRouter["mall/controllers:MonitorController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:ObjectController"] = append(beego.GlobalControllerRouter["mall/controllers:ObjectController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:ObjectController"] = append(beego.GlobalControllerRouter["mall/controllers:ObjectController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:ObjectController"] = append(beego.GlobalControllerRouter["mall/controllers:ObjectController"],
beego.ControllerComments{
Method: "Get",
Router: `/:objectId`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:ObjectController"] = append(beego.GlobalControllerRouter["mall/controllers:ObjectController"],
beego.ControllerComments{
Method: "Put",
Router: `/:objectId`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:ObjectController"] = append(beego.GlobalControllerRouter["mall/controllers:ObjectController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:objectId`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsBrandController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsBrandController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsBrandController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsBrandController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsBrandController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsBrandController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsBrandController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsBrandController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsBrandController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsBrandController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsFeightTemplateController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductAttributeCategoryController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductCategoryController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PmsProductController"] = append(beego.GlobalControllerRouter["mall/controllers:PmsProductController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PostController"] = append(beego.GlobalControllerRouter["mall/controllers:PostController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PostController"] = append(beego.GlobalControllerRouter["mall/controllers:PostController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PostController"] = append(beego.GlobalControllerRouter["mall/controllers:PostController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PostController"] = append(beego.GlobalControllerRouter["mall/controllers:PostController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:PostController"] = append(beego.GlobalControllerRouter["mall/controllers:PostController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:RegisterController"] = append(beego.GlobalControllerRouter["mall/controllers:RegisterController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:TagController"] = append(beego.GlobalControllerRouter["mall/controllers:TagController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:TagController"] = append(beego.GlobalControllerRouter["mall/controllers:TagController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:TagController"] = append(beego.GlobalControllerRouter["mall/controllers:TagController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:TagController"] = append(beego.GlobalControllerRouter["mall/controllers:TagController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:TagController"] = append(beego.GlobalControllerRouter["mall/controllers:TagController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberLevelController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberReceiveAddressController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"] = append(beego.GlobalControllerRouter["mall/controllers:UmsMemberStatisticsInfoController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UserController"] = append(beego.GlobalControllerRouter["mall/controllers:UserController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UserController"] = append(beego.GlobalControllerRouter["mall/controllers:UserController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UserController"] = append(beego.GlobalControllerRouter["mall/controllers:UserController"],
beego.ControllerComments{
Method: "Get",
Router: `/:uid`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UserController"] = append(beego.GlobalControllerRouter["mall/controllers:UserController"],
beego.ControllerComments{
Method: "Put",
Router: `/:uid`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["mall/controllers:UserController"] = append(beego.GlobalControllerRouter["mall/controllers:UserController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:uid`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
}
|
package binarytree
import (
"container/list"
"reflect"
)
type Item interface{}
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func arrayToBinTree(nums []Item) *TreeNode {
queue := list.New()
if reflect.TypeOf(nums[0]) == nil {
return nil
}
root := &TreeNode{nums[0].(int), nil, nil}
queue.PushBack(root)
for i := 1; queue.Len() != 0; {
root := queue.Remove(queue.Front()).(*TreeNode)
if i < len(nums) {
if reflect.TypeOf(nums[i]) != nil {
root.Left = &TreeNode{nums[i].(int), nil, nil}
queue.PushBack(root.Left)
}
i++
}
if i < len(nums) {
if reflect.TypeOf(nums[i]) != nil {
root.Right = &TreeNode{nums[i].(int), nil, nil}
queue.PushBack(root.Right)
}
i++
}
}
return root
}
// 前序遍历：递归解法
func preorderTraversal(root *TreeNode) []int {
result := []int{}
if root != nil {
result = append(result, root.Val)
result = append(result, preorderTraversal(root.Left)...)
result = append(result, preorderTraversal(root.Right)...)
}
return result
}
/* // 前序遍历：迭代解法1
func preorderTraversal(root *TreeNode) []int {
result := []int{}
stack := list.New()
for root != nil || stack.Len() != 0 {
for root != nil {
stack.PushBack(root)
result = append(result, root.Val)
root = root.Left
}
if stack.Len() != 0 {
root = stack.Remove(stack.Back()).(*TreeNode)
root = root.Right
}
}
return result
} */
/* // 前序遍历：迭代解法2
func preorderTraversal(root *TreeNode) []int {
result := []int{}
if root == nil {
return result
}
stack := list.New()
stack.PushBack(root)
for stack.Len() != 0 {
tmp := stack.Remove(stack.Back()).(*TreeNode)
if tmp != nil {
result = append(result, tmp.Val)
stack.PushBack(tmp.Right)
stack.PushBack(tmp.Left)
}
}
return result
} */
// 中序遍历：递归解法
func inorderTraversal(root *TreeNode) []int {
result := []int{}
if root != nil {
result = append(result, inorderTraversal(root.Left)...)
result = append(result, root.Val)
result = append(result, inorderTraversal(root.Right)...)
}
return result
}
/* // 中序遍历：迭代解法
func inorderTraversal(root *TreeNode) []int {
result := []int{}
stack := list.New()
for root != nil || stack.Len() != 0 {
for root != nil {
stack.PushBack(root)
root = root.Left
}
if stack.Len() != 0 {
root = stack.Remove(stack.Back()).(*TreeNode)
result = append(result, root.Val)
root = root.Right
}
}
return result
} */
/* // 后序遍历：递归解法
func postorderTraversal(root *TreeNode) []int {
result := []int{}
if root != nil {
result = append(result, postorderTraversal(root.Left)...)
result = append(result, postorderTraversal(root.Right)...)
result = append(result, root.Val)
}
return result
} */
// 后序遍历：迭代解法
func postorderTraversal(root *TreeNode) []int {
result := []int{}
stack := list.New()
tag := make(map[*TreeNode]bool)
for root != nil || stack.Len() != 0 {
for root != nil {
stack.PushBack(root)
root = root.Left
}
if stack.Len() != 0 {
root = stack.Back().Value.(*TreeNode)
if !tag[root] {
tag[root] = true
root = root.Right
} else {
root = stack.Remove(stack.Back()).(*TreeNode)
result = append(result, root.Val)
root = nil
}
}
}
return result
}
// 层次遍历
func levelorderTraversal(root *TreeNode) [][]int {
result := [][]int{}
if root == nil {
return result
}
queue := list.New()
queue.PushBack(root)
for queue.Len() != 0 {
currentLevel := []int{}
currentLevelLen := queue.Len()
for i := 0; i < currentLevelLen; i++ {
root = queue.Remove(queue.Front()).(*TreeNode)
currentLevel = append(currentLevel, root.Val)
if root.Left != nil {
queue.PushBack(root.Left)
}
if root.Right != nil {
queue.PushBack(root.Right)
}
}
result = append(result, currentLevel)
}
return result
}
|
package server
import (
"github.com/hokora/bank/ipc"
"github.com/hokora/bank/util"
)
const (
TRANSFER_ERR_NONE = 0
TRANSFER_ERR_FROM_NOT_EXIST = 1
TRANSFER_ERR_TO_NOT_EXIST = 2
TRANSFER_ERR_SERVER = 3
TRANSFER_ERR_NOT_ENOUGH_BALANCE = 4
)
func (s *Server) TransferHandler(ctx *ipc.Context) {
pr := util.NewPacketReader(ctx.Packet)
from := string(pr.ReadBytesWithLenUInt8())
to := string(pr.ReadBytesWithLenUInt8())
amt := pr.ReadFloat64()
err := s.Transfer(from, to, amt)
switch err {
case TRANSFER_ERR_NONE:
ctx.Reply(true, []byte{})
default:
ctx.Reply(false, []byte{err})
}
}
// do both update operation together so do not have to revert on error
func (s *Server) Transfer(from, to string, amt float64) byte {
fromAcc, err := s.b.RetrieveAccountByUsername(from)
if err != nil {
if err.Error() == "not found" {
return TRANSFER_ERR_FROM_NOT_EXIST
}
return TRANSFER_ERR_SERVER
}
err = fromAcc.Transfer(to, amt)
if err != nil {
return TRANSFER_ERR_NOT_ENOUGH_BALANCE
}
toAcc, err := s.b.RetrieveAccountByUsername(to)
if err != nil {
if err.Error() == "not found" {
return TRANSFER_ERR_TO_NOT_EXIST
}
return TRANSFER_ERR_SERVER
}
toAcc.Deposit(amt)
err = s.b.UpdateAccount(fromAcc)
if err != nil {
return TRANSFER_ERR_SERVER
}
err = s.b.UpdateAccount(toAcc)
if err != nil {
//reverse toAcc update
return TRANSFER_ERR_SERVER
}
return TRANSFER_ERR_NONE
}
|
package operatorlister
import (
"fmt"
"sync"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/types"
corev1 "k8s.io/client-go/listers/core/v1"
)
type UnionServiceAccountLister struct {
serviceAccountListers map[string]corev1.ServiceAccountLister
serviceAccountLock sync.RWMutex
}
// List lists all ServiceAccounts in the indexer.
func (usl *UnionServiceAccountLister) List(selector labels.Selector) (ret []*v1.ServiceAccount, err error) {
usl.serviceAccountLock.RLock()
defer usl.serviceAccountLock.RUnlock()
set := make(map[types.UID]*v1.ServiceAccount)
for _, sl := range usl.serviceAccountListers {
serviceAccounts, err := sl.List(selector)
if err != nil {
return nil, err
}
for _, serviceAccount := range serviceAccounts {
set[serviceAccount.GetUID()] = serviceAccount
}
}
for _, serviceAccount := range set {
ret = append(ret, serviceAccount)
}
return
}
// ServiceAccounts returns an object that can list and get ServiceAccounts.
func (usl *UnionServiceAccountLister) ServiceAccounts(namespace string) corev1.ServiceAccountNamespaceLister {
usl.serviceAccountLock.RLock()
defer usl.serviceAccountLock.RUnlock()
// Check for specific namespace listers
if sl, ok := usl.serviceAccountListers[namespace]; ok {
return sl.ServiceAccounts(namespace)
}
// Check for any namespace-all listers
if sl, ok := usl.serviceAccountListers[metav1.NamespaceAll]; ok {
return sl.ServiceAccounts(namespace)
}
return &NullServiceAccountNamespaceLister{}
}
func (usl *UnionServiceAccountLister) RegisterServiceAccountLister(namespace string, lister corev1.ServiceAccountLister) {
usl.serviceAccountLock.Lock()
defer usl.serviceAccountLock.Unlock()
if usl.serviceAccountListers == nil {
usl.serviceAccountListers = make(map[string]corev1.ServiceAccountLister)
}
usl.serviceAccountListers[namespace] = lister
}
func (l *coreV1Lister) RegisterServiceAccountLister(namespace string, lister corev1.ServiceAccountLister) {
l.serviceAccountLister.RegisterServiceAccountLister(namespace, lister)
}
func (l *coreV1Lister) ServiceAccountLister() corev1.ServiceAccountLister {
return l.serviceAccountLister
}
// NullServiceAccountNamespaceLister is an implementation of a null ServiceAccountNamespaceLister. It is
// used to prevent nil pointers when no ServiceAccountNamespaceLister has been registered for a given
// namespace.
type NullServiceAccountNamespaceLister struct {
corev1.ServiceAccountNamespaceLister
}
// List returns nil and an error explaining that this is a NullServiceAccountNamespaceLister.
func (n *NullServiceAccountNamespaceLister) List(selector labels.Selector) (ret []*v1.ServiceAccount, err error) {
return nil, fmt.Errorf("cannot list ServiceAccounts with a NullServiceAccountNamespaceLister")
}
// Get returns nil and an error explaining that this is a NullServiceAccountNamespaceLister.
func (n *NullServiceAccountNamespaceLister) Get(name string) (*v1.ServiceAccount, error) {
return nil, fmt.Errorf("cannot get ServiceAccount with a NullServiceAccountNamespaceLister")
}
|
package progress
import (
"os"
"gopkg.in/cheggaaa/pb.v1"
)
type Bar struct {
*pb.ProgressBar
}
func NewBar() Bar {
bar := pb.New(0)
bar.SetUnits(pb.U_BYTES)
bar.Output = os.Stderr
return Bar{bar} // shop
}
func (b Bar) SetTotal(contentLength int64) {
b.Total = contentLength
}
func (b Bar) Kickoff() {
b.Start()
}
|
/*
* Tencent is pleased to support the open source community by making Blueking Container Service available.,
* Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
* Licensed under the MIT License (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
* http://opensource.org/licenses/MIT
* 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 v1
import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// BCSNetIPSpec defines the desired state of BCSNetIP
type BCSNetIPSpec struct {
// 所属网段
Net string `json:"net"`
// 网段掩码
Mask int `json:"mask"`
// 网段网关
Gateway string `json:"gateway"`
}
// BCSNetIPStatus defines the observed state of BCSNetIP
type BCSNetIPStatus struct {
// Active --已使用，Available --可用, Reserved --保留
Phase string `json:"phase,omitempty"`
// 对应主机信息
Host string `json:"host,omitempty"`
// 是否被用作固定IP
Fixed bool `json:"fixed,omitempty"`
// 容器ID
ContainerID string `json:"containerID,omitempty"`
// BCSNetIPClaim信息，格式为"命名空间/名称"
IPClaimKey string `json:"ipClaimKey,omitempty"`
PodName string `json:"podName,omitempty"`
PodNamespace string `json:"podNamespace,omitempty"`
UpdateTime metav1.Time `json:"updateTime,omitempty"`
KeepDuration string `json:"keepDuration,omitempty"`
}
//+kubebuilder:object:root=true
//+kubebuilder:resource:scope=Cluster
//+kubebuilder:subresource:status
// BCSNetIP is the Schema for the bcsnetips API
type BCSNetIP struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec BCSNetIPSpec `json:"spec,omitempty"`
Status BCSNetIPStatus `json:"status,omitempty"`
}
//+kubebuilder:object:root=true
// BCSNetIPList contains a list of BCSNetIP
type BCSNetIPList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []BCSNetIP `json:"items"`
}
func init() {
SchemeBuilder.Register(&BCSNetIP{}, &BCSNetIPList{})
}
|
package main
import (
"errors"
"fmt"
)
type Queue struct {
store []int
front int
rear int
size int
}
func NewQueue(size int) *Queue{
return &Queue{make([]int, size), 0, 0, 0}
}
func (q *Queue) isFull() bool {
return len(q.store) == q.size
}
func (q *Queue) enque(num int) error{
if q.size == len(q.store) {
return errors.New("Queue full")
}
q.store[q.front] = num
q.size += 1
q.front = (q.front + 1) % len(q.store)
return nil
}
func (q *Queue) deque() int {
ele := q.store[q.rear]
q.size -= 1
q.rear = (q.rear + 1) % len(q.store)
return ele
}
type Window struct {
win *Queue
avg float64
}
func (x *Window) Next(num int) {
if x.win.isFull() {
oldNum := x.win.deque()
_ = x.win.enque(num)
x.avg = (x.avg * float64(x.win.size) - float64(oldNum) + float64(num))/float64(x.win.size)
} else {
_ = x.win.enque(num)
x.avg = (x.avg * float64(x.win.size - 1) + float64(num))/float64(x.win.size)
}
}
func main() {
w := Window{NewQueue(3),0.0}
w.Next(5)
w.Next(10)
w.Next(15)
w.Next(20)
fmt.Println(w.avg)
}
|
package main
import (
"regexp"
"strings"
"github.com/clipperhouse/inflect"
)
type Type struct {
Package *Package
Pointer string
Name string
StandardMethods []string
Projections []*Projection
Containers []string
Imports []string
}
func (t *Type) LocalName() (result string) {
return t.Pointer + t.Name
}
func (t *Type) Plural() (result string) {
result = inflect.Pluralize(t.Name)
if result == t.Name {
result += "s"
}
return
}
func (t *Type) FileName() string {
return strings.ToLower(t.Name) + "_gen.go"
}
func (t *Type) AddProjection(methodName, typeName string) {
t.Projections = append(t.Projections, &Projection{methodName, typeName, t})
}
type Projection struct {
Method string
Type string
Parent *Type
}
func (p *Projection) MethodName() string {
name := p.Type
pointer := regexp.MustCompile(`^\**`)
pointers := len(pointer.FindAllString(name, -1)[0])
name = strings.Replace(name, "*", "", -1) + strings.Repeat("Pointer", pointers)
slice := regexp.MustCompile(`(\[\])`)
slices := len(slice.FindAllString(name, -1))
name = strings.Replace(name, "[]", "", -1) + strings.Repeat("Slice", slices)
illegal := regexp.MustCompile(`[^\p{L}\p{N}]+`)
name = illegal.ReplaceAllString(name, " ")
name = strings.Title(name)
name = strings.Replace(name, " ", "", -1)
return p.Method + strings.Title(name)
}
func (p *Projection) String() string {
return p.MethodName()
}
|
package v1alpha3
import (
"github.com/devspace-cloud/devspace/pkg/devspace/config/versions/config"
"github.com/devspace-cloud/devspace/pkg/devspace/config/versions/util"
next "github.com/devspace-cloud/devspace/pkg/devspace/config/versions/v1alpha4"
"github.com/devspace-cloud/devspace/pkg/util/log"
)
// Upgrade upgrades the config
func (c *Config) Upgrade(log log.Logger) (config.Config, error) {
nextConfig := &next.Config{}
err := util.Convert(c, nextConfig)
if err != nil {
return nil, err
}
// Convert dockerfilepath and contextpath
if c.Deployments != nil {
for key, deployConfig := range *c.Deployments {
if deployConfig.Helm != nil {
if (*nextConfig.Deployments)[key].Helm == nil {
(*nextConfig.Deployments)[key].Helm = &next.HelmConfig{}
}
if deployConfig.Helm.ChartPath != nil {
(*nextConfig.Deployments)[key].Helm.Chart = &next.ChartConfig{
Name: deployConfig.Helm.ChartPath,
}
}
if deployConfig.Helm.Overrides != nil {
(*nextConfig.Deployments)[key].Helm.ValuesFiles = deployConfig.Helm.Overrides
}
if deployConfig.Helm.OverrideValues != nil {
(*nextConfig.Deployments)[key].Helm.Values = deployConfig.Helm.OverrideValues
}
}
}
}
return nextConfig, nil
}
// UpgradeVarPaths upgrades the config
func (c *Config) UpgradeVarPaths(varPaths map[string]string, log log.Logger) error {
return nil
}
|
package gormsql
import (
"github.com/atymkiv/echo_frame_learning/blog/model"
"github.com/jinzhu/gorm"
)
// NewUser returns a new user database instance
func NewUser(db Database) *User {
return &User{
db: db,
}
}
// User represents the client for user table
type User struct {
db Database
}
// Interface for post database
type Database interface {
Create(value interface{}) *gorm.DB
}
func (u *User) Signup(usr blog.User) (*blog.User, error) {
var user = new(blog.User)
user.Email = usr.Email
user.Password = usr.Password
// Save user
if err := u.db.Create(&user).Error; err != nil {
return nil, err
}
return user, nil
}
|
package ircserver
import "gopkg.in/sorcix/irc.v2"
func init() {
Commands["server_QUIT"] = &ircCommand{
Func: (*IRCServer).cmdServerQuit,
}
}
func (i *IRCServer) cmdServerQuit(s *Session, reply *Replyctx, msg *irc.Message) {
// No prefix means the server quits the entire session.
if msg.Prefix == nil {
i.deleteSessionLocked(s, reply.msgid)
// For services, we also need to delete all sessions that share the
// same .Id, but have a different .Reply.
for id, session := range i.sessions {
if id.Id != s.Id.Id || id.Reply == 0 {
continue
}
i.sendCommonChannels(session, reply, &irc.Message{
Prefix: &session.ircPrefix,
Command: irc.QUIT,
Params: []string{msg.Trailing()},
})
i.deleteSessionLocked(session, reply.msgid)
}
return
}
// We got a prefix, so only a single session quits (e.g. nickname
// enforcer).
for id, session := range i.sessions {
if id.Id != s.Id.Id || id.Reply == 0 || NickToLower(session.Nick) != NickToLower(msg.Prefix.Name) {
continue
}
i.sendCommonChannels(session, reply, &irc.Message{
Prefix: &session.ircPrefix,
Command: irc.QUIT,
Params: []string{msg.Trailing()},
})
i.deleteSessionLocked(session, reply.msgid)
return
}
}
|
package main
import (
"context"
"encoding/base64"
"fmt"
"github.com/BurntSushi/toml"
"github.com/fatih/color"
"github/luoyayu/goidx/api"
"github/luoyayu/goidx/config"
"github/luoyayu/goidx/utils"
S "gopkg.in/abiosoft/ishell.v2"
"io"
"log"
"net/http"
"net/url"
"os"
"path"
"path/filepath"
"strings"
)
var WorkDir = "/"
var WorkDrive *api.SDrive
var SharedDrives []*api.SDrive
func WorkDriveNotExist() bool {
if WorkDrive == nil {
fmt.Println(utils.COut("please select a drive by `dd`", color.FgRed))
return true
}
return false
}
func init() {
c := &config.Config{}
if _, err := toml.DecodeFile("config.toml", &c); err != nil {
panic("no config.toml!")
}
config.WorkerHost = c.Host
config.Password = c.Password
config.UserName = c.User
config.RootBasicAuth += base64.StdEncoding.EncodeToString([]byte(fmt.Sprint(config.UserName, ":", config.Password)))
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
s := S.New()
s.SetPrompt(utils.COut(">>> ", color.FgGreen))
s.Interrupt(func(c *S.Context, count int, input string) {
cancel()
os.Exit(0)
})
s.Println("google shared drive index")
// dd
s.AddCmd(&S.Cmd{Name: "dd",
Aliases: []string{"dd"},
Func: func(c *S.Context) {
SharedDrives = api.GetSharedDrives("")
if len(SharedDrives) == 0 {
return
}
var choiceNames []string
for i := range SharedDrives {
choiceNames = append(choiceNames, SharedDrives[i].Name)
}
choice := c.MultiChoice(choiceNames, "select a shared drive")
WorkDrive = SharedDrives[choice]
c.Println("※ current working drive:", utils.COut(WorkDrive.Name, color.FgRed))
c.Println()
},
})
// pwd
s.AddCmd(&S.Cmd{Name: "pwd", Func: func(c *S.Context) {
if WorkDriveNotExist() {
return
}
c.Println(utils.COut(WorkDrive.Name+":"+WorkDir, color.FgCyan))
c.Println()
}})
// ls
s.AddCmd(&S.Cmd{Name: "ls",
Help: "list dir, not supporting show file info!",
Func: func(c *S.Context) {
if WorkDriveNotExist() {
return
}
argPath := strings.Join(c.Args, " ")
if !filepath.IsAbs(argPath) {
argPath = filepath.Join(WorkDir, argPath)
}
exist, files := api.ShowDir(filepath.Clean(argPath)+"/", "", WorkDrive.Id)
if !exist {
c.Println(utils.COut("no such dir!", color.FgRed))
return
}
// list file
for _, f := range files {
if f.IsFolder {
c.Println(utils.COut(f.Name, color.FgGreen))
} else {
c.Println(utils.COut(f.Name, color.FgBlue))
}
}
c.Println()
},
})
/*s.AddCmd(&S.Cmd{Name: "ll",
Func: func(c *S.Context) {
if WorkDrive == nil {
log.Println("please select a drive by `dd`")
return
}
},
})*/
// cd
s.AddCmd(&S.Cmd{Name: "cd",
Func: func(c *S.Context) {
if WorkDriveNotExist() {
return
}
// select mode
if len(c.Args) == 0 {
select2dir(c)
c.Println()
return
}
argPath := strings.Join(c.Args, " ")
if !filepath.IsAbs(argPath) {
argPath = filepath.Join(WorkDir, argPath)
}
if exist, _ := api.ShowDir(filepath.Clean(argPath)+"/", "", WorkDrive.Id); exist {
WorkDir = filepath.Clean(argPath)
} else {
c.Println(utils.COut("no such dir!", color.FgRed))
}
},
})
// play
s.AddCmd(&S.Cmd{
Name: "play",
Func: func(c *S.Context) {
if len(c.Args) == 0 { // select mode
var choicePlayable []string
_, files := api.ShowDir(filepath.Clean(WorkDir)+"/", "", WorkDrive.Id)
var playableFiles []*api.File
for _, f := range files {
if f.IsPlayable {
playableFiles = append(playableFiles, f)
choicePlayable = append(choicePlayable, f.Name)
}
}
if len(playableFiles) > 0 {
choice := c.MultiChoice(choicePlayable, "select to play")
if choice >= 0 && choice < len(playableFiles) {
selected := playableFiles[choice]
log.Println("play for", selected.Name)
var playArgs []string
if selected.IsVideo {
selectedFileBaseName := strings.TrimRight(filepath.Base(selected.Name), filepath.Ext(selected.Name))
var selectedCaptions []*api.File
for _, f := range files {
if strings.HasPrefix(f.Name, selectedFileBaseName) && !f.IsVideo && strings.HasSuffix(f.Name, ".ass") {
selectedCaptions = append(selectedCaptions, f)
}
}
for _, f := range selectedCaptions {
url_ := (&url.URL{
Scheme: "https",
Host: config.WorkerHost,
Path: WorkDir + "/" + f.Name,
RawQuery: url.Values{"rootId": []string{WorkDrive.Id}}.Encode(),
}).String()
if resp, err := http.Get(url_); err != nil {
log.Printf("download caption %q, err: %v\n", f.Name, err)
} else {
file, _ := os.Create(filepath.Join(os.TempDir(), f.Name))
io.Copy(file, resp.Body)
resp.Body.Close()
playArgs = append(playArgs, "--sub-file="+filepath.Join(os.TempDir(), f.Name))
}
}
}
url_ := (&url.URL{
Scheme: "https",
Host: config.WorkerHost,
Path: WorkDir + "/" + selected.Name,
RawQuery: url.Values{"rootId": []string{WorkDrive.Id}}.Encode(),
}).String()
go utils.Play(ctx, url_, selected.Name, "", playArgs...)
c.Println("You can type `stop` to kill mpv!")
}
} else {
c.Println(utils.COut("nothing is playable!", color.FgRed))
}
} else { // play the folder
// TODO:
}
},
})
s.AddCmd(&S.Cmd{
Name: "stop",
Func: func(c *S.Context) {
cancel()
ctx, cancel = context.WithCancel(context.Background())
},
})
s.Run()
}
func select2dir(c *S.Context) {
_, files := api.ShowDir(filepath.Clean(WorkDir)+"/", "", WorkDrive.Id)
choiceDirs := []string{".."}
folderFiles := []*api.File{{Name: ".."}}
for _, f := range files {
if f.IsFolder {
folderFiles = append(folderFiles, f)
choiceDirs = append(choiceDirs, f.Name)
}
}
choiceDirs = append(choiceDirs, utils.COut(">>> Quit select mode", color.FgRed))
if len(folderFiles) > 0 {
choice := c.MultiChoice(choiceDirs, utils.COut("WorkDir: "+WorkDir, color.FgCyan))
if choice == len(choiceDirs)-1 {
return
}
if choice >= 0 && choice < len(folderFiles) {
WorkDir = path.Join(WorkDir, choiceDirs[choice])
select2dir(c)
}
}
return
}
|
package week11
// 66. 加一 https://leetcode-cn.com/problems/plus-one/
// 输入：digits = [1,2,3]
// 输出：[1,2,4]
func plusOne(digits []int) []int {
ptr := len(digits) - 1
plus := true
for ptr >= 0 {
if digits[ptr] == 9 && plus {
// 如果是9且需要进位, 则数字改为0, 保持进位
digits[ptr] = 0
} else if plus {
// 如果不是9且需要进位, 则数字+1, 不再进位
digits[ptr]++
plus = false
} else {
// 如果不是9且不需要进位, 不动, 且不再进位
plus = false
}
ptr--
}
// 如果结果仍然需要进位，则头补1
if plus {
digits = append([]int{1}, digits...)
}
return digits
}
|
// Package controlplane contains the HTTP and gRPC base servers and the xDS gRPC implementation for envoy.
package controlplane
import (
"fmt"
"net/http"
"time"
"github.com/CAFxX/httpcompression"
"github.com/gorilla/mux"
"github.com/pomerium/pomerium/config"
"github.com/pomerium/pomerium/internal/handlers"
"github.com/pomerium/pomerium/internal/log"
"github.com/pomerium/pomerium/internal/middleware"
"github.com/pomerium/pomerium/internal/telemetry"
"github.com/pomerium/pomerium/internal/telemetry/requestid"
"github.com/pomerium/pomerium/internal/urlutil"
hpke_handlers "github.com/pomerium/pomerium/pkg/hpke/handlers"
)
func (srv *Server) addHTTPMiddleware(root *mux.Router, _ *config.Config) {
compressor, err := httpcompression.DefaultAdapter()
if err != nil {
panic(err)
}
root.Use(compressor)
root.Use(srv.reproxy.Middleware)
root.Use(requestid.HTTPMiddleware())
root.Use(log.NewHandler(log.Logger))
root.Use(log.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
log.FromRequest(r).Debug().
Dur("duration", duration).
Int("size", size).
Int("status", status).
Str("method", r.Method).
Str("host", r.Host).
Str("path", r.URL.String()).
Msg("http-request")
}))
root.Use(middleware.Recovery)
root.Use(log.RemoteAddrHandler("ip"))
root.Use(log.UserAgentHandler("user_agent"))
root.Use(log.RefererHandler("referer"))
root.Use(log.RequestIDHandler("request-id"))
root.Use(telemetry.HTTPStatsHandler(func() string {
return srv.currentConfig.Load().Options.InstallationID
}, srv.name))
}
func (srv *Server) mountCommonEndpoints(root *mux.Router, cfg *config.Config) error {
authenticateURL, err := cfg.Options.GetAuthenticateURL()
if err != nil {
return fmt.Errorf("invalid authenticate URL: %w", err)
}
signingKey, err := cfg.Options.GetSigningKey()
if err != nil {
return fmt.Errorf("invalid signing key: %w", err)
}
hpkePrivateKey, err := cfg.Options.GetHPKEPrivateKey()
if err != nil {
return fmt.Errorf("invalid hpke private key: %w", err)
}
hpkePublicKey := hpkePrivateKey.PublicKey()
root.HandleFunc("/healthz", handlers.HealthCheck)
root.HandleFunc("/ping", handlers.HealthCheck)
root.Handle("/.well-known/pomerium", handlers.WellKnownPomerium(authenticateURL))
root.Handle("/.well-known/pomerium/", handlers.WellKnownPomerium(authenticateURL))
root.Path("/.well-known/pomerium/jwks.json").Methods(http.MethodGet).Handler(handlers.JWKSHandler(signingKey))
root.Path(urlutil.HPKEPublicKeyPath).Methods(http.MethodGet).Handler(hpke_handlers.HPKEPublicKeyHandler(hpkePublicKey))
return nil
}
|
// Copyright 2020 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 telemetry
import (
"context"
"time"
"github.com/pingcap/tidb/kv"
"github.com/pingcap/tidb/sessionctx"
)
type telemetryData struct {
Hardware []*clusterHardwareItem `json:"hardware"`
Instances []*clusterInfoItem `json:"instances"`
TelemetryHostExtra *telemetryHostExtraInfo `json:"hostExtra"`
ReportTimestamp int64 `json:"reportTimestamp"`
TrackingID string `json:"trackingId"`
FeatureUsage *featureUsage `json:"featureUsage"`
WindowedStats []*windowData `json:"windowedStats"`
SlowQueryStats *slowQueryStats `json:"slowQueryStats"`
}
func generateTelemetryData(sctx sessionctx.Context, trackingID string) telemetryData {
ctx := kv.WithInternalSourceType(context.Background(), kv.InternalTxnTelemetry)
r := telemetryData{
ReportTimestamp: time.Now().Unix(),
TrackingID: trackingID,
}
if h, err := getClusterHardware(ctx, sctx); err == nil {
r.Hardware = h
}
if i, err := getClusterInfo(ctx, sctx); err == nil {
r.Instances = i
}
if f, err := getFeatureUsage(ctx, sctx); err == nil {
r.FeatureUsage = f
}
if s, err := getSlowQueryStats(); err == nil {
r.SlowQueryStats = s
}
r.WindowedStats = getWindowData()
r.TelemetryHostExtra = getTelemetryHostExtraInfo()
return r
}
func postReportTelemetryData() {
postReportTxnUsage()
postReportCTEUsage()
postReportAccountLockUsage()
postReportMultiSchemaChangeUsage()
postReportExchangePartitionUsage()
postReportTablePartitionUsage()
postReportSlowQueryStats()
postReportNonTransactionalCounter()
PostSavepointCount()
postReportLazyPessimisticUniqueCheckSetCount()
postReportDDLUsage()
postReportIndexMergeUsage()
postStoreBatchUsage()
postReportFairLockingUsageCounter()
}
// PostReportTelemetryDataForTest is for test.
func PostReportTelemetryDataForTest() {
postReportTablePartitionUsage()
}
|
package main
import "github.com/vugu/vugu"
func vuguSetup(buildEnv *vugu.BuildEnv, eventEnv vugu.EventEnv) vugu.Builder {
var counter Counter
buildEnv.SetWireFunc(func(b vugu.Builder) {
if c, ok := b.(CounterSetter); ok {
c.CounterSet(&counter)
}
})
ret := &Root{}
buildEnv.WireComponent(ret)
return ret
}
|
package definition
import (
"fmt"
"io/ioutil"
"os"
"path"
log "github.com/sirupsen/logrus"
"gopkg.in/yaml.v2"
)
const maxDepth = 50
// TemplateRenderer - Interface to user for the template rendering
type TemplateRenderer interface {
Render(templateStr string)
AddOutput(stepName string, varName string, value string)
}
// StepTypes - Defines step types
var StepTypes = map[string]bool{
"stage": true,
"container": true,
"command": true,
"export": true,
}
type Param struct {
Type string `yaml:"type"`
Default *string `yaml:"default,omitempty"`
Description string `yaml:"description"`
IsSensitive bool `yaml:"is_sensitive"`
}
func (p Param) HasDefault() bool {
return p.Default != nil
}
// ServerDefinition - Defines a cork server
type ServerDefinition struct {
Stages map[string]Stage `yaml:"stages"`
Params map[string]Param `yaml:"params"`
Tags []string `yaml:"tags"`
Version int `yaml:"version"`
// Internal data
requiredUserParamsByStage map[string][]string `yaml:"-"`
}
// Load - Loads the server definition from the default location
func LoadFromDir(corkDir string) (*ServerDefinition, error) {
defPath := path.Join(corkDir, "definition.yml")
return LoadFromPath(defPath)
}
// LoadFromPath - Loads the server definition from the specified path
func LoadFromPath(defPath string) (*ServerDefinition, error) {
defFile, err := os.Open(defPath)
if err != nil {
return nil, err
}
defer defFile.Close()
defBytes, err := ioutil.ReadAll(defFile)
if err != nil {
return nil, err
}
return LoadFromBytes(defBytes)
}
// LoadFromString - Loads the server definition from a string
func LoadFromString(defStr string) (*ServerDefinition, error) {
return LoadFromBytes([]byte(defStr))
}
// LoadFromBytes - Loads the server definition from bytes
func LoadFromBytes(defBytes []byte) (*ServerDefinition, error) {
def := ServerDefinition{
requiredUserParamsByStage: make(map[string][]string),
}
err := yaml.Unmarshal(defBytes, &def)
if err != nil {
return nil, err
}
err = def.Validate()
return &def, err
}
func (sd *ServerDefinition) ListStages() []string {
stageNames := make([]string, len(sd.Stages))
i := 0
for name := range sd.Stages {
stageNames[i] = name
i++
}
return stageNames
}
// ListSteps - Traverses the steps of a stage and resolves everything to a step
func (sd *ServerDefinition) ListSteps(stageName string) ([]*Step, error) {
return sd.resolveSteps(stageName, 0)
}
func (sd *ServerDefinition) resolveSteps(stageName string, depth int) ([]*Step, error) {
if depth > maxDepth {
// FIXME. we should detect circular dependencies
return nil, fmt.Errorf("Maximum stage recursion reached. You may have circular stage dependencies")
}
stage, ok := sd.Stages[stageName]
if !ok {
return nil, fmt.Errorf("Invalid definition. Cannot find stage '%s'", stageName)
}
var steps []*Step
for _, step := range stage {
if _, ok := StepTypes[step.Type]; !ok {
return nil, fmt.Errorf("Unknown step type: %s", step.Type)
}
if step.Type != "stage" {
steps = append(steps, step)
continue
}
if step.Args.Stage == "" {
return nil, fmt.Errorf("'stage' step requires a 'stage' argument")
}
stageSteps, err := sd.resolveSteps(step.Args.Stage, depth+1)
if err != nil {
return nil, err
}
steps = append(steps, stageSteps...)
}
return steps, nil
}
// RequiredUserParamsForStage gathers the required user params for a specific stage
func (sd *ServerDefinition) RequiredUserParamsForStage(stageName string) ([]string, error) {
requiredUserParams, ok := sd.requiredUserParamsByStage[stageName]
if !ok {
return nil, fmt.Errorf(`stage "%s" does not exist`, stageName)
}
return requiredUserParams, nil
}
func (sd *ServerDefinition) walkSteps(stageName string) ([]string, error) {
steps, err := sd.resolveSteps(stageName, 0)
if err != nil {
return nil, err
}
renderer := NewTemplateRenderer()
requiredUserParamsMap := map[string]bool{}
availableOutputs := map[string]bool{}
usedStepNames := map[string]bool{}
for _, step := range steps {
log.Debugf("Walking... Stage: %s Step Name: %s\n", stageName, step.Name)
if step.Name != "" {
used, _ := usedStepNames[step.Name]
if used {
return nil, fmt.Errorf(`Invalid Definition: step names must be unique in a stage. Step "%s" is not unique in stage "%s"`, step.Name, stageName)
}
}
usedStepNames[step.Name] = true
_, err := step.Args.ResolveArgs(renderer)
if err != nil {
return nil, err
}
requiredVarsForStep := renderer.ListRequiredVars()
for _, requiredVar := range requiredVarsForStep {
switch requiredVar.Type {
case "user":
requiredUserParamsMap[requiredVar.Lookup] = true
case "output":
_, ok := availableOutputs[requiredVar.Lookup]
if !ok {
return nil, fmt.Errorf(`Invalid Definition: Output variable "%s" used before available to step "%s"`, requiredVar.Lookup, step.ReferenceName())
}
}
renderer.ResetRequiredVarTracker()
}
for _, availableOutputName := range step.Outputs {
availableOutputs[fmt.Sprintf("%s.%s", step.Name, availableOutputName)] = true
}
}
var requiredUserParams []string
for requiredUserParam := range requiredUserParamsMap {
_, ok := sd.Params[requiredUserParam]
if !ok {
return nil, fmt.Errorf(`Invalid Definition: Variable "%s" is not defined. All expected variables need to have a definition.`, requiredUserParam)
}
requiredUserParams = append(requiredUserParams, requiredUserParam)
}
return requiredUserParams, nil
}
// Validate validates a definition file by running through the stages
func (sd *ServerDefinition) Validate() error {
if sd.Version == 0 {
return fmt.Errorf("Invalid Definition: version must be specified")
}
if sd.Version != 1 {
return fmt.Errorf("Invalid Definition: only version 1 is support")
}
for stageName := range sd.Stages {
requiredUserParams, err := sd.walkSteps(stageName)
if err != nil {
return err
}
sd.requiredUserParamsByStage[stageName] = requiredUserParams
}
return nil
}
|
package main
import "fmt"
func main() {
var i float32 = 42
fmt.Println("i = ", i)
j := 43
fmt.Println("j = ", j)
sum := i + j
fmt.Println("sum = ", sum)
}
|
package oauth
import (
"bytes"
"context"
"fmt"
"github.com/stretchr/testify/assert"
"github.com/testcontainers/testcontainers-go"
"github.com/testcontainers/testcontainers-go/wait"
"io/ioutil"
"net/http"
"os"
"testing"
"time"
)
var (
host = ""
client = http.Client{Timeout: 5 * time.Second}
)
func TestMain(m *testing.M) {
fmt.Println("about to start oauth tests")
containerMockServer, ctx := configMockServer()
code := m.Run()
shutdown(containerMockServer, ctx)
os.Exit(code)
}
func configMockServer() (testcontainers.Container, context.Context) {
ctx := context.Background()
req := testcontainers.ContainerRequest{
Image: "mockserver/mockserver",
ExposedPorts: []string{"1080/tcp"},
WaitingFor: wait.ForListeningPort("1080"),
}
containerMockServer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
ContainerRequest: req,
Started: true,
})
if err != nil {
panic(err)
}
ip, err := containerMockServer.Host(ctx)
if err != nil {
panic(err)
}
port, err := containerMockServer.MappedPort(ctx, "1080/tcp")
if err != nil {
panic(err)
}
_ = os.Setenv("PORT_OAUTH_SERVICE", port.Port())
_ = os.Setenv("HOST_OAUTH_SERVICE", ip)
host = fmt.Sprintf("http://%s:%s", ip, port.Port())
return containerMockServer, ctx
}
func shutdown(containerMockServer testcontainers.Container, ctx context.Context) {
defer containerMockServer.Terminate(ctx)
}
func TestIsPublicNilRequest(t *testing.T) {
assert.True(t, IsPublic(nil))
}
func TestIsPublic(t *testing.T) {
request := http.Request{
Header: make(http.Header),
}
request.Header.Add("X-Public", "true")
assert.True(t, IsPublic(&request))
}
func TestIsNotPublic(t *testing.T) {
request := http.Request{
Header: make(http.Header),
}
assert.False(t, IsPublic(&request))
}
func TestAuthenticateRequest(t *testing.T) {
data, _ := ioutil.ReadFile("../test/resources/request_access_token_ok.json")
requestBody := ioutil.NopCloser(bytes.NewReader(data))
requestLoadInformation, _ := http.NewRequest("PUT", host+"/expectation", requestBody)
_, _ = client.Do(requestLoadInformation)
request, _ := http.NewRequest("GET", host+"/users?access_token=abc123", nil)
errFinal := AuthenticateRequest(request)
assert.NotNil(t, request)
assert.EqualValues(t, "1", request.Header.Get("X-Client-Id"), "failed when validated X-Client-Id")
assert.Nil(t, errFinal)
}
func TestAuthenticateRequest_Not_Found(t *testing.T) {
data, _ := ioutil.ReadFile("../test/resources/request_access_token_not_found.json")
requestBody := ioutil.NopCloser(bytes.NewReader(data))
requestLoadInformation, _ := http.NewRequest("PUT", host+"/expectation", requestBody)
_, _ = client.Do(requestLoadInformation)
request, _ := http.NewRequest("GET", host+"/users?access_token=abc123notfound", nil)
errFinal := AuthenticateRequest(request)
assert.NotNil(t, request)
assert.EqualValues(t, "", request.Header.Get("X-Client-Id"), "failed when validated X-Client-Id")
assert.Nil(t, errFinal)
}
|
package main
import (
"fmt"
"time"
)
func main() {
//demand1()
//demand2()
demand3()
fmt.Println("休眠结束")
}
//延时方式一: 休眠
func demand1() {
time.Sleep(time.Second)
}
//延时方式二: Timer
func demand2() {
timer := time.NewTimer(time.Second)
<-timer.C
timer.Stop()
}
//延时方式三: After ~ 和Timer等价
func demand3() {
ch2 := time.After(time.Second)
<-ch2
}
|
package access
import (
"fmt"
"path"
"sort"
"strconv"
"github.com/databrickslabs/databricks-terraform/common"
"github.com/databrickslabs/databricks-terraform/identity"
"github.com/databrickslabs/databricks-terraform/workspace"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/pkg/errors"
)
// ObjectACL is a structure to generically describe access control
type ObjectACL struct {
ObjectID string `json:"object_id,omitempty"`
ObjectType string `json:"object_type,omitempty"`
AccessControlList []*AccessControl `json:"access_control_list"`
}
// AccessControl is a structure to describe user/group permissions
type AccessControl struct {
UserName *string `json:"user_name,omitempty"`
GroupName *string `json:"group_name,omitempty"`
AllPermissions []*Permission `json:"all_permissions,omitempty"`
}
func (ac AccessControl) String() string {
s := ""
switch {
case ac.GroupName != nil:
s += *ac.GroupName
case ac.UserName != nil:
s += *ac.UserName
default:
s += "something"
}
s += " "
for _, ap := range ac.AllPermissions {
if ap == nil {
continue
}
s += ap.String()
}
return s
}
// Permission is a structure to describe permission level
type Permission struct {
PermissionLevel string `json:"permission_level"`
Inherited bool `json:"inherited,omitempty"`
InheritedFromObject []string `json:"inherited_from_object,omitempty"`
}
func (p Permission) String() string {
if len(p.InheritedFromObject) > 0 {
return fmt.Sprintf("%s (from %s)", p.PermissionLevel, p.InheritedFromObject)
}
return p.PermissionLevel
}
// AccessControlChangeList is wrapper around ACL changes for REST API
type AccessControlChangeList struct {
AccessControlList []*AccessControlChange `json:"access_control_list"`
}
// AccessControlChange is API wrapper for changing permissions
type AccessControlChange struct {
UserName *string `json:"user_name,omitempty"`
GroupName *string `json:"group_name,omitempty"`
ServicePrincipalName *string `json:"service_principal_name,omitempty"`
PermissionLevel string `json:"permission_level"`
}
func (acc AccessControlChange) String() string {
return fmt.Sprintf("%v%v%v %s",
acc.UserName, acc.GroupName, acc.ServicePrincipalName,
acc.PermissionLevel)
}
// ToAccessControlChangeList converts data formats
func (oa *ObjectACL) ToAccessControlChangeList() *AccessControlChangeList {
acl := new(AccessControlChangeList)
for _, accessControl := range oa.AccessControlList {
for _, permission := range accessControl.AllPermissions {
if permission.Inherited {
continue
}
item := new(AccessControlChange)
acl.AccessControlList = append(acl.AccessControlList, item)
item.PermissionLevel = permission.PermissionLevel
if accessControl.UserName != nil {
item.UserName = accessControl.UserName
} else if accessControl.GroupName != nil {
item.GroupName = accessControl.GroupName
}
}
}
acl.Sort()
return acl
}
// Sort AccessControlList for consistent results
func (acl *AccessControlChangeList) Sort() {
sort.Slice(acl.AccessControlList, func(i, j int) bool {
return acl.AccessControlList[i].String() > acl.AccessControlList[j].String()
})
}
// AccessControl exports data for TF
func (acl *AccessControlChangeList) AccessControl(me string) []map[string]string {
result := []map[string]string{}
for _, control := range acl.AccessControlList {
item := map[string]string{}
if control.UserName != nil && *control.UserName != "" {
if me == *control.UserName {
continue
}
item["user_name"] = *control.UserName
} else if control.GroupName != nil && *control.GroupName != "" {
item["group_name"] = *control.GroupName
}
item["permission_level"] = control.PermissionLevel
result = append(result, item)
}
return result
}
// NewPermissionsAPI creates PermissionsAPI instance from provider meta
func NewPermissionsAPI(m interface{}) PermissionsAPI {
return PermissionsAPI{client: m.(*common.DatabricksClient)}
}
// PermissionsAPI exposes general permission related methods
type PermissionsAPI struct {
client *common.DatabricksClient
}
// AddOrModify works with permissions change list
func (a PermissionsAPI) AddOrModify(objectID string, objectACL *AccessControlChangeList) error {
return a.client.Patch("/preview/permissions"+objectID, objectACL)
}
// SetOrDelete updates object permissions
func (a PermissionsAPI) SetOrDelete(objectID string, objectACL *AccessControlChangeList) error {
return a.client.Put("/preview/permissions"+objectID, objectACL)
}
// Read gets all relevant permissions for the object, including inherited ones
func (a PermissionsAPI) Read(objectID string) (objectACL ObjectACL, err error) {
err = a.client.Get("/preview/permissions"+objectID, nil, &objectACL)
return
}
func parsePermissionsFromData(d *schema.ResourceData,
client *common.DatabricksClient) (*AccessControlChangeList, string, error) {
var objectId string
acl := new(AccessControlChangeList)
for _, mapping := range permissionsResourceIDFields() {
v, ok := d.GetOk(mapping.field)
if !ok {
continue
}
id, err := mapping.idRetriever(client, v.(string))
if err != nil {
return nil, "", err
}
objectId = fmt.Sprintf(
"/%s/%s",
mapping.resourceType, id)
err = d.Set("object_type", mapping.objectType)
if err != nil {
return nil, "", err
}
}
if objectId == "" {
return nil, "", fmt.Errorf("At least one type of resource identifiers must be set")
}
changes := 0
if data, ok := d.GetOk("access_control"); ok {
for _, element := range data.([]interface{}) {
rawAccessControl := element.(map[string]interface{})
change := new(AccessControlChange)
acl.AccessControlList = append(acl.AccessControlList, change)
if v, ok := rawAccessControl["group_name"].(string); ok && v != "" {
change.GroupName = &v
}
if v, ok := rawAccessControl["user_name"].(string); ok && v != "" {
change.UserName = &v
}
if v, ok := rawAccessControl["permission_level"].(string); ok {
change.PermissionLevel = v
}
changes++
}
}
if changes < 1 {
return nil, "", fmt.Errorf("at least one access_control is required")
}
acl.Sort()
return acl, objectId, nil
}
func resourcePermissionsCreate(d *schema.ResourceData, m interface{}) error {
client := m.(*common.DatabricksClient)
acl, objectID, err := parsePermissionsFromData(d, client)
if err != nil {
return err
}
err = NewPermissionsAPI(m).AddOrModify(objectID, acl)
if err != nil {
return err
}
d.SetId(objectID)
return resourcePermissionsRead(d, m)
}
func resourcePermissionsRead(d *schema.ResourceData, m interface{}) error {
id := d.Id()
objectACL, err := NewPermissionsAPI(m).Read(id)
if e, ok := err.(common.APIError); ok && e.IsMissing() {
d.SetId("")
return nil
}
if err != nil {
return err
}
for _, mapping := range permissionsResourceIDFields() {
if mapping.objectType != objectACL.ObjectType {
continue
}
err = d.Set("object_type", mapping.objectType)
if err != nil {
return fmt.Errorf("Cannot set object type: %v", mapping.objectType)
}
pathVariant := d.Get(mapping.objectType + "_path")
if pathVariant != "" {
// we're not importing and it's a path... it's set, so let's not re-set it
break
}
identifier := path.Base(id)
err := d.Set(mapping.field, identifier)
if err != nil {
return errors.Wrapf(err,
"Cannot set mapping field %s to %s",
mapping.field, id)
}
break
}
acl := objectACL.ToAccessControlChangeList()
me, err := identity.NewUsersAPI(m).Me()
if err != nil {
return errors.Wrapf(err, "Cannot self-identify")
}
accessControl := acl.AccessControl(me.UserName)
err = d.Set("access_control", accessControl)
if err != nil {
return err
}
return nil
}
func resourcePermissionsDelete(d *schema.ResourceData, m interface{}) error {
id := d.Id()
return NewPermissionsAPI(m).SetOrDelete(id, new(AccessControlChangeList))
}
// permissionsIDFieldMapping holds mapping
type permissionsIDFieldMapping struct {
field string
objectType string
resourceType string
idRetriever func(client *common.DatabricksClient, id string) (string, error)
}
// PermissionsResourceIDFields shows mapping of id columns to resource types
func permissionsResourceIDFields() []permissionsIDFieldMapping {
SIMPLE := func(client *common.DatabricksClient, id string) (string, error) {
return id, nil
}
PATH := func(client *common.DatabricksClient, path string) (string, error) {
info, err := workspace.NewNotebooksAPI(client).Read(path)
if err != nil {
return "", errors.Wrapf(err, "Cannot load path %s", path)
}
return strconv.FormatInt(info.ObjectID, 10), nil
}
return []permissionsIDFieldMapping{
{"cluster_policy_id", "cluster-policy", "cluster-policies", SIMPLE},
{"instance_pool_id", "instance-pool", "instance-pools", SIMPLE},
{"cluster_id", "cluster", "clusters", SIMPLE},
{"job_id", "job", "jobs", SIMPLE},
{"notebook_id", "notebook", "notebooks", SIMPLE},
{"notebook_path", "notebook", "notebooks", PATH},
{"directory_id", "directory", "directories", SIMPLE},
{"directory_path", "directory", "directories", PATH},
}
}
func conflictingFields(field string) []string {
conflicting := []string{}
for _, mapping := range permissionsResourceIDFields() {
if mapping.field == field {
continue
}
conflicting = append(conflicting, mapping.field)
}
return conflicting
}
// ResourcePermissions definition
func ResourcePermissions() *schema.Resource {
fields := map[string]*schema.Schema{
"object_type": {
Type: schema.TypeString,
Computed: true,
},
"access_control": {
ForceNew: true,
Type: schema.TypeList,
MinItems: 1,
Required: true,
ConfigMode: schema.SchemaConfigModeAttr,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"user_name": {
ForceNew: true,
Type: schema.TypeString,
Optional: true,
},
"group_name": {
ForceNew: true,
Type: schema.TypeString,
Optional: true,
},
"permission_level": {
ForceNew: true,
Type: schema.TypeString,
Required: true,
},
},
},
},
}
for _, mapping := range permissionsResourceIDFields() {
fields[mapping.field] = &schema.Schema{
ForceNew: true,
Type: schema.TypeString,
Optional: true,
ConflictsWith: conflictingFields(mapping.field),
}
}
return &schema.Resource{
Create: resourcePermissionsCreate,
Read: resourcePermissionsRead,
Delete: resourcePermissionsDelete,
Schema: fields,
}
}
|
/*
Copyright © 2021 Denis Belyatsky <denis.bel@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
package app
import (
"fmt"
"github.com/Brialius/jira2trello/internal/jira"
"github.com/Brialius/jira2trello/internal/trello"
"github.com/mattn/go-colorable"
"log"
"reflect"
"strings"
)
type SyncService struct {
jCli JiraConnector
tCli TrelloConnector
jTasks map[string]*jira.Task
tCards map[string]*trello.Card
}
func NewSyncService(jCli *jira.Client, tCli TrelloConnector) *SyncService {
return &SyncService{
jCli: jCli,
tCli: tCli,
}
}
func (s *SyncService) Sync() {
var err error
if err := s.jCli.Connect(); err != nil {
log.Fatalf("Can't connect to jira server: %s", err)
}
if err := s.tCli.Connect(); err != nil {
log.Fatalf("Can't connect to trello: %s", err)
}
fmt.Print("Getting Jira tasks... ")
if s.jTasks, err = s.jCli.GetUserTasks("status not in (done, closed, close, resolved) " +
"ORDER BY priority DESC, updated DESC"); err != nil {
log.Fatalf("can't get jira tasks: %s", err)
}
fmt.Printf("found %d\n", len(s.jTasks))
fmt.Println()
printJiraTasks(colorable.NewColorableStdout(), s.jTasks)
fmt.Println()
if s.tCards, err = getTrelloCards(s.tCli); err != nil {
log.Fatalf("can't get trello cards: %s", err)
}
if err := s.syncTasks(); err != nil {
log.Fatalf("can't sync tasks: %s", err)
}
if err := s.syncCompletedTasks(); err != nil {
log.Fatalf("can't sync completed tasks: %s", err)
}
}
func (s *SyncService) syncCompletedTasks() error {
fmt.Println("Searching completed tasks..")
for key, tCard := range s.tCards {
if _, ok := s.jTasks[key]; !ok {
if tCard.ListID != s.tCli.GetConfig().Lists.Done {
if err := s.tCli.MoveCardToList(tCard.ID, s.tCli.GetConfig().Lists.Done); err != nil {
return fmt.Errorf("can't move card to `Done` list: %w", err)
}
fmt.Printf("%s is completed!\n", key)
}
}
}
return nil
}
func (s *SyncService) syncTasks() error {
fmt.Println("Sync tasks...")
for key, jTask := range s.jTasks {
listID := s.tCli.GetConfig().Lists.Todo
labels := make([]string, 0)
labels = append(labels, s.tCli.GetConfig().Labels.Jira)
switch jTask.Status {
case "In Progress", "In Dev / In Progress":
listID = s.tCli.GetConfig().Lists.Doing
case "Dependency", "Blocked":
listID = s.tCli.GetConfig().Lists.Doing
labels = append(labels, s.tCli.GetConfig().Labels.Blocked)
case "Dev Complete", "In QA Review":
listID = s.tCli.GetConfig().Lists.Review
}
switch jTask.Type {
case "Story":
labels = append(labels, s.tCli.GetConfig().Labels.Story)
case "User Story":
labels = append(labels, s.tCli.GetConfig().Labels.Story)
case "Bug":
labels = append(labels, s.tCli.GetConfig().Labels.Bug)
default:
labels = append(labels, s.tCli.GetConfig().Labels.Task)
}
if tCard, ok := s.tCards[key]; !ok {
if err := s.addCardToList(jTask, listID, key, labels); err != nil {
return fmt.Errorf("can't add task to list: %w", err)
}
} else {
if err := s.updateCardLabels(tCard, labels); err != nil {
return err
}
if err := s.updateCardList(tCard, listID, jTask); err != nil {
return err
}
}
}
return nil
}
func (s *SyncService) updateCardList(tCard *trello.Card, listID string, task *jira.Task) error {
if tCard.ListID != listID {
if listID == s.tCli.GetConfig().Lists.Doing || listID == s.tCli.GetConfig().Lists.Todo {
if tCard.IsInAnyOfLists([]string{
s.tCli.GetConfig().Lists.Bucket,
s.tCli.GetConfig().Lists.Review,
}) {
return nil
}
}
fmt.Printf("Moving %s to %s list\n", task.Key, trello.GetListNameByID(listID, s.tCli.GetConfig().Lists))
err := s.tCli.MoveCardToList(tCard.ID, listID)
if err != nil {
return fmt.Errorf("can't move card to list: %w", err)
}
}
return nil
}
func (s *SyncService) updateCardLabels(tCard *trello.Card, labels []string) error {
if !reflect.DeepEqual(*tCard.IDLabels, labels) {
fmt.Printf("Updating labels for %s\n", tCard.Key)
err := s.tCli.UpdateCardLabels(tCard.ID, strings.Join(labels, ","))
if err != nil {
return fmt.Errorf("can't update labels on card `%s`: %w", tCard.Key, err)
}
}
return nil
}
func (s *SyncService) addCardToList(task *jira.Task, listID string, key string, labels []string) error {
fmt.Printf("Adding %s to %s list..\n", task.Key, trello.GetListNameByID(listID, s.tCli.GetConfig().Lists))
desc := task.Desc + "\nJira link: " + task.Link + "\nType: " + task.Type
if task.ParentKey != "" {
desc += "\nParent link: " + task.ParentLink
}
return s.tCli.CreateCard(&trello.Card{
Name: key + " | " + task.Summary,
ListID: listID,
Desc: desc,
IDLabels: &labels,
IDMembers: s.tCli.GetConfig().UserID,
})
}
func getTrelloCards(tCli TrelloConnector) (map[string]*trello.Card, error) {
fmt.Print("Getting Trello cards... ")
tCards := map[string]*trello.Card{}
cards, err := tCli.GetUserJiraCards()
if err != nil {
// todo: error returned from interface method should be wrapped
return nil, err
}
fmt.Printf("found %d\n", len(cards))
for _, card := range cards {
tCards[card.Key] = card
}
return tCards, nil
}
|
package service_test
import (
"context"
"crypto/tls"
"fmt"
"io"
"io/ioutil"
"net/http"
"reflect"
"sort"
"testing"
"github.com/go-ocf/kit/codec/cbor"
"github.com/go-ocf/kit/codec/json"
"github.com/go-ocf/cloud/authorization/provider"
c2cTest "github.com/go-ocf/cloud/cloud2cloud-gateway/test"
"github.com/go-ocf/cloud/cloud2cloud-gateway/uri"
"github.com/go-ocf/cloud/grpc-gateway/pb"
grpcTest "github.com/go-ocf/cloud/grpc-gateway/test"
"github.com/go-ocf/go-coap"
kitNetGrpc "github.com/go-ocf/kit/net/grpc"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
)
type sortLinksByHref []interface{}
const DeviceIDNotFound = "00010000-0000-0000-0000-000000000001"
func (a sortLinksByHref) Len() int { return len(a) }
func (a sortLinksByHref) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a sortLinksByHref) Less(i, j int) bool {
e1 := a[i].(map[interface{}]interface{})
e2 := a[j].(map[interface{}]interface{})
return e1["href"].(string) < e2["href"].(string)
}
func sortLinks(s []interface{}) []interface{} {
v := sortLinksByHref(s)
sort.Sort(v)
return v
}
func cleanUp(v interface{}) interface{} {
d, ok := v.(map[interface{}]interface{})
if !ok {
return v
}
links, ok := d["links"].([]interface{})
if !ok {
return v
}
links = sortLinks(links)
for _, l := range links {
li, ok := l.(map[interface{}]interface{})
if !ok {
continue
}
delete(li, "ins")
}
d["links"] = links
return v
}
func getDeviceAllRepresentation(deviceID, deviceName string) interface{} {
return cleanUp(map[interface{}]interface{}{
"device": map[interface{}]interface{}{
"di": deviceID,
"dmn": []interface{}{},
"dmno": "",
"if": interface{}(nil),
"n": deviceName,
"rt": interface{}(nil),
},
"links": []interface{}{
map[interface{}]interface{}{
"anchor": "",
"di": deviceID,
"eps": []interface{}{},
"href": "/" + deviceID + "/oc/con",
"id": "",
"if": []interface{}{"oic.if.rw", "oic.if.baseline"},
"p": map[interface{}]interface{}{
"bm": uint64(0x3), "port": uint64(0x0), "sec": false, "x.org.iotivity.tcp": uint64(0x0), "x.org.iotivity.tls": uint64(0x0),
},
"rt": []interface{}{"oic.wk.con"},
"title": "",
"type": interface{}(nil),
},
map[interface{}]interface{}{
"anchor": "",
"di": deviceID,
"eps": []interface{}{},
"href": "/" + deviceID + "/oic/cloud/s",
"id": "",
"if": []interface{}{"oic.if.baseline"},
"p": map[interface{}]interface{}{
"bm": uint64(0x3), "port": uint64(0x0), "sec": false, "x.org.iotivity.tcp": uint64(0x0), "x.org.iotivity.tls": uint64(0x0),
},
"rt": []interface{}{"x.cloud.device.status"},
"title": "Cloud device status",
"type": interface{}(nil),
},
map[interface{}]interface{}{
"anchor": "",
"di": "" + deviceID + "",
"eps": []interface{}{},
"href": "/" + deviceID + "/light/1",
"id": "",
"if": []interface{}{"oic.if.rw", "oic.if.baseline"},
"p": map[interface{}]interface{}{
"bm": uint64(0x3), "port": uint64(0x0), "sec": false, "x.org.iotivity.tcp": uint64(0x0), "x.org.iotivity.tls": uint64(0x0),
},
"rt": []interface{}{"core.light"},
"title": "",
"type": interface{}(nil),
},
map[interface{}]interface{}{
"anchor": "",
"di": "" + deviceID + "",
"eps": []interface{}{},
"href": "/" + deviceID + "/oic/d",
"id": "",
"if": []interface{}{"oic.if.r", "oic.if.baseline"},
"p": map[interface{}]interface{}{
"bm": uint64(0x1), "port": uint64(0x0), "sec": false, "x.org.iotivity.tcp": uint64(0x0), "x.org.iotivity.tls": uint64(0x0),
},
"rt": []interface{}{"oic.d.cloudDevice", "oic.wk.d"},
"title": "", "type": interface{}(nil),
},
map[interface{}]interface{}{
"anchor": "",
"di": "" + deviceID + "",
"eps": []interface{}{},
"href": "/" + deviceID + "/light/2",
"id": "",
"if": []interface{}{"oic.if.rw", "oic.if.baseline"},
"p": map[interface{}]interface{}{
"bm": uint64(0x3), "port": uint64(0x0), "sec": false, "x.org.iotivity.tcp": uint64(0x0), "x.org.iotivity.tls": uint64(0x0),
},
"rt": []interface{}{"core.light"},
"title": "",
"type": interface{}(nil),
},
map[interface{}]interface{}{
"anchor": "",
"di": "" + deviceID + "",
"eps": []interface{}{},
"href": "/" + deviceID + "/oic/p",
"id": "", "if": []interface{}{"oic.if.r", "oic.if.baseline"},
"p": map[interface{}]interface{}{
"bm": uint64(0x1), "port": uint64(0x0), "sec": false, "x.org.iotivity.tcp": uint64(0x0), "x.org.iotivity.tls": uint64(0x0),
},
"rt": []interface{}{"oic.wk.p"},
"title": "",
"type": interface{}(nil),
},
},
"status": "online",
})
}
func TestRequestHandler_RetrieveDevice(t *testing.T) {
deviceID := grpcTest.MustFindDeviceByName(grpcTest.TestDeviceName)
type args struct {
uri string
accept string
}
tests := []struct {
name string
args args
wantContentType string
wantCode int
want interface{}
}{
{
name: "JSON: " + uri.Devices + "/" + deviceID,
args: args{
uri: uri.Devices + "/" + deviceID,
accept: coap.AppJSON.String(),
},
wantCode: http.StatusOK,
wantContentType: coap.AppJSON.String(),
want: getDeviceAllRepresentation(deviceID, grpcTest.TestDeviceName),
},
{
name: "CBOR: " + uri.Devices + "/" + deviceID,
args: args{
uri: uri.Devices + "/" + deviceID,
accept: coap.AppOcfCbor.String(),
},
wantCode: http.StatusOK,
wantContentType: coap.AppOcfCbor.String(),
want: getDeviceAllRepresentation(deviceID, grpcTest.TestDeviceName),
},
{
name: "notFound",
args: args{
uri: uri.Devices + "/" + DeviceIDNotFound,
accept: coap.AppJSON.String(),
},
wantCode: http.StatusNotFound,
wantContentType: "text/plain",
want: "cannot retrieve device: cannot retrieve device(" + DeviceIDNotFound + ") [base]: cannot get devices: rpc error: code = NotFound desc = cannot get devices contents: not found",
},
{
name: "invalidAccept",
args: args{
uri: uri.Devices + "/" + deviceID,
accept: "application/invalid",
},
wantCode: http.StatusBadRequest,
wantContentType: "text/plain",
want: "cannot retrieve device: cannot retrieve: invalid accept header([application/invalid])",
},
{
name: "JSON: " + uri.Devices + "//" + deviceID + "/",
args: args{
uri: uri.Devices + "//" + deviceID + "/",
accept: coap.AppJSON.String(),
},
wantCode: http.StatusOK,
wantContentType: coap.AppJSON.String(),
want: getDeviceAllRepresentation(deviceID, grpcTest.TestDeviceName),
},
}
ctx, cancel := context.WithTimeout(context.Background(), TEST_TIMEOUT)
defer cancel()
ctx = kitNetGrpc.CtxWithToken(ctx, provider.UserToken)
tearDown := c2cTest.SetUp(ctx, t)
defer tearDown()
conn, err := grpc.Dial(grpcTest.GRPC_HOST, grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{
RootCAs: grpcTest.GetRootCertificatePool(t),
})))
require.NoError(t, err)
c := pb.NewGrpcGatewayClient(conn)
defer conn.Close()
shutdownDevSim := grpcTest.OnboardDevSim(ctx, t, c, deviceID, grpcTest.GW_HOST, grpcTest.GetAllBackendResourceLinks())
defer shutdownDevSim()
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
req := c2cTest.NewRequest(http.MethodGet, tt.args.uri, nil).AddHeader("Accept", tt.args.accept).Build(ctx, t)
resp := c2cTest.DoHTTPRequest(t, req)
assert.Equal(t, tt.wantCode, resp.StatusCode)
defer resp.Body.Close()
require.Equal(t, tt.wantContentType, resp.Header.Get("Content-Type"))
if tt.want != nil {
var got interface{}
readFrom := func(w io.Reader, v interface{}) error {
return fmt.Errorf("not supported")
}
switch tt.wantContentType {
case coap.AppJSON.String():
readFrom = json.ReadFrom
case coap.AppCBOR.String(), coap.AppOcfCbor.String():
readFrom = cbor.ReadFrom
case "text/plain":
readFrom = func(w io.Reader, v interface{}) error {
b, err := ioutil.ReadAll(w)
if err != nil {
return err
}
val := reflect.ValueOf(v)
if val.Kind() != reflect.Ptr {
return fmt.Errorf("some: check must be a pointer")
}
val.Elem().Set(reflect.ValueOf(string(b)))
return nil
}
}
err = readFrom(resp.Body, &got)
require.NoError(t, err)
cleanUp(got)
require.Equal(t, tt.want, got)
}
})
}
}
|
package centos
import (
"errors"
"github.com/caos/orbos/internal/operator/common"
"github.com/caos/orbos/mntr"
"strings"
)
func getEnsureMasquerade(
monitor mntr.Monitor,
zoneName string,
current *common.ZoneDesc,
desired common.Firewall,
) (
string,
error,
) {
ensureMasquerade := ""
masq, err := queryMasquerade(monitor, zoneName)
if err != nil {
return ensureMasquerade, err
}
zone := desired.Zones[zoneName]
current.Masquerade = masq
if masq != zone.Masquerade {
if zone.Masquerade {
ensureMasquerade = "--add-masquerade"
} else {
ensureMasquerade = "--remove-masquerade"
}
}
return ensureMasquerade, nil
}
func queryMasquerade(monitor mntr.Monitor, zone string) (bool, error) {
response, err := listFirewall(monitor, zone, "--list-all")
if err != nil {
return false, err
}
trimmed := strings.TrimSpace(strings.Join(response, " "))
if strings.Contains(trimmed, "masquerade: yes") {
return true, nil
} else if strings.Contains(trimmed, "masquerade: no") {
return false, nil
}
return false, errors.New("response to query not processable")
}
|
package main
import (
"flag"
"log"
"os"
"github.com/janivihervas/authproxy/internal/server"
"github.com/janivihervas/authproxy/upstream"
)
func main() {
var port = "3000"
if e := os.Getenv("PORT"); e != "" {
port = e
}
var portFlag string
flag.StringVar(&portFlag, "port", "3000", "port to run the server")
flag.Parse()
if portFlag != "" {
port = portFlag
}
logger := log.New(os.Stdout, "", log.Ldate|log.Ltime|log.LUTC)
err := server.RunHTTP(port, upstream.Echo{}, logger)
if err != nil {
panic(err)
}
}
|
// DRUNKWATER TEMPLATE(add description and prototypes)
// Question Title and Description on leetcode.com
// Function Declaration and Function Prototypes on leetcode.com
//104. Maximum Depth of Binary Tree
//Given a binary tree, find its maximum depth.
//The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
//Note: A leaf is a node with no children.
//Example:
//Given binary tree [3,9,20,null,null,15,7],
// 3
// / \
// 9 20
// / \
// 15 7
//return its depth = 3.
///**
// * Definition for a binary tree node.
// * type TreeNode struct {
// * Val int
// * Left *TreeNode
// * Right *TreeNode
// * }
// */
//func maxDepth(root *TreeNode) int {
//}
// Time Is Money
|
package services
import (
"context"
pingv1 "github.com/syncromatics/kafmesh/internal/protos/kafmesh/ping/v1"
)
// PingAPI provides uptime status for the kafmesh service
type PingAPI struct{}
// Ping responses immediately when a request is made
func (s *PingAPI) Ping(ctx context.Context, request *pingv1.PingRequest) (*pingv1.PingResponse, error) {
return &pingv1.PingResponse{}, nil
}
|
package agrasta
import (
"testing"
"golang.org/x/crypto/sha3"
)
// We have to make sure the rank counting works reliably
func TestMatrixRanker(t *testing.T) {
s := State{}
s.ShakeHash = sha3.NewShake256()
faults := 0
for i := 0; i < 1000; i++ {
// Fill the matrix with random data
var m Matrix
for i := 0; i < BlockSize; i++ {
for j := 0; j < BlockWords; j++ {
m[i][j] = s.rand()
}
}
if m.Rank() != BlockSize {
faults++
}
}
// It should be around 700, there may be encounter with an outlier case,
// with fairly low probability - just change hash seed if that happens.
if faults < 650 || faults > 750 {
t.Fatalf("Matrix ranking seems off, seen %d/%d faults\n", faults, 1000)
}
}
func TestNewMatrixRank(t *testing.T) {
s := State{}
s.ShakeHash = sha3.NewShake256()
for i := 0; i < 1000; i++ {
m := s.NewMatrix()
if m.Rank() != BlockSize {
t.Fatal("insufficient rank")
}
}
}
func TestPRFCombined(t *testing.T) {
s1 := State{}
s1.ShakeHash = sha3.NewShake256()
s2 := State{}
s2.ShakeHash = sha3.NewShake256()
for i := 0; i < 100; i++ {
var k1, k2 Block
k1 = s1.PRF(&k1)
k2 = s2.PRF2(&k2)
if k1 != k2 {
t.Fatal("Coalesced rowmult broken")
}
}
}
func BenchmarkNewMatrix(b *testing.B) {
s := State{}
s.ShakeHash = sha3.NewShake256()
b.ResetTimer()
for i := 0; i < b.N; i++ {
s.NewMatrix()
}
}
func BenchmarkCrypt(b *testing.B) {
s := State{}
b.ResetTimer()
var k Block
for i := 0; i < b.N; i++ {
k = s.Crypt(&k, &k, nil, uint64(i))
}
}
func BenchmarkCrypt2(b *testing.B) {
s := State{}
b.ResetTimer()
var k Block
for i := 0; i < b.N; i++ {
k = s.Crypt2(&k, &k, nil, uint64(i))
}
}
|
/*
Copyright 2023 The KubeVela 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 v1alpha1
import "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
const (
// ResourceUpdatePolicyType refers to the type of resource-update policy
ResourceUpdatePolicyType = "resource-update"
)
// ResourceUpdatePolicySpec defines the spec of resource-update policy
type ResourceUpdatePolicySpec struct {
Rules []ResourceUpdatePolicyRule `json:"rules"`
}
// Type the type name of the policy
func (in *ResourceUpdatePolicySpec) Type() string {
return ResourceUpdatePolicyType
}
// ResourceUpdatePolicyRule defines the rule for resource-update resources
type ResourceUpdatePolicyRule struct {
// Selector picks which resources should be affected
Selector ResourcePolicyRuleSelector `json:"selector"`
// Strategy the strategy for updating resources
Strategy ResourceUpdateStrategy `json:"strategy,omitempty"`
}
// ResourceUpdateStrategy the update strategy for resource
type ResourceUpdateStrategy struct {
// Op the update op for selected resources
Op ResourceUpdateOp `json:"op,omitempty"`
// RecreateFields the field path which will trigger recreate if changed
RecreateFields []string `json:"recreateFields,omitempty"`
}
// ResourceUpdateOp update op for resource
type ResourceUpdateOp string
const (
// ResourceUpdateStrategyPatch patch the target resource (three-way patch)
ResourceUpdateStrategyPatch ResourceUpdateOp = "patch"
// ResourceUpdateStrategyReplace update the target resource
ResourceUpdateStrategyReplace ResourceUpdateOp = "replace"
)
// FindStrategy return if the target resource is read-only
func (in *ResourceUpdatePolicySpec) FindStrategy(manifest *unstructured.Unstructured) *ResourceUpdateStrategy {
for _, rule := range in.Rules {
if rule.Selector.Match(manifest) {
return &rule.Strategy
}
}
return nil
}
|
package main
import (
"bytes"
"flag"
"fmt"
)
func getCountFromNum(inputNumber int) int {
num := inputNumber - '0'
if num >= 2 && num <= 6 {
return 3
}
if num == 7 {
return 4
} else if num == 8 {
return 3
} else if num == 9 {
return 4
} else {
return 0
}
}
func getStringFromNum(inputNumber int) []string {
num := inputNumber - '0'
if num >= 2 && num <= 6 {
return []string{string('a' + 3*(num-2)),
string('b' + 3*(num-2)),
string('c' + 3*(num-2))}
}
if num == 7 {
return []string{string('p'), string('q'), string('r'), string('s')}
} else if num == 8 {
return []string{string('t'), string('u'), string('v')}
} else if num == 9 {
return []string{string('w'), string('x'), string('y'), string('z')}
} else {
return nil
}
}
func combination(a []string, b []string) []string {
if len(a) == 0 || len(b) == 0 {
return nil
}
result := make([]string, 0, len(a)*len(b))
var buffer bytes.Buffer
for i := 0; i < len(a); i++ {
for j := 0; j < len(b); j++ {
buffer.Reset()
buffer.WriteString(a[i])
buffer.WriteString(b[j])
result = append(result, buffer.String())
}
}
return result
}
func letterCombinations(digits string) []string {
if len(digits) == 0 {
return nil
} else if len(digits) == 1 {
return getStringFromNum(int(digits[0]))
} else {
return combination(getStringFromNum(int(digits[0])), letterCombinations(digits[1:]))
}
}
var s string
func init() {
flag.StringVar(&s, "s", "", "input numbers as a string")
}
func main() {
flag.Parse()
fmt.Println("Welcome to the playground!")
fmt.Println(s)
//inputString := "22"
fmt.Println("Result:", letterCombinations(s))
}
|
package main
import (
"time"
"github.com/shauncampbell/golang-tplink-hs100/pkg/configuration"
"github.com/shauncampbell/golang-tplink-hs100/pkg/hs100"
)
const defaultSleep = 2000 * time.Millisecond
func main() {
h := hs100.NewHs100("localhost", configuration.Default())
println("Name of device:")
name, _ := h.GetName()
println(name)
time.Sleep(defaultSleep)
println("Is on:")
b, _ := h.IsOn()
println(b)
time.Sleep(defaultSleep)
println("Turning on")
_ = h.TurnOn()
println("done")
time.Sleep(defaultSleep)
println("Is on:")
b, _ = h.IsOn()
println(b)
time.Sleep(defaultSleep)
println("Turning off")
_ = h.TurnOff()
println("done")
time.Sleep(defaultSleep)
println("Is on:")
b, _ = h.IsOn()
println(b)
}
|
package main
import (
"fmt"
"testing"
"time"
)
func TestPlainTextWithoutTemplate(t *testing.T) {
// given
tmpl := "text-value 123"
tmplCtx := NewTemplateContext(NewVars(""))
// when
output := tmplCtx.ApplyTo(tmpl)
// then
expected := "text-value 123"
if tmplCtx.HasErrors() {
t.Error("Unexpected error", tmplCtx.Error())
}
if output != expected {
t.Errorf("Unexpected output. Expected: %s, Actual: %s", expected, output)
}
}
func TestPlainTextWithVars(t *testing.T) {
// given
tmpl := "{username} was successfully assigned to the Order #{order-id}"
vars := NewVars("")
vars.Add("order-id", 555)
vars.Add("username", "Smith")
tmplCtx := NewTemplateContext(vars)
// when
output := tmplCtx.ApplyTo(tmpl)
// then
expected := "Smith was successfully assigned to the Order #555"
if tmplCtx.HasErrors() {
t.Error("Unexpected error", tmplCtx.Error())
}
if output != expected {
t.Errorf("Unexpected output. Expected: %s, Actual: %s", expected, output)
}
}
func TestPlainTextWithNotExistingFunc(t *testing.T) {
// given
tmpl := "{username} was successfully assigned to the Order {{ .NotExists `9302945` }}"
vars := NewVars("")
vars.Add("username", "Smith")
tmplCtx := NewTemplateContext(vars)
// when
output := tmplCtx.ApplyTo(tmpl)
// then
expected := ""
if !tmplCtx.HasErrors() {
t.Error("Expected error not found")
}
if output != "" {
t.Errorf("Unexpected output. Expected: %s, Actual: %s", expected, output)
}
}
func TestFuncBase64(t *testing.T) {
// given
tmpl := "{{ .Base64 `DPFG` }}"
tmplCtx := NewTemplateContext(NewVars(""))
// when
output := tmplCtx.ApplyTo(tmpl)
// then
expected := "RFBGRw=="
if tmplCtx.HasErrors() {
t.Error("Unexpected error", tmplCtx.Error())
}
if output != expected {
t.Errorf("Unexpected output. Expected: %s, Actual: %s", expected, output)
}
}
func TestFuncSHA1(t *testing.T) {
// given
tmpl := "{{ .SHA1 `{username}` }}"
vars := NewVars("")
vars.Add("username", "el_mask")
tmplCtx := NewTemplateContext(vars)
// when
output := tmplCtx.ApplyTo(tmpl)
// then
expected := "2b0cc371b76f3ec6c1bebc52bcc44af69304dabf"
if tmplCtx.HasErrors() {
t.Error("Unexpected error", tmplCtx.Error())
}
if output != expected {
t.Errorf("Unexpected output. Expected: %s, Actual: %s", expected, output)
}
}
func TestFuncWSSEPasswordDigest(t *testing.T) {
// given
tmpl := "{{ .WSSEPasswordDigest `{nonce}` `{created}` `{password}` }}"
vars := NewVars("")
vars.Add("nonce", "abc123")
vars.Add("created", "2012-06-09T18:41:03.640Z")
vars.Add("password", "password")
tmplCtx := NewTemplateContext(vars)
// when
output := tmplCtx.ApplyTo(tmpl)
// then
expected := "mh7Ix8Qe02z1FIr51zoRO5pDMJg="
if tmplCtx.HasErrors() {
t.Error("Unexpected error", tmplCtx.Error())
}
if output != expected {
t.Errorf("Unexpected output. Expected: %s, Actual: %s", expected, output)
}
}
func TestFuncDaysFromNow(t *testing.T) {
// given
vars := NewVars("")
tmplCtx := NewTemplateContext(vars)
// when
output := tmplCtx.ApplyTo(`increment {{-3 | .DaysFromNow | .FormatDateTime "2006-01-02" }}`)
// then
expected := time.Now().AddDate(0, 0, -3).Format("2006-01-02")
if output != fmt.Sprintf("increment %s", expected) {
t.Error(output, "is not equal to", expected)
}
}
func TestFuncNow(t *testing.T) {
// given
vars := NewVars("")
tmplCtx := NewTemplateContext(vars)
// when
output := tmplCtx.ApplyTo(`now is {{.Now | .FormatDateTime "2006-01-02" }}`)
// then
expected := time.Now().Format("2006-01-02")
if output != fmt.Sprintf("now is %s", expected) {
t.Error(output, "is not equal to", expected)
}
}
func TestFuncNowInTZAndFormat(t *testing.T) {
// given
tmplCtx := NewTemplateContext(NewVars(""))
loc, err := time.LoadLocation("America/New_York")
if err != nil {
t.Error(err)
}
expected := time.Now().In(loc).Format("2006-01-02T15:04:05Z07:00")
// when
output := tmplCtx.ApplyTo(`now is {{ "America/New_York" | .Now | .FormatDateTime "2006-01-02T15:04:05Z07:00" }}`)
// then
if output != fmt.Sprintf("now is %s", expected) {
t.Error(output, "is not equal to", expected)
}
}
|
package hot100
import "sort"
// 给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
// 解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
// 关键: dfs
// 若当前数x之前的数y ,x==y,并且y 之前没有被选中,则当前可以直接退出
func subsetsWithDup(nums []int) [][]int {
sort.Ints(nums)
ret := make([][]int, 0)
var dfs func(chosePre bool, index int)
temp := make([]int, 0)
dfs = func(chosePre bool, index int) {
if index == len(nums) {
ret = append(ret, append([]int{}, temp...))
return
}
dfs(false, index+1)
// 如果之前的数没有被选择
if !chosePre && index > 0 && nums[index-1] == nums[index] {
// 并且紧邻的两个数相等
// 则直接returns
return
}
temp = append(temp, nums[index])
dfs(true, index+1)
// 裁剪
temp = temp[:len(temp)-1]
}
dfs(false, 0)
//
return ret
}
|
package dictparser
import (
"testing"
"github.com/stretchr/testify/assert"
)
var successTests = []struct {
input string
output []string
}{
{
input: "",
output: []string{},
},
{
input: "aa aa aa bb bb d d d d c",
output: []string{"d", "aa", "bb", "c"},
},
{
input: "a b b c c c d d d d e e e e e g g g g g g h h h h h h h i i i i i i i i j j j j j j j j j j k k k k k k k k k k k k ",
output: []string{"k", "j", "i", "h", "g", "e", "d", "c", "b", "a"},
},
}
func TestTop10(t *testing.T) {
for _, testData := range successTests {
t.Run(testData.input, func(t *testing.T) {
output := Top10(testData.input)
assert.Equal(t, testData.output, output)
})
}
}
|
package router
import (
"fmt"
"testing"
"time"
"github.com/AsynkronIT/protoactor-go/actor"
"github.com/stretchr/testify/mock"
)
var _ fmt.Formatter
var _ time.Time
func TestRouterSendsUserMessageToChild(t *testing.T) {
child, p := spawnMockProcess("child")
defer removeMockProcess(child)
p.On("SendUserMessage", mock.Anything, "hello", mock.Anything)
p.On("SendSystemMessage", mock.Anything, mock.Anything, mock.Anything)
s1 := actor.NewPIDSet(child)
rs := new(testRouterState)
rs.On("SetRoutees", s1)
rs.On("RouteMessage", "hello", mock.Anything)
grc := newGroupRouterConfig(child)
grc.On("CreateRouterState").Return(rs)
routerPID := actor.Spawn(actor.FromSpawnFunc(spawner(grc)))
routerPID.Tell("hello")
mock.AssertExpectationsForObjects(t, p, rs)
}
type testGroupRouter struct {
GroupRouter
mock.Mock
}
func newGroupRouterConfig(routees ...*actor.PID) *testGroupRouter {
r := new(testGroupRouter)
r.Routees = actor.NewPIDSet(routees...)
return r
}
func (m *testGroupRouter) CreateRouterState() Interface {
args := m.Called()
return args.Get(0).(*testRouterState)
}
type testRouterState struct {
mock.Mock
routees *actor.PIDSet
}
func (m *testRouterState) SetRoutees(routees *actor.PIDSet) {
m.Called(routees)
m.routees = routees
}
func (m *testRouterState) RouteMessage(message interface{}, sender *actor.PID) {
m.Called(message, sender)
m.routees.ForEach(func(i int, pid actor.PID) {
pid.Request(message, sender)
})
}
func (m *testRouterState) GetRoutees() *actor.PIDSet {
args := m.Called()
return args.Get(0).(*actor.PIDSet)
}
|
package routers
import (
"github.com/astaxie/beego"
)
func init() {
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"Signin",
`/signin`,
[]string{"get"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"Signup",
`/signup`,
[]string{"post"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"Signout",
`/signout`,
[]string{"get"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"Get",
`/:username`,
[]string{"get"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"GetContact",
`/:username/contacts`,
[]string{"get"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"AddContact",
`/:username/contacts/:contact_username`,
[]string{"get"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"DelContact",
`/:username/contacts/:contact_username`,
[]string{"delete"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"GetChat",
`/:username/contacts/:contact_username/chats`,
[]string{"get"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"DelChat",
`/:username/contacts/:contact_username/chats/:id`,
[]string{"delete"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"UpdateChat",
`/:username/contacts/:contact_username/chats/:id`,
[]string{"get"},
nil})
beego.GlobalControllerRouter["message/controllers:UserController"] = append(beego.GlobalControllerRouter["message/controllers:UserController"],
beego.ControllerComments{
"GetUnreadChat",
`/:username/contacts/:contact_username/chats/unread`,
[]string{"get"},
nil})
}
|
package action
import (
"context"
"github.com/guilhermesteves/aclow"
"github.com/guilhermesteves/go-todo-api/pkg/data/config"
dbtransformer "github.com/guilhermesteves/go-todo-api/pkg/data/transformer"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
"time"
)
type ListTodo struct {
app *aclow.App
}
func (n *ListTodo) Address() []string { return []string{"list_todo"} }
func (n *ListTodo) Start(app *aclow.App) {
n.app = app
}
func (n *ListTodo) Execute(msg aclow.Message, call aclow.Caller) (aclow.Message, error) {
client := n.app.Resources["mongo"].(*mongo.Client)
db := client.Database(config.MongoDbDatabase())
ctx, _ := context.WithTimeout(context.Background(), time.Minute)
cur, err := db.Collection("col_todo").Find(ctx, bson.M{}, &options.FindOptions{})
if err != nil {
return aclow.Message{}, err
}
var todos primitive.A
cur.Decode(&todos)
if len(todos) > 0 {
return aclow.Message{Body: dbtransformer.BsonToToDos(todos)}, nil
} else {
return aclow.Message{}, nil
}
}
|
package metahelm
import (
"testing"
"gopkg.in/src-d/go-billy.v4/memfs"
)
func TestReadFileSafely(t *testing.T) {
oldmax := fileSizeMaxBytes
defer func() { fileSizeMaxBytes = oldmax }()
fileSizeMaxBytes = 5
mfs := memfs.New()
f, _ := mfs.Create("foo.txt")
f.Write([]byte("1234567890"))
if _, err := readFileSafely(mfs, "foo.txt"); err == nil {
t.Fatalf("should have failed")
}
fileSizeMaxBytes = 100
d, err := readFileSafely(mfs, "foo.txt")
if err != nil {
t.Fatalf("should have succeeded: %v", err)
}
if string(d) != "1234567890" {
t.Fatalf("bad contents: %v", string(d))
}
}
|
/*
Utils for basic functions.
*/
package utils
|
package main
import (
"encoding/json"
"net/http"
"reflect"
"strings"
"golang.org/x/net/context"
"google.golang.org/appengine/datastore"
"google.golang.org/appengine/log"
)
// DeleteResponse Structure of returning a delete request.
type DeleteResponse struct {
Key *datastore.Key `json:"key"`
}
// EntityResponse Structure of returning an entity from a request.
type EntityResponse struct {
Key *datastore.Key `json:"key"`
Entity interface{} `json:"entity"`
}
// ListResponse Structure of returning multiple entities from a request.
type ListResponse struct {
Items []EntityResponse `json:"items"`
}
// Determine if a string is in a list of strings.
func stringInSlice(a string, list []string) bool {
for _, b := range list {
if b == a {
return true
}
}
return false
}
// Determine if a string has one of the prefixes in the list of strings.
func stringPrefixInSlice(a string, list []string) string {
for _, b := range list {
if strings.HasPrefix(a, b) {
return b
}
}
return ""
}
// Utility for writing a response in a json format.
func writeJSONResponse(ctx context.Context, w http.ResponseWriter, s interface{}) {
js, err := json.Marshal(s)
if err != nil {
log.Errorf(ctx, "error marshalling: %v", err)
http.Error(w, "Unable to marshal response", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write(js)
}
// Utility for writing an error response in a json format.
func writeJSONError(ctx context.Context, w http.ResponseWriter, e error, msg string, code int) {
var js []byte
var err error
log.Errorf(ctx, "error: %v", e)
if reflect.TypeOf(e).Name() == "ValidationError" {
js, err = json.Marshal(e)
} else {
var message string
if msg != "" {
message = msg
} else {
message = e.Error()
}
js, err = json.Marshal(map[string]interface{}{"Error": message})
}
if err != nil {
log.Errorf(ctx, "error marshalling: %v", err)
http.Error(w, e.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(code)
w.Write(js)
}
|
// +build OMIT
package sample
import "sync"
//START OMIT
type LockedHolder struct {
sync.Locker
Data map[string]string
}
func MainFunc() string {
holder := &LockedHolder{Data: map[string]string{}}
wg := &sync.WaitGroup{}
wg.Add(2)
lockHelper(holder, wg, func() { holder["foo"] = "bar" })
lockHelper(holder, wg, func() { holder["foo"] = "something else" })
wg.Wait()
return holder["foo"]
}
func lockHelper(holder *LockerHolder, wg *sync.WaitGroup, work func()) {
go func() {
holder.Lock()
defer holder.Lock()
defer wg.Done()
work()
}()
}
//END OMIT
|
package main
/*
这个文件是用来测试write是否按照正常的流程运行的
*/
import "github.com/shiningacg/apicore"
func init() {
apicore.AddHandler(apicore.NewMatcher("/stream", "GET"), func() apicore.Handler {
return &Stream{}
})
}
type Stream struct {
}
func (s *Stream) Handle(conn apicore.Conn) {
conn.SetCode(300)
conn.SetHead("X-Hello", "Ok")
conn.Write([]byte("hellow"))
}
func (s *Stream) IsValid() error {
return nil
}
|
package int_tree
import (
"github.com/joeyciechanowicz/letter-combinations/pkg/reader"
"sort"
)
func ToAlphabetIndex(letter rune) int {
return int(letter) - int(ToRune("a"))
}
func ToRune(letter string) rune {
return []rune(letter)[0]
}
var RuneToLetters = map[rune]int {
ToRune("a"): ToAlphabetIndex(ToRune("a")),
ToRune("b"): ToAlphabetIndex(ToRune("b")),
ToRune("c"): ToAlphabetIndex(ToRune("c")),
ToRune("d"): ToAlphabetIndex(ToRune("d")),
ToRune("e"): ToAlphabetIndex(ToRune("e")),
ToRune("f"): ToAlphabetIndex(ToRune("f")),
ToRune("g"): ToAlphabetIndex(ToRune("g")),
ToRune("h"): ToAlphabetIndex(ToRune("h")),
ToRune("i"): ToAlphabetIndex(ToRune("i")),
ToRune("j"): ToAlphabetIndex(ToRune("j")),
ToRune("k"): ToAlphabetIndex(ToRune("k")),
ToRune("l"): ToAlphabetIndex(ToRune("l")),
ToRune("m"): ToAlphabetIndex(ToRune("m")),
ToRune("n"): ToAlphabetIndex(ToRune("n")),
ToRune("o"): ToAlphabetIndex(ToRune("o")),
ToRune("p"): ToAlphabetIndex(ToRune("p")),
ToRune("q"): ToAlphabetIndex(ToRune("q")),
ToRune("r"): ToAlphabetIndex(ToRune("r")),
ToRune("s"): ToAlphabetIndex(ToRune("s")),
ToRune("t"): ToAlphabetIndex(ToRune("t")),
ToRune("u"): ToAlphabetIndex(ToRune("u")),
ToRune("v"): ToAlphabetIndex(ToRune("v")),
ToRune("w"): ToAlphabetIndex(ToRune("w")),
ToRune("x"): ToAlphabetIndex(ToRune("x")),
ToRune("y"): ToAlphabetIndex(ToRune("y")),
ToRune("z"): ToAlphabetIndex(ToRune("z")),
}
var Alphabet = [26]rune {
ToRune("a"),
ToRune("b"),
ToRune("c"),
ToRune("d"),
ToRune("e"),
ToRune("f"),
ToRune("g"),
ToRune("h"),
ToRune("i"),
ToRune("j"),
ToRune("k"),
ToRune("l"),
ToRune("m"),
ToRune("n"),
ToRune("o"),
ToRune("p"),
ToRune("q"),
ToRune("r"),
ToRune("s"),
ToRune("t"),
ToRune("u"),
ToRune("v"),
ToRune("w"),
ToRune("x"),
ToRune("y"),
ToRune("z"),
}
type LetterCount struct {
Letter int
Count byte
}
type WordDetails struct {
Word string
SortedLetterCounts []LetterCount
}
type WordDetailsSlice []WordDetails
type Node struct {
Children map[int]*Node
Words []*WordDetails
}
type runeSlice []rune
func (p runeSlice) Len() int { return len(p) }
func (p runeSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p runeSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func NewWordDetails(word string) WordDetails {
var details = WordDetails{
word,
[]LetterCount{},
}
sortedLetters := []rune(word)
sort.Sort(runeSlice(sortedLetters))
letterCounts := make(map[int]byte)
details.SortedLetterCounts = append(details.SortedLetterCounts, LetterCount{ToAlphabetIndex(sortedLetters[0]), 0})
for _, char := range sortedLetters {
alphaIndex := ToAlphabetIndex(char)
letterCounts[alphaIndex] += 1
if details.SortedLetterCounts[len(details.SortedLetterCounts)-1].Letter != alphaIndex {
details.SortedLetterCounts = append(details.SortedLetterCounts, LetterCount{alphaIndex, 0})
}
}
for i, runeCount := range details.SortedLetterCounts {
details.SortedLetterCounts[i].Count = letterCounts[runeCount.Letter]
}
return details
}
/**
Creates a trie of WordDetails where int is used instead of runes
The int is the index of a letter in Alphabet
*/
func CreateIntDictionaryTree(filename string) (Node, []WordDetails){
nodeCount := 0
var words []WordDetails
var trie = Node{
make(map[int]*Node),
make([]*WordDetails, 0),
}
reader.ReadFile(filename, func(word string) {
var details WordDetails
details = NewWordDetails(word)
var head *Node
head = &trie
for _, runeCount := range details.SortedLetterCounts {
if _, ok := head.Children[runeCount.Letter]; !ok {
nodeCount++
head.Children[runeCount.Letter] = &Node{
make(map[int]*Node),
[]*WordDetails{},
}
}
head = head.Children[runeCount.Letter]
}
words = append(words, details)
head.Words = append(head.Words, &details)
})
//fmt.Println("Trie nodes: ", nodeCount)
return trie, words
}
|
// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
//
// Modifications copyright 2013 Ernest Micklei. 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 glog
import (
"testing"
)
// go test -v -test.run TestDebug ...glog
func TestDebug(t *testing.T) {
logging.toStderr = true
logging.verbosity = DEBUG
logit()
}
func TestTrace(t *testing.T) {
logging.toStderr = true
logging.verbosity = TRACE
logit()
}
func TestInfoOnly(t *testing.T) {
logging.toStderr = true
logging.verbosity = 0
logit()
}
func logit() {
Info("this is info level")
Debug("this is debug level")
if DebugEnabled() {
Info("info is debug")
Debugf("formatted info is %s", "debug")
}
Trace("this is trace level")
if TraceEnabled() {
Info("info is trace")
Tracef("formatted info is %s", "trace")
}
}
|
package scrappers
import (
communityv1alpha1 "github.com/cloudnative-id/community-operator/pkg/apis/community/v1alpha1"
)
type Scrapper interface {
GetName() (string, error)
GetArticles() ([]communityv1alpha1.ArticleSpec, error)
}
|
package main
import (
"bufio"
"errors"
"flag"
"fmt"
"io"
"os"
"runtime"
"runtime/pprof"
"sort"
"github.com/wchargin/tensorboard-data-server/fs"
"github.com/wchargin/tensorboard-data-server/io/logdir"
)
var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
var memprofile = flag.String("memprofile", "", "write memory profile to this file")
func main() {
flag.Parse()
args := flag.Args()
if len(args) != 1 {
fmt.Fprintf(os.Stderr, "must specify run directory as only argument\n")
os.Exit(1)
}
// Profiling structure copied from "go doc runtime/pprof".
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
fmt.Fprintf(os.Stderr, "creating CPU profile: %v\n", err)
os.Exit(1)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
readLogDirectory(args[0], len(*cpuprofile) == 0 && len(*memprofile) == 0)
if *memprofile != "" {
fmt.Println("creating memory profile...")
f, err := os.Create(*memprofile)
if err != nil {
fmt.Fprintf(os.Stderr, "creating memory profile: %v\n", err)
os.Exit(1)
}
defer f.Close()
runtime.GC()
if err := pprof.WriteHeapProfile(f); err != nil {
fmt.Fprintf(os.Stderr, "writing memory profile: %v\n", err)
}
fmt.Println("done with memory profile")
}
}
func readLogDirectory(dir string, poll bool) {
ll := logdir.LoaderBuilder{FS: fs.OS{}, Logdir: dir}.Start()
stdin := bufio.NewReader(os.Stdin)
for {
c := make(chan struct{})
go func() {
ll.Reload()
close(c)
}()
<-c
runs := ll.Runs()
runNames := make([]string, len(runs))
{
i := 0
for k := range runs {
runNames[i] = k
i++
}
}
sort.Strings(runNames)
for _, run := range runNames {
fmt.Printf("run %q\n", run)
acc := runs[run]
mds := acc.List()
tags := make([]string, len(mds))
{
i := 0
for k := range mds {
tags[i] = k
i++
}
}
sort.Strings(tags)
for _, tag := range tags {
s := mds[tag].String()
if len(s) > 60 {
s = s[:57] + "..."
}
fmt.Printf("\ttag %q <%v>: meta=%v\n", tag, mds[tag].GetDataClass(), s)
sample := acc.Sample(tag)
if len(sample) > 0 {
firstStep := sample[0].EventStep
lastStep := sample[len(sample)-1].EventStep
fmt.Printf("\t\tn=%d, firstStep=%d, lastStep=%d\n", len(sample), firstStep, lastStep)
}
}
}
if !poll {
break
}
fmt.Printf("More (y/N)? ")
line, err := stdin.ReadString('\n')
if errors.Is(err, io.EOF) {
fmt.Println()
break
}
if err != nil {
panic(err)
}
if line != "y\n" && line != "Y\n" {
break
}
}
if err := ll.Close(); err != nil {
fmt.Fprintf(os.Stderr, "closing logdir loader: %v\n", err)
os.Exit(1)
}
}
|
package grammar
// import "fmt"
// func main() {
// var arr = [10]int{1, 2}
// fmt.Println(arr[0])
// var m = map[string]string{
// "google": "lolo",
// "baidu": "polo",
// }
// for k, v := range m {
// fmt.Println(k)
// fmt.Println(v)
// }
// var k int = 8
// fmt.Println(k)
// }
|
package db
import (
"time"
"github.com/golang/glog"
)
// 发布信息结构体
type Reflash struct {
Id uint "gorm:PRIMARY KEY"
SubCode string `gorm:"type:text;not null` // 排班编号
UserAddr string "gorm:not null" // 用户地址
CreateTime time.Time "gorm:not null" // 创建时间
UpdateTime time.Time "gorm:not null" // 更新时间
Used bool "gorm:not null" // 是否使用
UpdateRealTime int "gorm:not null" // 是否使用
UpdateWay int "gorm:not null" // 是否使用
}
func InsertReflash(sn, usr string) {
// inserting New one
db := DbClient.Client.Create(&Reflash{
SubCode: sn,
CreateTime: time.Now(),
Used: true,
})
if db.Error != nil {
glog.Errorln("SetSchedule err", db.Error)
}
}
func GetReflashs(where string, args ...string) map[int][]*Reflash {
ss := make([]*Reflash, 0)
db := DbClient.Client.Where(where, args).Find(&ss)
if db.Error != nil {
glog.Errorln("GetSchedules err", db.Error)
}
m := make(map[int][]*Reflash)
for _, v := range ss {
if _, exist := m[v.UpdateRealTime]; !exist {
m[v.UpdateRealTime] = []*Reflash{v}
} else {
m[v.UpdateRealTime] = append(m[v.UpdateRealTime], v)
}
}
return m
}
func UpdatingReflash(where, args, update, str string) {
db := DbClient.Client.Model(&Reflash{}).Where(where, args).Update(update, str)
if db.Error != nil {
glog.Errorln("GetSchedules err", db.Error)
}
}
func UpdatingReflash2(where, arg1, arg2, update, argu interface{}) {
db := DbClient.Client.Model(&Reflash{}).Where(where, arg1, arg2).Update(update, argu)
if db.Error != nil {
glog.Errorln("GetSchedules err", db.Error)
}
}
|
package integration_test
import (
"github.com/cloudfoundry/libbuildpack/cutlass"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("pushing a static app with dummy file in root", func() {
var app *cutlass.App
AfterEach(func() {
if app != nil {
app.Destroy()
}
app = nil
})
BeforeEach(func() {
app = cutlass.New(Fixtures("public_unspecified"))
PushAppAndConfirm(app)
})
It("should only have dummy file in public", func() {
files, err := app.Files("app")
Expect(err).To(BeNil())
Expect(files).To(ContainElement("app/public/dummy_file"))
Expect(files).ToNot(ContainElement("app/dummy_file"))
})
})
|
package pool
import (
"crawler/models"
"sync"
"sync/atomic"
)
type StorageMap map[uint64]*models.Task
type StorageType struct {
mx sync.RWMutex
m StorageMap
index uint64
}
func NewStorage() *StorageType {
return &StorageType{
m: StorageMap{},
index: 0,
}
}
func (s *StorageType) NextIndex() uint64 {
return atomic.AddUint64(&(s.index), 1)
}
func (s *StorageType) Get(id uint64) (task *models.Task, ok bool) {
s.mx.RLock()
defer s.mx.RUnlock()
task, ok = s.m[id]
return
}
func (s *StorageType) Set(id uint64, task *models.Task) {
s.mx.Lock()
defer s.mx.Unlock()
s.m[id] = task
}
func (s *StorageType) Delete(id uint64) {
s.mx.Lock()
defer s.mx.Unlock()
delete(s.m, id)
}
func (s *StorageType) Len() int {
s.mx.RLock()
defer s.mx.RUnlock()
return len(s.m)
}
|
package resume
import (
"time"
"github.com/devspace-cloud/devspace/pkg/devspace/cloud"
"github.com/devspace-cloud/devspace/pkg/devspace/kubectl"
"github.com/devspace-cloud/devspace/pkg/util/log"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/pkg/errors"
)
//SpaceResumer can resume a space
type SpaceResumer interface {
ResumeSpace(loop bool) error
}
type resumer struct {
kubeClient kubectl.Client
log log.Logger
}
// NewSpaceResumer creates a new instance of the interface SpaceResumer
func NewSpaceResumer(kubeClient kubectl.Client, log log.Logger) SpaceResumer {
return &resumer{
kubeClient: kubeClient,
log: log,
}
}
// ResumeSpace signals the cloud that we are currently working on the space and resumes it if it's currently paused
func (r *resumer) ResumeSpace(loop bool) error {
kubeLoader := r.kubeClient.KubeConfigLoader()
isSpace, err := kubeLoader.IsCloudSpace(r.kubeClient.CurrentContext())
if err != nil {
return errors.Wrap(err, "is cloud space")
}
// It is not a space so we just exit here
if isSpace == false {
return nil
}
// Retrieve space id and cloud provider
spaceID, cloudProvider, err := kubeLoader.GetSpaceID(r.kubeClient.CurrentContext())
if err != nil {
return errors.Errorf("Unable to get Space ID for context '%s': %v", r.kubeClient.CurrentContext(), err)
}
p, err := cloud.GetProvider(cloudProvider, r.log)
if err != nil {
return err
}
// Retrieve space from cache
space, _, err := p.GetAndUpdateSpaceCache(spaceID, false)
if err != nil {
return err
}
key, err := p.GetClusterKey(space.Space.Cluster)
if err != nil {
return errors.Wrap(err, "get cluster key")
}
resumed, err := p.Client().ResumeSpace(spaceID, key, space.Space.Cluster)
if err != nil {
return errors.Wrap(err, "resume space")
}
// We will wait a little bit till the space has resumed
if resumed {
r.log.StartWait("Resuming space")
defer r.log.StopWait()
// Give the controllers some time to create the pods
time.Sleep(time.Second * 3)
err = r.waitForSpaceResume()
if err != nil {
return err
}
}
if loop {
go func() {
for {
time.Sleep(time.Minute * 3)
p.Client().ResumeSpace(spaceID, key, space.Space.Cluster)
}
}()
}
return nil
}
// WaitForSpaceResume waits for a space to resume
func (r *resumer) waitForSpaceResume() error {
maxWait := time.Minute * 5
start := time.Now()
for time.Now().Sub(start) <= maxWait {
pods, err := r.kubeClient.KubeClient().CoreV1().Pods(r.kubeClient.Namespace()).List(metav1.ListOptions{})
if err != nil {
return errors.Wrap(err, "list pods")
}
continueWaiting := false
for _, pod := range pods.Items {
for _, containerStatus := range pod.Status.ContainerStatuses {
if containerStatus.State.Waiting != nil {
continueWaiting = true
}
}
}
if !continueWaiting {
break
}
time.Sleep(1 * time.Second)
}
return nil
}
|
package spiders
// where i defined spider
import (
"github.com/wcong/ants-go/ants/http"
"log"
)
const (
BASE_PARSE_NAME = "base"
SPIDERS_STATUS_INIT = iota
SPIDERS_STATUS_RUNNING
SPIDERS_STATUS_STOP
SPIDERS_BASIC_COOKIE
)
/*
what a spider do
* make start request
* define basic parse func
*/
type Spider struct {
BeforeMethod func()
InitStartUrls func()
AfterMethod func()
Name string
StartUrls []string
ExtData map[string]interface{}
ParseMap map[string]func(response *http.Response) ([]*http.Request, error) // defined you own parse function to scrapy response,make sure it return []response
}
func (this *Spider) MakeStartRequests() []*http.Request {
if this.InitStartUrls != nil {
this.InitStartUrls()
}
startRequestSlice := make([]*http.Request, len(this.StartUrls))
for index, url := range this.StartUrls {
request, err := http.NewRequest("GET", url, this.Name, BASE_PARSE_NAME, nil, 0)
if err != nil {
log.Println(err)
continue
}
startRequestSlice[index] = request
}
return startRequestSlice
}
|
package testdata
import "github.com/shitakemura/myapi/models"
type serviceMock struct{}
func NewServiceMock() *serviceMock {
return &serviceMock{}
}
func (s *serviceMock) PostArticleService(article models.Article) (models.Article, error) {
return articleTestData[1], nil
}
func (s *serviceMock) GetArticleListService(page int) ([]models.Article, error) {
return articleTestData, nil
}
func (s *serviceMock) GetArticleService(articleID int) (models.Article, error) {
return articleTestData[0], nil
}
func (s *serviceMock) PostNiceService(article models.Article) (models.Article, error) {
return articleTestData[0], nil
}
func (s *serviceMock) PostCommentService(comment models.Comment) (models.Comment, error) {
return commentTestData[0], nil
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.