text
stringlengths 11
4.05M
|
|---|
package main
import (
"net/http"
"fmt"
"context"
"time"
)
func main() {
http.HandleFunc("/",index)
http.Handle("/favicon.ico",http.NotFoundHandler())
http.ListenAndServe(":8080",nil)
}
func index(w http.ResponseWriter,r *http.Request){
ctx:=r.Context()
ctx=context.WithValue(ctx,"uid",1234)
ctx=context.WithValue(ctx,"uname","aman") //we can some values in context
res,err:=access(ctx)
if err!=nil{
http.Error(w,err.Error(),http.StatusRequestTimeout)
return
}
fmt.Fprintln(w,res)
}
func access(ctx context.Context) (int,error){
ctx,cancel:=context.WithTimeout(ctx,time.Second*2)
defer cancel()
ch:=make(chan int)
go func(){
uid:=ctx.Value("uid").(int)
time.Sleep(time.Second*10)
if ctx.Err!=nil{
return
}
ch <-uid
}()
select{
case <-ctx.Done(): return 0,ctx.Err()
case c:=<-ch: return c,nil
}
}
|
package processor
import (
"encoding/json"
"github.com/citrus-tart/certificate-aggregator/certificate"
"github.com/citrus-tart/certificate-aggregator/events"
)
type Repository interface {
GetById(string) certificate.Certificate
Save(certificate.Certificate) certificate.Certificate
}
type processor struct {
repo Repository
}
type certificateCreatedPayload struct {
ID string `json:"id"`
Name string `json:"name"`
Description string `json:"description"`
Authority string `json:"authority"`
}
type certificateUpdatedPayload struct {
Name string `json:"name"`
Description string `json:"description"`
Authority string `json:"authority"`
}
func (p processor) ProcessEvent(ev events.Event) {
var c certificate.Certificate
switch ev.Name {
case "certificate:created":
// unmarshal payload in to struct
var payload certificateCreatedPayload
json.Unmarshal([]byte(ev.Payload), &payload)
// update object
c.ID = payload.ID
c.Name = payload.Name
c.Description = payload.Description
c.Authority = payload.Authority
c.Created = ev.Timestamp
// store
p.repo.Save(c)
case "certificate:updated":
// get from repo
c = p.repo.GetById(ev.EntityID)
// unmarshal payload in to struct
var payload certificateUpdatedPayload
json.Unmarshal([]byte(ev.Payload), &payload)
// update object
c.ID = ev.EntityID
c.Name = payload.Name
c.Description = payload.Description
c.Authority = payload.Authority
// store
p.repo.Save(c)
}
}
func New(r Repository) processor {
var p processor
p.repo = r
return p
}
|
package ui
import (
"testing"
"time"
)
func TestInitMultiProgressInSilentMode(t *testing.T) {
var pw = InitMultiProgress(10, 5)
if !pw.silent {
t.Error("ProgressWrapper should be in silent mode")
}
}
func TestInitMultiProgressInSilentModeWithoutMultiProgress(t *testing.T) {
var pw = InitMultiProgress(10, 5)
if pw.multiProgress != nil {
t.Error("ProgressWrapper in silent mode should not have multiProgress")
}
}
func TestInitMultiProgressInSilentModeWithoutMultiProgressBars(t *testing.T) {
var pw = InitMultiProgress(10, 5)
if len(pw.progressBars) == 0 {
t.Error("ProgressWrapper in silent mode should not have progressBars")
}
}
func TestInitMultiProgressInSilentModeWithWaitGroup(t *testing.T) {
var pw = InitMultiProgress(10, 5)
if pw.waitGroup == nil {
t.Error("ProgressWrapper in silent mode should not have waitGroup")
}
}
func TestInitMultiProgress(t *testing.T) {
var pw = InitMultiProgress(10, 10)
if pw.silent {
t.Error("ProgressWrapper should be not silent if count > 10")
}
}
func TestInitMultiProgressWithMultiProgress(t *testing.T) {
var pw = InitMultiProgress(10, 10)
if pw.multiProgress == nil {
t.Error("ProgressWrapper should have multiProgress")
}
}
func TestInitMultiProgressWithMultiProgressBars(t *testing.T) {
var pw = InitMultiProgress(10, 10)
if pw.progressBars == nil || len(pw.progressBars) != 10 {
t.Error("ProgressWrapper should have progressBars")
}
for _, bar := range pw.progressBars {
if bar != nil {
t.Error("ProgressWrapper should have empty progressBars")
}
}
}
func TestInitMultiProgressWithWaitGroup(t *testing.T) {
var pw = InitMultiProgress(10, 10)
if pw.waitGroup == nil {
t.Error("ProgressWrapper should have waitGroup")
}
}
func TestProgressWrapper_AddBar(t *testing.T) {
var pw = InitMultiProgress(10, 10)
var givenThreadID = 5
if pw.progressBars[givenThreadID] != nil {
t.Error("ProgressWrapper should have empty progressBars")
}
pw.AddBar(givenThreadID)
for i, bar := range pw.progressBars {
if i == givenThreadID && bar == nil {
t.Error("ProgressWrapper should not have empty progressBar after calling AddBar")
} else if i != givenThreadID && bar != nil {
t.Error("ProgressWrapper should have empty progressBars")
}
}
}
func TestProgressWrapper_ShouldNotAddBarInSilentMode(t *testing.T) {
var pw = InitMultiProgress(10, 5)
var givenThreadID = 2
pw.AddBar(givenThreadID)
for _, bar := range pw.progressBars {
if bar != nil {
t.Error("ProgressWrapper should not have empty progressBars after calling AddBar in silent mode")
}
}
}
func TestProgressWrapper_Increment(t *testing.T) {
var pw = InitMultiProgress(10, 10)
var givenThreadID = 5
pw.AddBar(givenThreadID)
if pw.progressBars[givenThreadID].Current() != 0 {
t.Error("progressBar should not be incremented from the beginning")
}
pw.Increment(givenThreadID, time.Since(time.Now()))
if pw.progressBars[givenThreadID].Current() < 1 {
t.Error("progressBar should be incremented")
}
}
func TestProgressWrapper_ShouldNotIncrementInSilentMode(t *testing.T) {
var pw = InitMultiProgress(10, 5)
var givenThreadID = 5
pw.AddBar(givenThreadID)
pw.Increment(givenThreadID, time.Since(time.Now()))
}
func TestProgressWrapper_DoneExecution(t *testing.T) {
var pw = InitMultiProgress(10, 10)
var givenThreadID = 5
pw.AddBar(givenThreadID)
pw.DoneExecution()
}
func TestProgressWrapper_WaitForCompletionWithProgressBars(t *testing.T) {
var pw = InitMultiProgress(10, 10)
for i := 0; i < 10; i++ {
i := i
go func() {
pw.AddBar(i)
defer pw.DoneExecution()
time.Sleep(time.Millisecond * time.Duration(10))
pw.CompleteProgress(i)
}()
}
pw.WaitForCompletion()
}
func TestProgressWrapper_WaitForCompletion(t *testing.T) {
var pw = InitMultiProgress(3, 3)
for i := 0; i < 3; i++ {
i := i
go func() {
pw.AddBar(i)
defer pw.DoneExecution()
time.Sleep(time.Millisecond * time.Duration(10))
}()
}
pw.WaitForCompletion()
}
|
package libtsm
import (
"fmt"
"reflect"
"runtime"
"unsafe"
)
// #cgo pkg-config: libtsm
// #include <stdlib.h>
// #include <libtsm.h>
// #include "callback_wrapper.h"
import "C"
type VteWriteCallback func(data string)
type vteRef struct {
ptr *C.struct_tsm_vte
writeCallback VteWriteCallback
}
type Vte struct {
ref *vteRef
}
func finalizeVte(vteRef *vteRef) {
if nil != vteRef.ptr {
C.tsm_vte_unref(vteRef.ptr)
vteRef.ptr = nil
}
}
//export go_wrap_tsm_vte_write_cb
func go_wrap_tsm_vte_write_cb(u8 *C.char, len C.size_t, data unsafe.Pointer) {
vte := (*vteRef)(data)
if vte.writeCallback != nil {
vte.writeCallback(C.GoStringN(u8, C.int(len)))
}
}
func NewVte(screen Screen, writeCallback VteWriteCallback) (vte Vte, err error) {
vte.ref = &vteRef{
writeCallback: writeCallback,
}
runtime.SetFinalizer(vte.ref, finalizeVte)
failed, _ := C.go_tsm_vte_new(&vte.ref.ptr, screen.ref.ptr, unsafe.Pointer(vte.ref))
if failed != 0 {
err = fmt.Errorf("tsm_vte_new failed: %s", tsmErrorString(failed))
}
return
}
const (
PaletteDefault = ""
PaletteSolarized = "solarized"
PaletteSolarizedBlack = "solarized-black"
PaletteSolarizedWhite = "solarized-white"
)
func (vte Vte) SetPalette(palette string) error {
palettePtr := C.CString(palette)
defer C.free(unsafe.Pointer(palettePtr))
failed, _ := C.tsm_vte_set_palette(vte.ref.ptr, palettePtr)
if failed != 0 {
return fmt.Errorf("tsm_vte_set_palette('%s') failed: %s", palette, tsmErrorString(failed))
}
return nil
}
func (vte Vte) Reset() {
C.tsm_vte_reset(vte.ref.ptr)
}
func (vte Vte) HardReset() {
C.tsm_vte_hard_reset(vte.ref.ptr)
}
func (vte Vte) Input(data string) {
dataHdr := *(*reflect.StringHeader)(unsafe.Pointer(&data))
C.tsm_vte_input(vte.ref.ptr, (*C.char)(unsafe.Pointer(dataHdr.Data)), C.size_t(dataHdr.Len))
}
func (vte Vte) InputBytes(data []byte) {
dataHdr := *(*reflect.SliceHeader)(unsafe.Pointer(&data))
C.tsm_vte_input(vte.ref.ptr, (*C.char)(unsafe.Pointer(dataHdr.Data)), C.size_t(dataHdr.Len))
}
func (vte Vte) HandleKeyboard(keysym uint32, ascii uint32, mods VteModifier, unicode rune) bool {
result, _ := C.tsm_vte_handle_keyboard(vte.ref.ptr, C.uint32_t(keysym), C.uint32_t(ascii), C.uint(mods), C.uint32_t(unicode))
return bool(result)
}
|
package main
import "fmt"
func f1() int {
x, y := 10, 5
if x > 0 {
return y
}
return 0
}
func main() {
// simple if control
fmt.Printf("x = %v \n", f1())
}
|
// Copyright © 2020 Attestant Limited.
// 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 standard
import (
"context"
"github.com/attestantio/go-eth2-client/spec/phase0"
)
// ValidatorsByPubKey fetches the requested validators from local store given their public keys.
func (s *Service) ValidatorsByPubKey(ctx context.Context, pubKeys []phase0.BLSPubKey) map[phase0.ValidatorIndex]*phase0.Validator {
res := make(map[phase0.ValidatorIndex]*phase0.Validator)
s.validatorsMutex.RLock()
for _, pubKey := range pubKeys {
if validator, exists := s.validatorsByPubKey[pubKey]; exists {
res[s.validatorPubKeyToIndex[pubKey]] = validator
}
}
s.validatorsMutex.RUnlock()
return res
}
|
package core
import (
"fmt"
"log"
)
type Blockchain struct {
Blocks []*Block
}
func NewBlockchain() *Blockchain {
genesisBlock := GenerateGenesisBlock()
blockchain := Blockchain{}
blockchain.ApendBlock(&genesisBlock)
return &blockchain
}
func (bc *Blockchain) SendData(data string) {
preBlock := bc.Blocks[len(bc.Blocks)-1]
newBlock := GenerateNewBlock(*preBlock, data)
bc.ApendBlock(&newBlock)
}
func (bc *Blockchain) ApendBlock(newBlock *Block) {
if len(bc.Blocks) == 0 || isValid(*newBlock, *bc.Blocks[len(bc.Blocks)-1]) {
bc.Blocks = append(bc.Blocks, newBlock)
} else {
log.Fatal("invalid block")
}
}
func (bc *Blockchain) Print() {
fmt.Println("开始打印")
for _, block := range bc.Blocks {
fmt.Printf("Index: %d\n", block.Index)
fmt.Printf("Timestamp: %d\n", block.Timestamp)
fmt.Printf("PrevBlockHash: %s\n", block.PrevBlockHash)
fmt.Printf("Hash: %s\n", block.Hash)
fmt.Printf("Data: %s\n\n", block.Data)
}
}
func isValid(newBlock Block, oldBlock Block) bool {
if newBlock.Index-1 != oldBlock.Index {
return false
}
if newBlock.PrevBlockHash != oldBlock.Hash {
return false
}
if calculateHash(newBlock) != newBlock.Hash {
return false
}
return true
}
|
package common
//--------------通用的错误定义小于1000---------------------
const (
Success int = 0 // 成功
MissingParam int = 101 // 缺少必须参数
InvalidParam int = 102 // 无效的参数
VerifyParamFailed int = 103 // 参数验证失败
SystemUnknowErr int = 201 // 未知错误
SystemInternalErr int = 202 // 系统内部出错
SystemBusy int = 203 // 系统繁忙
)
//-------------业务参数请求大于等于1000----------------
const (
SignFailed int = 2001 // 校验签名失败
DataFieldFormatErr int = 2002 // data字段格式错误
MerchantNotExist int = 2003 // 商户不存在
MerchantForbidden int = 2004 // 商户已被禁用
OrderNotExist int = 2005 // 订单不存在
IpWhitListForbidden int = 2006 // IP白名单受限
DuplicateOrderNO int = 2007 // 订单号重复
ChannelUnusable int = 2008 // 通道不可用
OrderFailed int = 2009 // 下单失败
InsufficientBalance int = 2010 // 余额不足
NotInTime int = 2011 // 不在时间内
NotInAmt int = 2012 // 不在金额内
)
const (
SuccessMsg string = "success" // 成功时的msg
)
// 状态码和错误消息映射map
var CodeMap map[int]string
func init() {
CodeMap = make(map[int]string)
CodeMap[Success] = SuccessMsg
CodeMap[SystemUnknowErr] = "未知错误"
CodeMap[SystemInternalErr] = "系统内部出错"
CodeMap[SystemBusy] = "系统繁忙"
CodeMap[MissingParam] = "缺少必须参数"
CodeMap[InvalidParam] = "无效的参数"
CodeMap[VerifyParamFailed] = "参数验证失败"
CodeMap[SignFailed] = "校验签名失败"
CodeMap[DataFieldFormatErr] = "data字段格式错误"
CodeMap[MerchantNotExist] = "商户不存在"
CodeMap[MerchantForbidden] = "商户已被禁用"
CodeMap[OrderNotExist] = "订单不存在"
CodeMap[IpWhitListForbidden] = "IP白名单受限"
CodeMap[DuplicateOrderNO] = "订单号重复"
CodeMap[ChannelUnusable] = "通道不可用"
CodeMap[OrderFailed] = "下单失败"
CodeMap[InsufficientBalance] = "余额不足"
CodeMap[NotInTime] = "不在时间内"
CodeMap[NotInAmt] = "不在金额范围内"
}
// 获取一个带code和msg的错误
func NewCodeError(code int) error {
return &Response{Code: code, Msg: GetCodeMsg(code)}
}
// 获取一个带code和msg的错误
func NewCodeErrorWithMsg(code int, msg string) error {
return &Response{Code: code, Msg: msg}
}
// 获取错误码对应的描述信息
func GetCodeMsg(code int) string {
if msg, ok := CodeMap[code]; ok != false { // 有设置默认错误消息
return msg
}
return ""
}
|
package format
import (
"github.com/g-harel/gothrough/internal/types"
)
func formatField(field *types.Field) *Snippet {
snippet := NewSnippet()
if field.Name != "" {
snippet.fieldName(field.Name)
snippet.space()
}
snippet.fieldType(field.Type)
return snippet
}
func formatFieldList(fields []types.Field) *Snippet {
snippet := NewSnippet()
for i, field := range fields {
if i > 0 {
snippet.punctuation(",")
snippet.space()
}
snippet.concat(formatField(&field))
}
return snippet
}
|
package db
import (
"bytes"
"crypto/sha256"
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/boltdb/bolt"
"github.com/subutai-io/agent/log"
"github.com/subutai-io/gorjun/config"
)
var (
bucket = []byte("MyBucket")
search = []byte("SearchIndex")
users = []byte("Users")
tokens = []byte("Tokens")
authID = []byte("AuthID")
tags = []byte("Tags")
db = initDB()
)
func initDB() *bolt.DB {
os.MkdirAll(filepath.Dir(config.DB.Path), 0755)
os.MkdirAll(config.Storage.Path, 0755)
db, err := bolt.Open(config.DB.Path, 0600, &bolt.Options{Timeout: 3 * time.Second})
log.Check(log.FatalLevel, "Opening DB: "+config.DB.Path, err)
err = db.Update(func(tx *bolt.Tx) error {
for _, b := range [][]byte{bucket, search, users, tokens, authID, tags} {
_, err := tx.CreateBucketIfNotExists(b)
log.Check(log.FatalLevel, "Creating bucket: "+string(b), err)
}
return nil
})
log.Check(log.FatalLevel, "Finishing update transaction", err)
return db
}
// Write create record about file in DB
func Write(owner, key, value string, options ...map[string]string) error {
if len(owner) == 0 {
owner = "subutai"
}
err := db.Update(func(tx *bolt.Tx) error {
now, _ := time.Now().MarshalText()
// Associating files with user
b, _ := tx.Bucket(users).CreateBucketIfNotExists([]byte(owner))
if b, err := b.CreateBucketIfNotExists([]byte("files")); err == nil {
if v := b.Get([]byte(key)); v == nil {
// log.Warn("Associating: " + owner + " with " + value + " (" + key + ")")
b.Put([]byte(key), []byte(value))
}
}
// Creating new record about file
if b, err := tx.Bucket(bucket).CreateBucket([]byte(key)); err == nil {
b.Put([]byte("date"), now)
b.Put([]byte("name"), []byte(value))
// Adding search index for files
b, _ = tx.Bucket(search).CreateBucketIfNotExists([]byte(strings.ToLower(value)))
b.Put(now, []byte(key))
}
// Adding owners, shares and tags to files
if b := tx.Bucket(bucket).Bucket([]byte(key)); b != nil {
if c, err := b.CreateBucket([]byte("owner")); err == nil {
c.Put([]byte(owner), []byte("w"))
}
for i := range options {
for k, v := range options[i] {
switch k {
case "type":
if c, err := b.CreateBucketIfNotExists([]byte("type")); err == nil {
if c, err := c.CreateBucketIfNotExists([]byte(v)); err == nil {
c.Put([]byte(owner), []byte("w"))
}
}
case "md5", "sha256":
if c, err := b.CreateBucketIfNotExists([]byte("hash")); err == nil {
c.Put([]byte(k), []byte(v))
// Getting file size
if f, err := os.Open(config.Storage.Path + v); err == nil {
fi, _ := f.Stat()
f.Close()
b.Put([]byte("size"), []byte(fmt.Sprint(fi.Size())))
}
}
case "tags":
if c, err := b.CreateBucketIfNotExists([]byte("tags")); err == nil && len(v) > 0 {
for _, v := range strings.Split(v, ",") {
tag := []byte(strings.ToLower(strings.TrimSpace(v)))
t, _ := tx.Bucket(tags).CreateBucketIfNotExists(tag)
c.Put(tag, []byte("w"))
t.Put([]byte(key), []byte("w"))
}
}
case "signature":
if c, err := b.CreateBucketIfNotExists([]byte("owner")); err == nil {
c.Put([]byte(owner), []byte(v))
}
default:
if b.Get([]byte(k)) == nil {
b.Put([]byte(k), []byte(v))
}
}
}
}
if b, _ = b.CreateBucketIfNotExists([]byte("scope")); b != nil {
if b, _ = b.CreateBucketIfNotExists([]byte(owner)); b != nil {
}
}
}
return nil
})
log.Check(log.WarnLevel, "Writing data to db", err)
return err
}
// Edit record about file in DB
func Edit(owner, key, value string, options ...map[string]string) {
if len(owner) == 0 {
owner = "subutai"
}
err := db.Update(func(tx *bolt.Tx) error {
// Associating files with user
b, _ := tx.Bucket(users).CreateBucketIfNotExists([]byte(owner))
if b, err := b.CreateBucketIfNotExists([]byte("files")); err == nil {
if v := b.Get([]byte(key)); v == nil {
// log.Warn("Associating: " + owner + " with " + value + " (" + key + ")")
b.Put([]byte(key), []byte(value))
}
}
// Editing record about file
if len(value) > 0 {
b.Put([]byte("name"), []byte(value))
}
// Editing owners, shares and tags to files
if b := tx.Bucket(bucket).Bucket([]byte(key)); b != nil {
if c := b.Bucket([]byte("owner")); len(owner) > 0 {
c.Put([]byte(owner), []byte("w"))
}
for i := range options {
for k, v := range options[i] {
switch k {
case "type":
c := b.Bucket([]byte("type"))
if c := c.Bucket([]byte(v)); len(owner) > 0 {
c.Put([]byte(owner), []byte("w"))
}
case "md5", "sha256":
if c := b.Bucket([]byte("hash")); len(k) > 0 {
c.Put([]byte(k), []byte(v))
// Getting file size
if f, err := os.Open(config.Storage.Path + v); err == nil {
fi, _ := f.Stat()
f.Close()
b.Put([]byte("size"), []byte(fmt.Sprint(fi.Size())))
}
}
case "tags":
if c := b.Bucket([]byte("tags")); len(v) > 0 {
for _, v := range strings.Split(v, ",") {
tag := []byte(strings.ToLower(strings.TrimSpace(v)))
t, _ := tx.Bucket(tags).CreateBucketIfNotExists(tag)
c.Put(tag, []byte("w"))
t.Put([]byte(key), []byte("w"))
}
}
case "signature":
if c := b.Bucket([]byte("owner")); len(v) > 0 {
c.Put([]byte(owner), []byte(v))
}
default:
{
b.Put([]byte(k), []byte(v))
}
}
}
}
if b = b.Bucket([]byte("scope")); b != nil {
if b = b.Bucket([]byte(owner)); b != nil {
}
}
}
return nil
})
log.Check(log.WarnLevel, "Editing data in db", err)
}
// Delete removes record about file from DB
func Delete(owner, repo, key string) (total int) {
db.Update(func(tx *bolt.Tx) error {
var filename []byte
owned := CheckRepo(owner, "", key)
md5, _ := Hash(key)
total = CheckRepo("", "", key)
// Deleting user association with file
if b := tx.Bucket(bucket).Bucket([]byte(key)); b != nil {
if d := b.Bucket([]byte("type")); d != nil {
if d := d.Bucket([]byte(repo)); d != nil {
d.Delete([]byte(owner))
}
}
if c := b.Bucket([]byte("scope")); owned == 1 && c != nil {
c.Delete([]byte(owner))
}
if b := b.Bucket([]byte("owner")); owned == 1 && b != nil {
b.Delete([]byte(owner))
}
}
// Deleting file association with user
if b := tx.Bucket(users).Bucket([]byte(owner)); owned == 1 && b != nil {
if b := b.Bucket([]byte("files")); b != nil {
filename = b.Get([]byte(key))
b.Delete([]byte(key))
}
}
// Removing indexes and file only if no file owners left
if total == 1 || key != md5 {
// Deleting search index
if b := tx.Bucket(search).Bucket(bytes.ToLower(filename)); b != nil {
b.ForEach(func(k, v []byte) error {
if string(v) == key {
b.Delete(k)
}
return nil
})
}
for _, tag := range FileField(key, "tags") {
if s := tx.Bucket(tags).Bucket([]byte(tag)); s != nil {
log.Check(log.DebugLevel, "Removing tag "+tag+" from index bucket", s.Delete([]byte(key)))
}
}
// Removing file from DB
tx.Bucket(bucket).DeleteBucket([]byte(key))
}
return nil
})
return total
}
// Read returns name by ID
func Read(key string) (name string) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(key)); b != nil {
if value := b.Get([]byte("name")); value != nil {
name = string(value)
}
}
return nil
})
return name
}
// Hash returns hash sums by ID
func Hash(key string) (md5, sha256 string) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(key)); b != nil {
if b := b.Bucket([]byte("hash")); b != nil {
if value := b.Get([]byte("md5")); value != nil {
md5 = string(value)
}
if value := b.Get([]byte("sha256")); value != nil {
sha256 = string(value)
}
}
}
return nil
})
return md5, sha256
}
func Info(id string) map[string]string {
list := make(map[string]string)
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(id)); b != nil {
b.ForEach(func(k, v []byte) error {
list[string(k)] = string(v)
return nil
})
if hash := b.Bucket([]byte("hash")); hash != nil {
list["md5"] = string(hash.Get([]byte("md5")))
list["sha256"] = string(hash.Get([]byte("sha256")))
}
}
return nil
})
if len(list) != 0 {
list["id"] = id
}
return list
}
func Close() {
db.Close()
}
func Search(query string) (list []string) {
db.View(func(tx *bolt.Tx) error {
b := tx.Bucket(search)
b.ForEach(func(k, v []byte) error {
if strings.Contains(strings.ToLower(string(k)), strings.ToLower(query)) {
// for k, _ := c.Seek([]byte(query)); len(k) > 0 && bytes.HasPrefix(k, []byte(query)); k, _ = c.Next() {
//Shitty search index contains lots of outdated and invalid records and we must return all of them. Need to fix it.
b.Bucket(k).ForEach(func(kk, vv []byte) error {
for _, l := range list {
if l == string(vv) {
return nil
}
}
list = append(list, string(vv))
return nil
})
// _, kk := b.Bucket(k).Cursor().First()
}
return nil
})
return nil
})
return
}
func LastHash(name, t string) (hash string) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(search).Bucket([]byte(strings.ToLower(name))); b != nil {
c := b.Cursor()
for k, v := c.Last(); k != nil; k, v = c.Prev() {
if CheckRepo("", t, string(v)) > 0 {
hash = string(v)
break
}
}
}
return nil
})
return hash
}
func RegisterUser(name, key []byte) {
db.Update(func(tx *bolt.Tx) error {
b, err := tx.Bucket(users).CreateBucketIfNotExists([]byte(strings.ToLower(string(name))))
if !log.Check(log.WarnLevel, "Registering user "+string(name), err) {
b.Put([]byte("key"), key)
if b, err := b.CreateBucketIfNotExists([]byte("keys")); err == nil {
b.Put(key, nil)
}
}
return err
})
}
// UserKeys returns list of users GPG keys
func UserKeys(name string) (keys []string) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(strings.ToLower(name))); b != nil {
if k := b.Bucket([]byte("keys")); k != nil {
return k.ForEach(func(k, v []byte) error { keys = append(keys, string(k)); return nil })
}
keys = append(keys, string(b.Get([]byte("key"))))
}
return nil
})
return keys
}
// UserKey is replaced by UserKeys and left for compatibility. This function should be removed later.
func UserKey(name string) (key string) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(strings.ToLower(name))); b != nil {
if value := b.Get([]byte("key")); value != nil {
key = string(value)
}
}
return nil
})
return key
}
func SaveToken(name, token string) {
db.Update(func(tx *bolt.Tx) error {
if b, _ := tx.Bucket(tokens).CreateBucketIfNotExists([]byte(token)); b != nil {
b.Put([]byte("name"), []byte(name))
now, _ := time.Now().MarshalText()
b.Put([]byte("date"), now)
}
return nil
})
}
func CheckToken(token string) (name string) {
token = fmt.Sprintf("%x", sha256.Sum256([]byte(token)))
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(tokens).Bucket([]byte(token)); b != nil {
date := new(time.Time)
date.UnmarshalText(b.Get([]byte("date")))
if date.Add(time.Hour * 24).Before(time.Now()) {
return nil
}
if value := b.Get([]byte("name")); value != nil {
name = string(value)
}
}
return nil
})
return name
}
func SaveAuthID(name, token string) {
db.Update(func(tx *bolt.Tx) error {
tx.Bucket(authID).Put([]byte(token), []byte(name))
return nil
})
}
func CheckAuthID(token string) (name string) {
db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket(authID)
if value := b.Get([]byte(token)); value != nil {
name = string(value)
b.Delete([]byte(token))
}
return nil
})
return name
}
// FileField provides list of file properties
func FileField(hash, field string) (list []string) {
list = []string{}
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(hash)); b != nil {
if f := b.Bucket([]byte(field)); f != nil {
f.ForEach(func(k, v []byte) error {
list = append(list, string(k))
return nil
})
} else if b.Get([]byte(field)) != nil {
list = append(list, string(b.Get([]byte(field))))
}
}
return nil
})
return list
}
// FileSignatures returns map with file owners and theirs signatures
func FileSignatures(hash string) (list map[string]string) {
list = map[string]string{}
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(hash)); b != nil {
if b := b.Bucket([]byte("owner")); b != nil {
b.ForEach(func(k, v []byte) error {
if string(v) != "w" {
list[string(k)] = string(v)
}
return nil
})
}
}
return nil
})
return list
}
// UserFile searching file at particular user. It returns list of hashes of files with required name.
func UserFile(owner, file string) (list []string) {
if len(owner) == 0 {
owner = "subutai"
}
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(owner)); b != nil {
if files := b.Bucket([]byte("files")); files != nil {
files.ForEach(func(k, v []byte) error {
if Read(string(k)) == file {
list = append(list, string(k))
}
return nil
})
}
}
return nil
})
return list
}
// All artifacts of user by repo
func All(owner string, repo string) (list []string) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(owner)); b != nil {
if files := b.Bucket([]byte("files")); files != nil {
files.ForEach(func(k, v []byte) error {
if CheckRepo(owner, repo, string(k)) > 0 {
list = append(list, string(k))
}
return nil
})
}
}
return nil
})
return list
}
//Count all artifact that md5 equal to hash
func CountMd5(hash string) (md5 int) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket); b != nil {
b.ForEach(func(k, v []byte) error {
if b := b.Bucket(k).Bucket([]byte("hash")); b != nil {
if string(b.Get([]byte("md5"))) == hash {
md5++
}
}
return nil
})
}
return nil
})
return md5
}
// GetScope shows users with whom shared a certain owner of the file
func GetScope(hash, owner string) (scope []string) {
scope = []string{}
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(hash)); b != nil {
if b := b.Bucket([]byte("scope")); b != nil {
if b := b.Bucket([]byte(owner)); b != nil {
b.ForEach(func(k, v []byte) error {
scope = append(scope, string(k))
return nil
})
}
}
}
return nil
})
return scope
}
// ShareWith adds user to share scope of file
func ShareWith(hash, owner, user string) {
db.Update(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(hash)); b != nil {
if b := b.Bucket([]byte("scope")); b != nil {
if b := b.Bucket([]byte(owner)); b != nil {
b.Put([]byte(user), []byte("w"))
}
}
}
return nil
})
}
// UnshareWith removes user from share scope of file
func UnshareWith(hash, owner, user string) {
db.Update(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(hash)); b != nil {
if b := b.Bucket([]byte("scope")); b != nil {
if b := b.Bucket([]byte(owner)); b != nil {
b.Delete([]byte(user))
}
}
}
return nil
})
}
// CheckShare returns true if user has access to file, otherwise - false
func CheckShare(hash, user string) (shared bool) {
// log.Warn("hash: " + hash + ", user: " + user)
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(hash)); b != nil {
if b := b.Bucket([]byte("scope")); b != nil {
b.ForEach(func(k, v []byte) error {
// log.Warn("Owner: " + string(k))
if strings.EqualFold(string(k), user) {
shared = true
} else if b := b.Bucket(k); b != nil {
b.ForEach(func(k1, v1 []byte) error {
// log.Warn("+++" + string(k1))
if strings.EqualFold(string(k1), user) {
shared = true
}
return nil
})
}
return nil
})
}
}
return nil
})
return
}
// Public returns true if file is publicly accessible
func Public(hash string) (public bool) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(hash)); b != nil {
if b := b.Bucket([]byte("scope")); b != nil {
b.ForEach(func(k, v []byte) error {
if b := b.Bucket(k); b != nil {
k, _ := b.Cursor().First()
if k == nil {
public = true
}
}
return nil
})
} else {
public = true
}
}
return nil
})
return
}
// countTotal counts and sets user's total quota usage
func countTotal(user string) (total int) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(user)); b != nil {
if c := b.Bucket([]byte("files")); c != nil {
c.ForEach(func(k, v []byte) error {
tmp, _ := strconv.Atoi(Info(string(k))["size"])
total += tmp
return nil
})
}
}
return nil
})
return
}
// QuotaLeft returns user's quota left space
func QuotaLeft(user string) int {
var quota, stored int
db.Update(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(user)); b != nil {
if q := b.Get([]byte("quota")); q != nil {
quota, _ = strconv.Atoi(string(q))
} else {
quota = config.DefaultQuota()
}
if s := b.Get([]byte("stored")); s != nil {
stored, _ = strconv.Atoi(string(s))
} else {
stored = countTotal(user)
b.Put([]byte("stored"), []byte(strconv.Itoa(stored)))
}
}
return nil
})
if quota == -1 {
return -1
} else if quota <= stored {
return 0
}
return quota - stored
}
// QuotaUsageSet accepts size of added/removed file and updates quota usage for user
func QuotaUsageSet(user string, value int) {
var stored int
db.Update(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(user)); b != nil {
if s := b.Get([]byte("stored")); s != nil {
stored, _ = strconv.Atoi(string(s))
} else {
stored = countTotal(user)
}
b.Put([]byte("stored"), []byte(strconv.Itoa(stored+value)))
}
return nil
})
}
// QuotaGet returns value of user's disk quota
func QuotaGet(user string) (quota int) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(user)); b != nil {
if q := b.Get([]byte("quota")); q != nil {
quota, _ = strconv.Atoi(string(q))
} else {
quota = config.DefaultQuota()
}
}
return nil
})
return
}
// QuotaSet sets changes default storage quota for user
func QuotaSet(user, quota string) {
db.Update(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(user)); b != nil {
b.Put([]byte("quota"), []byte(quota))
}
return nil
})
}
// QuotaUsageCorrect updates saved values of quota usage according to file index table
func QuotaUsageCorrect() {
db.Update(func(tx *bolt.Tx) error {
if b := tx.Bucket(users); b != nil {
b.ForEach(func(k, v []byte) error {
if c := b.Bucket(k); c != nil {
rVal := countTotal(string(k))
if sVal := c.Get([]byte("stored")); sVal == nil && rVal != 0 || sVal != nil && string(sVal) != strconv.Itoa(rVal) {
log.Info("Correcting quota usage for user " + string(k))
log.Info("Stored value: " + string(sVal) + ", real value: " + strconv.Itoa(rVal))
c.Put([]byte("stored"), []byte(strconv.Itoa(rVal)))
}
}
return nil
})
}
return nil
})
}
// QuotaUsageGet returns value of used disk quota
func QuotaUsageGet(user string) (stored int) {
db.Update(func(tx *bolt.Tx) error {
if b := tx.Bucket(users).Bucket([]byte(user)); b != nil {
if s := b.Get([]byte("stored")); s != nil {
stored, _ = strconv.Atoi(string(s))
} else {
stored = countTotal(user)
b.Put([]byte("stored"), []byte(strconv.Itoa(stored)))
}
}
return nil
})
return
}
// SaveTorrent saves torrent file for particular template in DB for future usage to prevent regeneration same file again.
func SaveTorrent(hash, torrent []byte) {
db.Update(func(tx *bolt.Tx) error {
if b, err := tx.Bucket(bucket).CreateBucketIfNotExists(hash); err == nil {
b.Put([]byte("torrent"), torrent)
}
return nil
})
}
// Torrent retrieves torrent file for template from DB. If no torrent file found it returns nil.
func Torrent(hash []byte) (val []byte) {
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket(hash); b != nil {
if value := b.Get([]byte("torrent")); value != nil {
val = value
}
}
return nil
})
return val
}
// CheckRepo walks through specified repo (or all repos, if none is specified) and checks
// if particular file exists and owner is correct. Returns number of found matches
func CheckRepo(owner, repo, hash string) (val int) {
reps := []string{repo}
if len(repo) == 0 {
reps = []string{"apt", "template", "raw"}
}
db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket); b != nil && strings.Contains(hash, "-") {
b.ForEach(func(k, v []byte) error {
if b := b.Bucket(k).Bucket([]byte("hash")); b != nil {
if string(b.Get([]byte("md5"))) == hash {
val++
}
}
return nil
})
}
if b := tx.Bucket(bucket).Bucket([]byte(hash)); b != nil {
if c := b.Bucket([]byte("type")); c != nil {
for _, v := range reps {
if d := c.Bucket([]byte(v)); d != nil {
if k, _ := d.Cursor().First(); len(owner) == 0 && k != nil {
val += d.Stats().KeyN
} else if d.Get([]byte(owner)) != nil || d.Get([]byte(strings.ToLower(owner))) != nil {
val++
}
}
}
} else if len(repo) == 0 || len(repo) != 0 && repo == string(b.Get([]byte("type"))) {
if len(owner) == 0 {
val = b.Bucket([]byte("owner")).Stats().KeyN
} else if b.Bucket([]byte("owner")).Get([]byte(owner)) != nil || b.Bucket([]byte("owner")).Get([]byte(strings.ToLower(owner))) != nil {
val++
}
}
}
return nil
})
return val
}
// RemoveTags deletes tag from index bucket and file information.
// It should be executed on every file deletion to keep DB consistant.
func RemoveTags(key, list string) error {
return db.Update(func(tx *bolt.Tx) error {
if b := tx.Bucket(bucket).Bucket([]byte(key)); b != nil {
if t := b.Bucket([]byte("tags")); t != nil {
for _, v := range strings.Split(list, ",") {
tag := []byte(strings.ToLower(strings.TrimSpace(v)))
if s := tx.Bucket(tags).Bucket(tag); s != nil {
log.Check(log.DebugLevel, "Removing tag "+string(tag)+" from index bucket", s.Delete(tag))
}
log.Check(log.DebugLevel, "Removing tag "+string(tag)+" from file information", t.Delete([]byte(key)))
}
}
}
return nil
})
}
// Tag returns a list of artifacts that contains requested tags.
// If no records found list will be empty.
func Tag(query string) (list []string, err error) {
err = db.View(func(tx *bolt.Tx) error {
if b := tx.Bucket(tags).Bucket([]byte(strings.ToLower(query))); b != nil {
return b.ForEach(func(k, v []byte) error {
list = append(list, string(k))
return nil
})
}
return fmt.Errorf("Tag not found")
})
return list, err
}
|
package main
import (
"GoRepositories/Mongo"
"errors"
"fmt"
"log"
"time"
"gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
// "errors"
// "fmt"
// "log"
// "strconv"
// "strings"
// "time"
// "GoRepositories/Mongo"
// "gopkg.in/mgo.v2"
// "gopkg.in/mgo.v2/bson"
)
func main() {
// connectionString := "mongodb://10.0.12.90:27117,10.0.11.124:27117/DigitalFleet/?replicaSet=replDigital;maxPoolSize=10000;w=1;readPreference=primaryPreferred;journal=true"
connectionString := "mongodb://127.0.0.1:27017/DigitalFleet/?maxPoolSize=10000;w=1;readPreference=primaryPreferred;journal=true"
fmt.Printf("started print\n")
collection := Mongo.InitCollectionAndDatabaseFromConnectionString(connectionString, "Users")
findQuery, _ := findUserQuery("Demo", "User", "demo123@digitalfleet.com", "5589532fe645110ffc4d305f")
item := new(User)
// personQuery := Mongo.FindOne(collection, bson.M{})
errQuery := Mongo.FindOne(collection, findQuery).One(&item)
if errQuery != nil {
fmt.Println("error FindOne", errQuery)
}
fmt.Println(item)
// db, _ := Mongo.InitDatabaseFromConnection(connectionString, "GoLangTest")
// collection := Mongo.InitCollectionFromConnectionString(connectionString, "GoLangTest", "people")
// lifeCycleTest(collection)
// fmt.Println("")
// fmt.Println("")
// fmt.Println("")
// fmt.Println("")
// get(collection, bson.M{"name": "Ale"})
}
func lifeCycleTest(collection *mgo.Collection) {
ID1 := bson.NewObjectId().Hex()
// newPerson, _ := bson.Marshal(&Person{ID1, "TestUser" + ID1, "+55 53 8116 9639", ID1, time.Now().UTC()})
newPerson := &Person{ID1, "TestUser" + ID1, "+55 53 8116 9639", "test", time.Now().UTC()}
// create
insertErr := Mongo.Insert(collection, newPerson)
if insertErr != nil {
fmt.Println(insertErr)
}
findByID := bson.M{"_id": ID1}
// update
newPerson.Phone = "1234"
updateErr := Mongo.Update(collection, findByID, newPerson)
if updateErr != nil {
fmt.Println(updateErr)
}
// update by query
updateQuery := bson.M{"$set": bson.M{"phone": "12345"}}
updateinfo, updateQueryError := Mongo.UpdateByQuery(collection, findByID, updateQuery)
if updateQueryError != nil {
fmt.Println(updateQueryError)
}
fmt.Println("updateinfo : ", updateinfo)
// update and return
fmt.Println("UpdateOneAndReturn")
updateReturnQuery := bson.M{"$set": bson.M{"phone": "123456"}}
findUpdateAndReturnQuery := bson.M{"testid": "test"}
returnItems, updatereturninfo, updateReturnQueryError := Mongo.UpdateOneAndReturn(collection, findUpdateAndReturnQuery, updateReturnQuery)
if updateReturnQueryError != nil {
fmt.Println(updateReturnQueryError)
}
fmt.Println("updatereturninfo : ", updatereturninfo)
fmt.Println("updatereturnitem : ", returnItems, returnItems["name"])
// deleteQuery := bson.M{"testid": "test"}
// deleteInfo, deleteErr := Mongo.DeleteByQuery(collection, deleteQuery)
// if deleteErr != nil {
// fmt.Println(deleteErr)
// }
// fmt.Println("deleteInfo : ", deleteInfo)
}
func get(collection *mgo.Collection, query bson.M) {
// result1 := Person{}
queryOptions := Mongo.QueryOptions{}
queryOptions.SetQueryOptionDefaults()
queryOptions.Skip = 0
queryOptions.Projection = bson.M{"testid": 0}
//queryOptions.Sort = "-datecreated"
// queryOptions.Sort = ""
fmt.Println("Get all")
// itemss, err2 := Mongo.Find(collection, bson.M{}, queryOptions)
// if err2 != nil {
// log.Fatal(err2)
// }
person := new(Person)
// personQuery := Mongo.FindOne(collection, bson.M{})
errQuery := Mongo.FindOne(collection, bson.M{}).One(&person)
if errQuery != nil {
fmt.Println("error FindOne", errQuery)
}
fmt.Println("**********************************************************************")
fmt.Println(person.ID, person.Name, person.Phone, person.TestID, person.DateCreated)
fmt.Println("**********************************************************************")
//for i := range itemss {
// name := itemss[i]["name"].(string)
// person := itemss[i].(Person)
//name := asString(itemss[i], "name1")
// fmt.Println("**********************************************************************")
// fmt.Println(person.Name, itemss[i]["phone"], itemss[i]["testid"], itemss[i]["datecreated"])
// }
// fmt.Println("Get first")
// findFirst, errFirst := Mongo.FindOne(collection, bson.M{"_id": "5705b6bd1d505c08ec68d2c9j"})
// if errFirst != nil {
// //log.Fatal(errFirst)
// fmt.Println(errFirst)
// fmt.Println(findFirst)
// if findFirst == nil {
// fmt.Println("yes")
// }
// } else {
// fmt.Println(findFirst["name"], findFirst["phone"], findFirst["testid"], findFirst["datecreated"])
// }
fmt.Println("Get byId")
person1 := new(Person)
errByID := Mongo.FindByID(collection, "570ea1ef1d505c12a8c380e8").One(&person1)
if errByID != nil {
log.Println(errByID)
} else {
fmt.Println("**********************************************************************")
fmt.Println(person1.ID, person1.Name, person1.Phone, person1.TestID, person1.DateCreated)
fmt.Println("**********************************************************************")
}
fmt.Println("Get Count")
findCount, errCount := Mongo.Count(collection, bson.M{"_id": "570ea1ef1d505c12a8c380e8"})
if errCount != nil {
fmt.Println(errCount)
}
fmt.Println(findCount)
fmt.Println("Get Distinct")
var result []string
findDistinct, errDistinct := Mongo.Distinct(collection, bson.M{}, "name", result)
if errDistinct != nil {
fmt.Println(errDistinct)
}
fmt.Println(findDistinct)
}
// data bson.M,
// func asString1(data bson.M, propertyNames []string) string {
// //var itemValue interface{}
//
// itemValue := data
// for i := range propertyNames {
// propertyName := itemValue[propertyName]["test"]
// itemValue, ok := itemValue[propertyName]["test"]
// if ok == false {
// return ""
// }
// }
// var test string
// test = itemValue.(string)
// value, ok1 := itemValue.(string)
//
// //value, ok := data[propertyName].(string)
// if ok1 == false {
// return ""
// }
// return value
// }
// func asString(data bson.M, propertyName string) string {
// value, ok := data[propertyName].(string)
// if ok == false {
// return ""
// }
// return value
// }
// Person test
type Person struct {
ID string `bson:"_id"`
Name string
Phone string
TestID string
DateCreated time.Time
}
func findUserQuery(firstName string, lastName string, email string, tenantID string) (bson.M, error) {
findQuery := bson.M{}
if tenantID == "" {
return findQuery, errors.New("tenantid cannot be empty")
}
findQuery["TenantId"] = tenantID
if firstName != "" {
findQuery["FirstName"] = getRegexQuery("FirstName", firstName)
}
if lastName != "" {
findQuery["LastName"] = getRegexQuery("LastName", lastName)
}
if email != "" {
findQuery["Email"] = getRegexQuery("Email", email)
}
return findQuery, nil
}
func getRegexQuery(propertyName string, propertyValue string) bson.M {
regexQuery := bson.RegEx{}
regexQuery.Pattern = propertyValue + "$"
regexQuery.Options = "i"
//return bson.M{propertyName: bson.M{"$regex": regexQuery}}
return bson.M{"$regex": regexQuery}
}
// User model
type User struct {
// (ReadOnly) Id of the document, created by system utilizing Mongo Bson Id
ID string `json:"Id" bson:"_id" binding:"required"`
// (ReadOnly) Date the document was created (UTC)
DateCreated time.Time `json:"DateCreated" bson:"DateCreated" binding:"required"`
// (ReadOnly) Date the document was modified (UTC)
DateModified time.Time `json:"DateModified" bson:"DateModified"`
// (ReadOnly) What user modified the document
UserModified string `json:"UserModified" bson:"UserModified,omitempty"`
// (ReadOnly) Has the record been deleted
IsDeleted bool `json:"IsDeleted" bson:"IsDeleted,omitempty"`
// (Migration/Sync only)ExternalId is used to sync with external systems (Not used for anything internally)
ExternalID string `json:"ExternalId" bson:"ExternalId,omitempty"`
// (Migration/Sync only)ExternalNumber is used to sync with external systems (Not used for anything internally)
ExternalNumber string `json:"ExternalNumber" bson:"ExternalNumber,omitempty"`
// (Migration/Sync only)used to validate systems and keep them in sync (Not used for anything internally)
HashCode string `json:"HashCode" bson:"HashCode,omitempty"`
// TenantID pertains to the tenant the document belongs to. this is not serialized out
TenantID string `json:"-" bson:"TenantId"`
Title string `json:"Title" bson:"Title"`
FirstName string `json:"FirstName" bson:"FirstName"`
LastName string `json:"LastName" bson:"LastName"`
UserName string `json:"UserName" bson:"UserName"`
Email string `json:"Email" bson:"Email"`
Type string `json:"Type" bson:"Type"`
TimeZone string `json:"TimeZone" bson:"TimeZone"`
CommunicationPreference string `json:"CommunicationPreference" bson:"CommunicationPreference"`
IsDriver bool `json:"IsDriver" bson:"IsDriver"`
Pin string `json:"Pin" bson:"Pin"`
Department string `json:"Department" bson:"Department"`
HireDate *time.Time `json:"HireDate" bson:"HireDate"`
CustomerID string `json:"Customer_Id" bson:"Customer_Id"`
HomePlantID string `json:"Home_Plant_Id" bson:"Home_Plant_Id"`
VehicleID string `json:"Vehicle_Id" bson:"Vehicle_Id"`
PrimaryCustomerIds []string `json:"Primary_Customer_Ids" bson:"-"`
PrimaryJobIds []string `json:"Primary_Job_Ids" bson:"-"`
PrimaryOrderIds []string `json:"Primary_Order_Ids" bson:"-"`
PrimaryTicketIds []string `json:"Primary_Ticket_Ids" bson:"-"`
}
|
package main
import (
"edjubert/CodeGenerator/functions"
"edjubert/CodeGenerator/parse"
)
func main() {
n, name, prefix, ext := parse.Flags()
functions.WriteCSV(*name, *n, *prefix, *ext)
}
|
package webserver
import (
"net/http"
)
type handlerContainer interface {
PreviewHandler(w http.ResponseWriter, r *http.Request)
}
func newHandlerContainer(store Pagestorer) handlerContainer {
return newService(store)
}
func getRoutes(s handlerContainer) Routes {
var routes = Routes{
{
Name: "BlogIndex",
Method: "GET",
Pattern: "/",
HandlerFunc: s.PreviewHandler,
},
{
Name: "CategoryIndex",
Method: "GET",
Pattern: "/{folder}/",
HandlerFunc: s.PreviewHandler,
},
{
Name: "PagePreview",
Method: "GET",
Pattern: "/{folder}/{slug}",
HandlerFunc: s.PreviewHandler,
},
}
return routes
}
|
package 路径和问题
// ---------------------- 记忆化搜索 ----------------------
const INF = 100000000000
var maxSumStartWithNode map[*TreeNode]int
func maxPathSum(root *TreeNode) int {
maxSumStartWithNode = make(map[*TreeNode]int)
return getMaxPathSum(root)
}
func getMaxPathSum(root *TreeNode) int {
if root == nil {
return -INF
}
maxSum := root.Val
if leftTreeSum := maxSumStartWith(root.Left); leftTreeSum > 0 {
maxSum += leftTreeSum
}
if rightTreeSum := maxSumStartWith(root.Right); rightTreeSum > 0 {
maxSum += rightTreeSum
}
return max(
maxSum,
getMaxPathSum(root.Left),
getMaxPathSum(root.Right),
)
}
func maxSumStartWith(root *TreeNode) int {
if root == nil {
return 0
}
if sum, ok := maxSumStartWithNode[root]; ok {
return sum
}
maxSumStartWithNode[root] = max(
maxSumStartWith(root.Left),
maxSumStartWith(root.Right),
0,
) + root.Val
return maxSumStartWithNode[root]
}
func max(arr ...int) int {
if len(arr) == 1 {
return arr[0]
}
a := arr[0]
b := max(arr[1:]...)
if a < b {
return b
}
return a
}
// ------------- 在求取 maxSumStartWith 过程中得出答案 -------------
const INF = 100000000000
var maxSumOfPath int
func maxPathSum(root *TreeNode) int {
maxSumOfPath = -INF
getMaxSumStartWithAndFormMaxSumOfPath(root)
return maxSumOfPath
}
func getMaxSumStartWithAndFormMaxSumOfPath(root *TreeNode) int {
if root == nil {
return 0
}
sumOfLeftTreePath := getMaxSumStartWithAndFormMaxSumOfPath(root.Left)
sumOfRightTreePath := getMaxSumStartWithAndFormMaxSumOfPath(root.Right)
maxSumOfPath = max(
maxSumOfPath,
root.Val+max(sumOfLeftTreePath, 0)+max(sumOfRightTreePath, 0),
)
return max(sumOfLeftTreePath, sumOfRightTreePath, 0) + root.Val
}
func max(arr ...int) int {
if len(arr) == 1 {
return arr[0]
}
a := arr[0]
b := max(arr[1:]...)
if a < b {
return b
}
return a
}
/*
题目链接: https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/
*/
|
package gov
import sdk "github.com/irisnet/irishub/types"
var _ Proposal = (*SoftwareUpgradeProposal)(nil)
type SoftwareUpgradeProposal struct {
BasicProposal
ProtocolDefinition sdk.ProtocolDefinition `json:"protocol_definition"`
}
func (sp SoftwareUpgradeProposal) GetProtocolDefinition() sdk.ProtocolDefinition {
return sp.ProtocolDefinition
}
func (sp *SoftwareUpgradeProposal) SetProtocolDefinition(upgrade sdk.ProtocolDefinition) {
sp.ProtocolDefinition = upgrade
}
|
//go:generate jwg -output model_json.go -transcripttag swagger .
//go:generate qbg -output model_query.go -usedatastorewrapper .
package favcliptools
import (
"context"
"encoding/json"
"fmt"
"testing"
"go.mercari.io/datastore"
"go.mercari.io/datastore/boom"
"go.mercari.io/datastore/testsuite"
)
var _ datastore.PropertyTranslator = userID(0)
var _ json.Marshaler = userID(1)
var _ json.Unmarshaler = (*userID)(nil)
type contextClient struct{}
const kindUser = "User"
type userID int64
// User kind
// +jwg
// +qbg
type User struct {
ID userID `datastore:"-" boom:"id" json:"id"`
Name string `json:"name"`
MentorID userID `json:"mentorID"`
}
func (id userID) ToPropertyValue(ctx context.Context) (interface{}, error) {
client := ctx.Value(contextClient{}).(datastore.Client)
key := client.IDKey(kindUser, int64(id), nil)
return key, nil
}
func (id userID) FromPropertyValue(ctx context.Context, p datastore.Property) (dst interface{}, err error) {
key, ok := p.Value.(datastore.Key)
if !ok {
return nil, datastore.ErrInvalidEntityType
}
return userID(key.ID()), nil
}
func (id userID) MarshalJSON() ([]byte, error) {
jsonNumber := json.Number(fmt.Sprintf("%d", int64(id)))
return json.Marshal(jsonNumber)
}
func (id *userID) UnmarshalJSON(b []byte) error {
var jsonNumber json.Number
err := json.Unmarshal(b, &jsonNumber)
if err != nil {
return err
}
v, err := jsonNumber.Int64()
if err != nil {
return err
}
*id = userID(v)
return nil
}
// TestSuite contains all the test cases that this package provides.
var TestSuite = map[string]testsuite.Test{
"FavclipTools": favclipTools,
}
func init() {
testsuite.MergeTestSuite(TestSuite)
}
func favclipTools(ctx context.Context, t *testing.T, client datastore.Client) {
defer func() {
err := client.Close()
if err != nil {
t.Fatal(err)
}
}()
// qbg using client.Context internally
ctx = context.WithValue(ctx, contextClient{}, client)
client.SetContext(ctx)
bm := boom.FromClient(ctx, client)
user := &User{
ID: userID(100),
Name: "foobar",
MentorID: userID(200),
}
_, err := bm.Put(user)
if err != nil {
t.Fatal(err)
}
b, err := json.Marshal(user)
if err != nil {
t.Fatal(err)
}
if v := string(b); v != `{"id":100,"name":"foobar","mentorID":200}` {
t.Errorf("unexpected: %v", v)
}
user = &User{}
err = json.Unmarshal(b, user)
if err != nil {
t.Fatal(err)
}
if v := int64(user.ID); v != 100 {
t.Errorf("unexpected: %v", v)
}
if v := user.Name; v != "foobar" {
t.Errorf("unexpected: %v", v)
}
if v := int64(user.MentorID); v != 200 {
t.Errorf("unexpected: %v", v)
}
{ // for jwg
b := NewUserJSONBuilder()
b.Add(b.ID)
b.Add(b.MentorID)
userJSON, err := b.Convert(user)
if err != nil {
t.Fatal(err)
}
if v := int64(userJSON.ID); v != 100 {
t.Errorf("unexpected: %v", v)
}
// removed
if v := userJSON.Name; v != "" {
t.Errorf("unexpected: %v", v)
}
if v := int64(userJSON.MentorID); v != 200 {
t.Errorf("unexpected: %v", v)
}
}
{ // for qbg
b := NewUserQueryBuilder(client)
b.MentorID.Equal(userID(200))
var list []*User
_, err = bm.GetAll(b.Query(), &list)
if err != nil {
t.Fatal(err)
}
if v := len(list); v != 1 {
t.Errorf("unexpected: %v", v)
}
}
}
|
package main
import "fmt"
func main() {
var atai1 intType = 3
var atai2 intType = 1
fmt.Println(add(atai1, atai2))
}
type intType int
func add(args ...interface{}) intType {
var ans intType
for _, v := range args {
ans += v.(intType)
}
return ans
}
|
package service
import (
"bytes"
"context"
"strings"
"testing"
"time"
"github.com/go-pkgz/repeater"
"github.com/go-pkgz/repeater/strategy"
"github.com/robfig/cron/v3"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"github.com/umputun/cronn/app/crontab"
"github.com/umputun/cronn/app/resumer"
"github.com/umputun/cronn/app/service/mocks"
)
func TestScheduler_Do(t *testing.T) {
cr := &mocks.Cron{}
resmr := &mocks.Resumer{}
parser := &mocks.CrontabParser{}
svc := Scheduler{
Cron: cr,
Resumer: resmr,
CrontabParser: parser,
UpdatesEnabled: false,
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
resmr.On("List").Return(nil).Once()
cr.On("Entries").Return([]cron.Entry{{}, {}, {}}).Once()
cr.On("Remove", mock.Anything).Times(3)
cr.On("Start").Once()
cr.On("Stop").Return(ctx).Once()
parser.On("List").Return([]crontab.JobSpec{
{Spec: "1 * * * *", Command: "test1"},
{Spec: "2 * * * *", Command: "test2"},
}, nil).Once()
cr.On("Schedule", mock.Anything, mock.Anything).Return(cron.EntryID(1)).Once()
cr.On("Schedule", mock.Anything, mock.Anything).Return(cron.EntryID(2)).Once()
svc.Do(ctx)
cr.AssertExpectations(t)
resmr.AssertExpectations(t)
parser.AssertExpectations(t)
}
func TestScheduler_DoIntegration(t *testing.T) {
t.Skip()
out := bytes.NewBuffer(nil)
cr := cron.New()
parser := crontab.New("testfiles/crontab", time.Minute)
res := resumer.New("/tmp", false)
notif := &mocks.Notifier{}
notif.On("Send", mock.Anything, mock.Anything).Return(nil)
notif.On("IsOnError").Return(true)
notif.On("IsOnCompletion").Return(false)
svc := Scheduler{
Cron: cr,
Resumer: res,
CrontabParser: parser,
UpdatesEnabled: false,
Notifier: notif,
Stdout: out,
}
ctx, cancel := context.WithTimeout(context.Background(), 110*time.Second)
defer cancel()
svc.Do(ctx)
t.Log(out.String())
assert.Contains(t, out.String(), "{echo 123} 123\n")
notif.AssertExpectations(t)
}
func TestScheduler_execute(t *testing.T) {
svc := Scheduler{Repeater: repeater.New(&strategy.Once{}), EnableLogPrefix: true}
wr := bytes.NewBuffer(nil)
err := svc.executeCommand("echo 123", wr)
require.NoError(t, err)
assert.Equal(t, "{echo 123} 123\n", wr.String())
svc = Scheduler{Repeater: repeater.New(&strategy.Once{}), EnableLogPrefix: false}
wr = bytes.NewBuffer(nil)
err = svc.executeCommand("echo 123", wr)
require.NoError(t, err)
assert.Equal(t, "123\n", wr.String())
}
func TestScheduler_executeFailedNotFound(t *testing.T) {
svc := Scheduler{Repeater: repeater.New(&strategy.Once{})}
wr := bytes.NewBuffer(nil)
err := svc.executeCommand("no-such-command", wr)
require.Error(t, err)
assert.Contains(t, wr.String(), "not found")
}
func TestScheduler_executeFailedExitCode(t *testing.T) {
svc := Scheduler{MaxLogLines: 10, Repeater: repeater.New(&strategy.Once{})}
wr := bytes.NewBuffer(nil)
err := svc.executeCommand("testfiles/fail.sh", wr)
require.Error(t, err)
assert.Contains(t, wr.String(), "TestScheduler_executeFailed")
t.Log(err)
assert.Equal(t, 10+3, len(strings.Split(err.Error(), "\n")))
assert.Equal(t, "TestScheduler_executeFailed 14", strings.Split(err.Error(), "\n")[12])
}
func TestScheduler_jobFunc(t *testing.T) {
resmr := &mocks.Resumer{}
scheduleMock := &scheduleMock{next: time.Date(2020, 7, 21, 16, 30, 0, 0, time.UTC)}
wr := bytes.NewBuffer(nil)
svc := Scheduler{MaxLogLines: 10, Stdout: wr, Resumer: resmr,
Repeater: repeater.New(&strategy.Once{}), DeDup: NewDeDup(true), EnableLogPrefix: true}
resmr.On("List").Return(nil).Once()
resmr.On("OnStart", "echo 123").Return("resume.file", nil).Once()
resmr.On("OnFinish", "resume.file").Return(nil).Once()
svc.jobFunc(crontab.JobSpec{Spec: "@startup", Command: "echo 123"}, scheduleMock).Run()
assert.Equal(t, "{echo 123} 123\n", wr.String())
}
func TestScheduler_jobFuncFailed(t *testing.T) {
resmr := &mocks.Resumer{}
notif := &mocks.Notifier{}
notif.On("Send", mock.Anything, mock.Anything).Return(nil)
notif.On("IsOnError").Return(true)
notif.On("MakeErrorHTML", "@startup", "no-such-thing", mock.MatchedBy(func(s string) bool {
return strings.Contains(s, "not found")
})).Return("email msg", nil)
scheduleMock := &scheduleMock{next: time.Date(2020, 7, 21, 16, 30, 0, 0, time.UTC)}
wr := bytes.NewBuffer(nil)
svc := Scheduler{MaxLogLines: 10, Stdout: wr, Resumer: resmr, Notifier: notif,
Repeater: repeater.New(&strategy.Once{}), DeDup: NewDeDup(true)}
resmr.On("List").Return(nil).Once()
resmr.On("OnStart", "no-such-thing").Return("resume.file", nil).Once()
resmr.On("OnFinish", "resume.file").Return(nil).Once()
svc.jobFunc(crontab.JobSpec{Spec: "@startup", Command: "no-such-thing"}, scheduleMock).Run()
assert.Contains(t, wr.String(), "not found")
notif.AssertExpectations(t)
}
type scheduleMock struct {
next time.Time
}
func (s *scheduleMock) Next(time.Time) time.Time {
return s.next
}
func TestScheduler_notifyOnError(t *testing.T) {
notif := &mocks.Notifier{}
notif.On("Send", mock.Anything, mock.Anything).Return(nil).Once()
notif.On("IsOnError").Return(true)
notif.On("MakeErrorHTML", "@startup", "no-such-thing", "message").Return("email msg", nil)
svc := Scheduler{MaxLogLines: 10, Notifier: notif, Repeater: repeater.New(&strategy.Once{})}
err := svc.notify(crontab.JobSpec{Spec: "@startup", Command: "no-such-thing"}, "message")
require.NoError(t, err)
notif.AssertExpectations(t)
}
func TestScheduler_notifyOnCompletion(t *testing.T) {
notif := &mocks.Notifier{}
notif.On("Send", mock.Anything, mock.Anything).Return(nil).Once()
notif.On("IsOnCompletion").Return(true)
notif.On("MakeCompletionHTML", "@startup", "ls -la").Return("email msg", nil)
svc := Scheduler{MaxLogLines: 10, Notifier: notif, Repeater: repeater.New(&strategy.Once{})}
err := svc.notify(crontab.JobSpec{Spec: "@startup", Command: "ls -la"}, "")
require.NoError(t, err)
notif.AssertExpectations(t)
}
func TestScheduler_DoWithReload(t *testing.T) {
cr := &mocks.Cron{}
resmr := &mocks.Resumer{}
parser := &mocks.CrontabParser{}
svc := Scheduler{
Cron: cr,
Resumer: resmr,
CrontabParser: parser,
UpdatesEnabled: true,
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
resmr.On("List").Return(nil).Once()
cr.On("Entries").Return([]cron.Entry{{}, {}, {}}).Times(2)
cr.On("Remove", mock.Anything).Times(6)
cr.On("Start").Once()
cr.On("Stop").Return(ctx).Once()
parser.On("String").Return("parser")
parser.On("List").Return([]crontab.JobSpec{
{Spec: "1 * * * *", Command: "test1"},
{Spec: "2 * * * *", Command: "test2"},
}, nil).Once()
parser.On("List").Return([]crontab.JobSpec{
{Spec: "11 * * * *", Command: "test1"},
}, nil).Once()
upCh := func() <-chan []crontab.JobSpec {
ch := make(chan []crontab.JobSpec, 1)
ch <- []crontab.JobSpec{{Command: "cmd", Spec: "@reboot"}}
close(ch)
return ch
}()
parser.On("Changes", mock.Anything).Return(upCh, nil).Once()
cr.On("Schedule", mock.Anything, mock.Anything).Return(cron.EntryID(1)).Times(2)
cr.On("Schedule", mock.Anything, mock.Anything).Return(cron.EntryID(2)).Once()
svc.Do(ctx)
cr.AssertExpectations(t)
resmr.AssertExpectations(t)
parser.AssertExpectations(t)
}
func TestScheduler_DoWithResume(t *testing.T) {
cr := &mocks.Cron{}
resmr := &mocks.Resumer{}
parser := &mocks.CrontabParser{}
svc := Scheduler{
Cron: cr,
Resumer: resmr,
CrontabParser: parser,
UpdatesEnabled: false,
Repeater: repeater.New(&strategy.Once{}),
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
resmr.On("List").Return([]resumer.Cmd{{Command: "cmd1", Fname: "f1"}, {Command: "cmd2", Fname: "f2"}}).Once()
cr.On("Entries").Return([]cron.Entry{}).Times(1)
parser.On("List").Return([]crontab.JobSpec{}, nil).Once()
cr.On("Start").Once()
cr.On("Stop").Return(ctx).Once()
resmr.On("OnFinish", "f1").Return(nil).Once()
resmr.On("OnFinish", "f2").Return(nil).Once()
svc.Do(ctx)
cr.AssertExpectations(t)
resmr.AssertExpectations(t)
parser.AssertExpectations(t)
}
|
package fake_uploader
import (
"errors"
"net/url"
)
type FakeUploader struct {
UploadedFileLocations []string
UploadUrls []*url.URL
UploadSize int64
alwaysFail bool
}
func New() *FakeUploader {
return &FakeUploader{}
}
func (uploader *FakeUploader) Upload(fileLocation string, destinationUrl *url.URL) (int64, error) {
if uploader.alwaysFail {
return 0, errors.New("I accidentally the upload")
}
uploader.UploadUrls = append(uploader.UploadUrls, destinationUrl)
uploader.UploadedFileLocations = append(uploader.UploadedFileLocations, fileLocation)
return uploader.UploadSize, nil
}
func (uploader *FakeUploader) AlwaysFail() {
uploader.alwaysFail = true
}
|
package main
import (
"fmt"
"git.roosoft.com/bitcoin/hd-wallets/lib"
seed "git.roosoft.com/bitcoin/hd-wallets/1-seed"
masterkey "git.roosoft.com/bitcoin/hd-wallets/2-masterPrivateKey"
childkeys "git.roosoft.com/bitcoin/hd-wallets/3-childKeys"
xpub "git.roosoft.com/bitcoin/hd-wallets/4-xpub"
)
func doSeed() {
fmt.Printf("\n\n1. Seed\n")
fmt.Printf("-------\n")
fmt.Printf("%-9s %s\n", "mnemonic", seed.GetMnemonic())
fmt.Printf("%-9s %x\n", "seed", seed.GetSeed())
}
func doMasterKey() {
fmt.Printf("\n\n2. Master key\n")
fmt.Printf("-------------\n")
fmt.Printf("%-12s %x\n", "private key", masterkey.GetPrivateKey())
fmt.Printf("%-12s %x\n", "chain code", masterkey.GetChainCode())
fmt.Printf("%-12s %x\n", "public key", masterkey.GetPublicKey())
}
func doChildKeys() {
fmt.Printf("\n\n3. Child keys\n")
fmt.Printf("-------------\n\n")
fmt.Printf("---BIP 44 ---\n")
// m/44h/0h/0h/0/*
for i := uint32(0); i < 20; i++ {
path, address, segwit32, segwitNested, _ := childkeys.GetChild(lib.PurposeBIP44, lib.CoinTypeBTC, 0, 0, i)
fmt.Printf("%-16s %-34s %s %s\n", path, address, segwitNested, segwit32)
}
fmt.Printf("\n\n---BIP 84 ---\n")
// m/84h/0h/0h/0/*
for i := uint32(0); i < 20; i++ {
path, address, segwit32, segwitNested, _ := childkeys.GetChild(lib.PurposeBIP84, lib.CoinTypeBTC, 0, 0, i)
fmt.Printf("%-16s %-34s %-34s %-43s\n", path, address, segwitNested, segwit32)
}
}
func doXpub() {
fmt.Printf("\n\n4. xpub\n")
fmt.Printf("-------\n\n")
xpriv := xpub.GetXpriv(lib.PurposeBIP84, lib.CoinTypeBTC, 0, 0, 0)
xpub := xpub.GetXpub(lib.PurposeBIP84, lib.CoinTypeBTC, 0, 0, 0)
fmt.Printf("%-6s %s\n", "xpriv", xpriv)
fmt.Printf("%-6s %s\n", "xpub", xpub)
}
func main() {
doSeed()
doMasterKey()
doChildKeys()
doXpub()
}
|
package cw
import (
"fmt"
)
func AdjacentElementsProduct() {
data := []int{-23, 4, -3, 8, -12}
fmt.Println(adjacentElementsProduct(data))
}
/**
Given an array of integers,
find the pair of adjacent elements
that has the largest product and return that product.
*/
func adjacentElementsProduct(inputArray []int) int {
n := len(inputArray)
switch n {
case 0:
return 0
case 1:
return inputArray[0]
case 2:
return inputArray[0] * inputArray[1]
}
largest := inputArray[0] * inputArray[1]
for i := 1; i < n-1; i++ {
current := inputArray[i] * inputArray[i+1]
if largest < current {
largest = current
}
}
return largest
}
|
package main
import "fmt"
type user struct {
name string
address string
}
func updateValues(u user) user {
u.name = "diwakar"
u.address = "jaipur"
return u
}
func main() {
u := user{name: "ravi", address: "abc"}
u = updateValues(u)
fmt.Println(u)
}
|
package analyze
import (
"context"
"github.com/jmoiron/sqlx"
"github.com/moyrne/tebot/internal/database"
"github.com/moyrne/tebot/internal/models"
"github.com/moyrne/weather"
"github.com/pkg/errors"
"strings"
)
var replacer = strings.NewReplacer("绑定位置", "", " ", "", "\t", "")
func BindArea(ctx context.Context, params Params) (string, error) {
area := replacer.Replace(params.Message)
if area == "" {
return "模板：绑定地区 深圳", nil
}
if err := database.NewTransaction(ctx, func(ctx context.Context, tx *sqlx.Tx) error {
_, err := weather.GetCityID(area)
if err != nil {
return errors.WithStack(err)
}
return models.UpdateArea(ctx, tx, params.QUID, area)
}); err != nil {
return "", err
}
return "绑定成功：" + area, nil
}
|
package core
import (
"er"
"math/rand"
)
func prfInit(me *gameImp) *er.Err {
me.lg.Dbg("Enter Round Finish phase")
if me.gd.Round >= me.gd.MinRounds {
if rand.Intn(6)+1-me.gd.MinRounds > 3-me.gd.Round {
return me.gotoPhase(_P_GAME_SETTLEMENT)
}
}
return me.gotoPhase(_P_ROUNDS_START)
}
|
/**
*@Author: haoxiongxiao
*@Date: 2019/1/27
*@Description: CREATE GO FILE api_services
*/
package hotel_api_services
type CreateOrderApiService struct{}
type CreateOrderReqParams struct {
CustomerName string `json:"customerName"`
RatePlanId string `json:"ratePlanId"`
HotelId string `json:"hotelId"`
SpecialRemarks string `json:"specialRemarks"`
ContactPhone string `json:"contactPhone"`
ContactEmail string `json:"contactEmail"`
InDate string `json:"inDate"`
OutDate string `json:"outDate"`
}
|
package templates
import (
"testing"
)
const (
templatesPath = "."
templateName = "test_template"
)
func Test_GetTemplateMeta(t *testing.T) {
var expectedTemplateSubject = "TestTemplateSubject"
// Get template Metadata
var templateMeta = getTemplateMeta(templatesPath + "/meta/" + templateName + ".json")
if templateMeta.Subject == "" {
t.Fatal("Template Meta cannot be found")
}
if templateMeta.Subject != expectedTemplateSubject {
t.Fatalf("Template Meta is found but subject \"%s\" not the one expected \"%s\"", templateMeta.Subject, expectedTemplateSubject)
}
}
func Test_GetBodySkeleton(t *testing.T) {
// Get template Metadata
var templateMeta = getTemplateMeta(templatesPath + "/meta/" + templateName + ".json")
var templateFileName = templatesPath + "/html/" + templateMeta.TemplateFilename
var templateBody = getBodySkeleton(templateFileName)
if templateBody == "" {
t.Fatalf("Template Body cannot be found: %s", templateFileName)
}
}
|
package main
var (
board [8][8]byte
done bool
)
func printBoard() {
for i:=0; i<8; i++ {
for j:=0; j<8; j++ {
print(" ", board[i][j])
}
println()
}
}
func move(x, y int, n byte) {
if !done && 0<=x && x<8 && 0<=y && y<8 && board[x][y] == 0 {
board[x][y] = n
if n == 64 {
printBoard()
done = true
return
}
move(x-1,y+2,n+1)
move(x-2,y+1,n+1)
move(x-2,y-1,n+1)
move(x-1,y-2,n+1)
move(x+1,y-2,n+1)
move(x+2,y-1,n+1)
move(x+2,y+1,n+1)
move(x+1,y+2,n+1)
board[x][y] = 0
}
}
func main() {
move(0, 0, 1)
}
|
/*
** description("").
** copyright('open-im,www.open-im.io').
** author("fg,Gordon@tuoyun.net").
** time(2021/9/15 10:28).
*/
package manage
import (
pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
"context"
"github.com/gin-gonic/gin"
"net/http"
"strings"
)
type paramsDeleteUsers struct {
OperationID string `json:"operationID" binding:"required"`
DeleteUidList []string `json:"deleteUidList" binding:"required"`
}
type paramsGetAllUsersUid struct {
OperationID string `json:"operationID" binding:"required"`
}
func DeleteUser(c *gin.Context) {
params := paramsDeleteUsers{}
if err := c.BindJSON(¶ms); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
log.InfoByKv("DeleteUser req come here", params.OperationID, "DeleteUidList", params.DeleteUidList)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn)
//defer etcdConn.Close()
req := &pbUser.DeleteUsersReq{
OperationID: params.OperationID,
DeleteUidList: params.DeleteUidList,
Token: c.Request.Header.Get("token"),
}
RpcResp, err := client.DeleteUsers(context.Background(), req)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call delete users rpc server failed"})
return
}
log.InfoByKv("call delete user rpc server is success", params.OperationID, "resp args", RpcResp.String())
resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "failedUidList": RpcResp.FailedUidList}
c.JSON(http.StatusOK, resp)
}
func GetAllUsersUid(c *gin.Context) {
params := paramsGetAllUsersUid{}
if err := c.BindJSON(¶ms); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
log.InfoByKv("GetAllUsersUid req come here", params.OperationID)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn)
//defer etcdConn.Close()
req := &pbUser.GetAllUsersUidReq{
OperationID: params.OperationID,
Token: c.Request.Header.Get("token"),
}
RpcResp, err := client.GetAllUsersUid(context.Background(), req)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error(), "uidList": []string{}})
return
}
log.InfoByKv("call GetAllUsersUid rpc server is success", params.OperationID, "resp args", RpcResp.String())
resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "uidList": RpcResp.UidList}
c.JSON(http.StatusOK, resp)
}
|
package cmd
import (
"errors"
"fmt"
"github.com/bbrowning/ocf/pkg/app"
"github.com/spf13/cobra"
)
const (
unbindCmdLong = `
Unbind a service from an application.
This command emulates Cloud Foundry's 'cf unbind-service' command but
targeting OpenShift instead. Not all the Cloud Foundry options are
supported; those that are supported are documented in the usage
information below.`
unbindCmdExample = `
# Unbind the 'rails-postgres' service from the application 'my-app'
%[1]s unbind-service my-app rails-postgres`
)
type UnbindConfig struct {
Application string
Service string
}
func init() {
RootCmd.AddCommand(newUnbindCmd("ocf"))
}
func newUnbindCmd(commandName string) *cobra.Command {
config := &UnbindConfig{}
cmd := &cobra.Command{
Use: "unbind-service",
Short: "Unbind a service from an application.",
Long: unbindCmdLong,
Example: fmt.Sprintf(unbindCmdExample, commandName),
Run: func(cmd *cobra.Command, args []string) {
err := config.Run(args)
if err != nil {
fmt.Printf("err: %v\n", err)
}
},
}
return cmd
}
func (config *UnbindConfig) Run(args []string) error {
debugf("Config: %+v\n", config)
if len(args) != 2 {
return errors.New("Error: Application name and service name are required")
}
app := &app.Application{Name: args[0]}
err := app.UnbindService(args[1])
if err != nil {
return err
}
return nil
}
|
package main
func partition(head *ListNode, x int) *ListNode {
before := &ListNode{
Val: 0,
Next: nil,
}
bn := before
after := &ListNode{
Val: 0,
Next: nil,
}
an := after
for head != nil {
temp := head
head = head.Next
if temp.Val >= x {
an.Next = temp
an = an.Next
} else {
bn.Next = temp
bn = bn.Next
}
}
bn.Next = after.Next
return before.Next
}
|
// Copyright (C) 2015 Scaleway. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE.md file.
package cli
import "github.com/scaleway/scaleway-cli/pkg/commands"
var cmdInspect = &Command{
Exec: runInspect,
UsageLine: "inspect [OPTIONS] IDENTIFIER [IDENTIFIER...]",
Description: "Return low-level information on a server, image, snapshot, volume or bootscript",
Help: "Return low-level information on a server, image, snapshot, volume or bootscript.",
Examples: `
$ scw inspect my-server
$ scw inspect server:my-server
$ scw inspect --browser my-server
$ scw inspect a-public-image
$ scw inspect image:a-public-image
$ scw inspect my-snapshot
$ scw inspect snapshot:my-snapshot
$ scw inspect my-volume
$ scw inspect volume:my-volume
$ scw inspect my-image
$ scw inspect image:my-image
$ scw inspect my-server | jq '.[0].public_ip.address'
$ scw inspect $(scw inspect my-image | jq '.[0].root_volume.id')
$ scw inspect -f "{{ .PublicAddress.IP }}" my-server
$ scw --sensitive inspect my-server
`,
}
func init() {
cmdInspect.Flag.BoolVar(&inspectHelp, []string{"h", "-help"}, false, "Print usage")
cmdInspect.Flag.StringVar(&inspectFormat, []string{"f", "-format"}, "", "Format the output using the given go template")
cmdInspect.Flag.BoolVar(&inspectBrowser, []string{"b", "-browser"}, false, "Inspect object in browser")
cmdInspect.Flag.StringVar(&inspectArch, []string{"-arch"}, "*", "Specify architecture")
}
// Flags
var inspectFormat string // -f, --format flag
var inspectBrowser bool // -b, --browser flag
var inspectHelp bool // -h, --help flag
var inspectArch string // --arch flag
func runInspect(cmd *Command, rawArgs []string) error {
if inspectHelp {
return cmd.PrintUsage()
}
if len(rawArgs) < 1 {
return cmd.PrintShortUsage()
}
args := commands.InspectArgs{
Format: inspectFormat,
Browser: inspectBrowser,
Identifiers: rawArgs,
Arch: inspectArch,
}
ctx := cmd.GetContext(rawArgs)
return commands.RunInspect(ctx, args)
}
|
/**
* @program: Go
*
* @description:
*
* @author: Mr.chen
*
* @create: 2020-03-06 15:42
**/
package middleware
import "github.com/kataras/iris"
func AuthConProduct(ctx iris.Context) {
uid := ctx.GetCookie("uid")
if uid == "" {
ctx.Application().Logger().Debug("必须先登录!")
ctx.Redirect("/user/login")
return
}
ctx.Application().Logger().Debug("已经登陆")
ctx.Next()
}
|
package types
// characterSearchResponse - a partial search response from stapi
type SearchResponse struct {
Characters []Character `json:"characters"`
Species []Species `json:"species"`
}
// FetchResponse - a partial fetch response from stapi
type FetchResponse struct {
Character FullCharacter `json:"character"`
Species Species `json:"species"`
}
|
package ll3
// use doubly linked list
type MyLinkedList struct {
len int
head *Node
tail *Node
}
type Node struct {
data int
next *Node
prev *Node
}
// node can not be head in linked list
// because we can not change head of
// linked in this func
func (p *Node) insertPrev(val int) *Node {
np := &Node{
data: val,
prev: p.prev,
next: p,
}
if p.prev != nil {
p.prev.next = np
}
p.prev = np
return np
}
// node can not be tail in linked list
// because we can not change tail of
// linked in this func
func (p *Node) insertNext(val int) *Node {
np := &Node{
data: val,
prev: p,
next: p.next,
}
if p.next != nil {
p.next.prev = np
}
p.next = np
return np
}
/** Initialize your data structure here. */
func Constructor() MyLinkedList {
return MyLinkedList{}
}
/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
func (l *MyLinkedList) Get(index int) int {
if index < 0 || index >= l.len {
return -1
}
if index == 0 {
return l.head.data
}
if index == l.len-1 {
return l.tail.data
}
return l.find(index).data
}
/** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
func (l *MyLinkedList) AddAtHead(val int) {
if l.head == nil {
l.head = &Node{data: val}
l.tail = l.head
} else {
l.head = l.head.insertPrev(val)
}
l.len++
}
/** Append a node of value val to the last element of the linked list. */
func (l *MyLinkedList) AddAtTail(val int) {
if l.tail == nil {
l.tail = &Node{data: val}
l.head = l.tail
} else {
l.tail = l.tail.insertNext(val)
}
l.len++
}
/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
func (l *MyLinkedList) AddAtIndex(index int, val int) {
// fix index less than 0
if index < 0 {
index = 0
}
// index can equal to length
if index < 0 || index > l.len {
return
}
if index == 0 {
l.AddAtHead(val)
return
}
if index == l.len {
l.AddAtTail(val)
return
}
l.find(index).insertPrev(val)
l.len++
}
/** Delete the index-th node in the linked list, if the index is valid. */
func (l *MyLinkedList) DeleteAtIndex(index int) {
if index < 0 || index >= l.len {
return
}
if index == 0 {
l.head = l.head.next
if l.head != nil {
l.head.prev = nil
}
} else if index == l.len-1 {
l.tail = l.tail.prev
if l.tail != nil {
l.tail.next = nil
}
} else {
p := l.find(index)
// p must not be nil, so we don't need to judge
p.next.prev = p.prev
p.prev.next = p.next
}
l.len--
}
// note: return node maybe nil
func (l *MyLinkedList) find(index int) (p *Node) {
var i int
if index <= l.len-index {
// start at head
for i, p = 0, l.head; i < index; i, p = i+1, p.next {
}
} else {
// start at tail
for i, p = l.len-1, l.tail; i > index; i, p = i-1, p.prev {
}
}
return
}
|
package Router
type Article struct{
Article_id int
Article_name string
Article_content string
}
type ArticleResponse struct {
Id int
Name string
}
type Comment struct{
Comment_content string
Comment_publisher string
Article_id int
}
|
package productstock
import (
"time"
)
//ProductStock is the definition of product stock table in database
type ProductStock struct {
ID uint `gorm:"primary_key" json:"id" valid:"-"`
Stock int `gorm:"not null" json:"stock" valid:"numeric,required"`
AverageBuyPrice float64 `gorm:"not null" json:"average_buy_price" valid:"float,required"`
ProductID uint `json:"product_id" valid:"numeric,required" sql:"type:uint REFERENCES products(id)"`
CreatedAt time.Time `json:"created_at" valid:"-"`
UpdatedAt time.Time `json:"updated_at" valid:"-"`
DeletedAt *time.Time `json:"deleted_at" valid:"-"`
}
|
package main
import (
"bufio"
"fmt"
"math"
"os"
"regexp"
"sort"
"strconv"
"strings"
)
const (
ImmuneSystem = iota
Infection = iota
)
type UnitGroup struct {
team int
count int
hp int
damage int
attackType string
initiative int
weak string
immune string
}
func (ug UnitGroup) EffectivePower(boost int) int {
if ug.team == ImmuneSystem {
return ug.count * (ug.damage + boost)
} else {
return ug.count * ug.damage
}
}
func (ug *UnitGroup) WeakTo(attack string) bool {
for _, w := range strings.Split(ug.weak, ", ") {
if w == attack {
return true
}
}
return false
}
func (ug *UnitGroup) ImmuneTo(attack string) bool {
for _, i := range strings.Split(ug.immune, ", ") {
if i == attack {
return true
}
}
return false
}
func parseGroup(team int, line string) UnitGroup {
regex, _ := regexp.Compile(`(\d+) units each with (\d+) hit points(?:.*) with an attack that does (\d+) (\w+) damage at initiative (\d+)`)
weakRegex, _ := regexp.Compile(`weak to ([\w, ]+)`)
immuneRegex, _ := regexp.Compile(`immune to ([\w, ]+)`)
result := regex.FindStringSubmatch(line)
count, _ := strconv.Atoi(result[1])
hp, _ := strconv.Atoi(result[2])
damage, _ := strconv.Atoi(result[3])
attackType := result[4]
init, _ := strconv.Atoi(result[5])
weak := weakRegex.FindStringSubmatch(line)
var weaknesses string
if len(weak) > 1 {
weaknesses = weak[1]
}
immune := immuneRegex.FindStringSubmatch(line)
var immunities string
if len(immune) > 1 {
immunities = immune[1]
}
group := UnitGroup{
team: team,
count: count,
hp: hp,
damage: damage,
attackType: attackType,
initiative: init,
weak: weaknesses,
immune: immunities,
}
return group
}
func simulateBattle(team1, team2 []*UnitGroup, boost int) (int, int) {
//fmt.Println("Initial:")
//fmt.Println("Team 1:")
//for _, ug := range team1 {
// fmt.Println(ug.count, "units", ug.EffectivePower(boost), "power")
//}
//fmt.Println("Team 2:")
//for _, ug := range team2 {
// fmt.Println(ug.count, "units", ug.EffectivePower(boost), "power")
//}
team1copy := make([]*UnitGroup, len(team1))
for i, ug := range team1 {
ugc := *ug
team1copy[i] = &ugc
}
team2copy := make([]*UnitGroup, len(team2))
for i, ug := range team2 {
ugc := *ug
team2copy[i] = &ugc
}
for len(team1copy) > 0 && len(team2copy) > 0 {
// Order by effective power and initiative
//fmt.Print("New round: ")
var deathToll int
units := make([]*UnitGroup, 0, len(team1copy)+len(team2copy))
units = append(units, team1copy...)
units = append(units, team2copy...)
sort.Slice(units, func(i, j int) bool {
if units[i].EffectivePower(boost) == units[j].EffectivePower(boost) {
return units[i].initiative > units[j].initiative
}
return units[i].EffectivePower(boost) > units[j].EffectivePower(boost)
})
// Make list of valid targets
targetsRemaining := map[*UnitGroup]struct{}{}
for _, u := range units {
targetsRemaining[u] = struct{}{}
}
targets := map[*UnitGroup]*UnitGroup{}
for _, attacker := range units {
var target *UnitGroup
bestDamage := 0
for t := range targetsRemaining {
if t.team == attacker.team {
continue
}
if t.ImmuneTo(attacker.attackType) {
continue
}
damage := attacker.EffectivePower(boost)
if t.WeakTo(attacker.attackType) {
damage *= 2
}
if damage > bestDamage || target == nil {
target = t
bestDamage = damage
} else if damage == bestDamage {
if t.EffectivePower(boost) > target.EffectivePower(boost) {
target = t
} else if t.EffectivePower(boost) == target.EffectivePower(boost) {
if t.initiative > target.initiative {
target = t
}
}
}
}
targets[attacker] = target
delete(targetsRemaining, target)
}
// Attack phase
sort.Slice(units, func(i, j int) bool {
return units[i].initiative > units[j].initiative
})
for _, attacker := range units {
if attacker.count <= 0 {
continue
}
defender := targets[attacker]
if defender == nil {
continue
}
attackDamage := attacker.EffectivePower(boost)
if defender.WeakTo(attacker.attackType) {
attackDamage *= 2
}
defendersKilled := attackDamage / defender.hp
if defendersKilled > defender.count {
defendersKilled = defender.count
}
deathToll += defendersKilled
defender.count -= defendersKilled
}
if deathToll == 0 {
return Infection, 0
}
// Remove dead units
var alive1 []*UnitGroup
for _, ug := range team1copy {
if ug.count > 0 {
alive1 = append(alive1, ug)
}
}
team1copy = alive1
var alive2 []*UnitGroup
for _, ug := range team2copy {
if ug.count > 0 {
alive2 = append(alive2, ug)
}
}
team2copy = alive2
}
var winner, alive int
if len(team1copy) == 0 {
winner = Infection
for _, ug := range team2copy {
alive += ug.count
}
} else {
winner = ImmuneSystem
for _, ug := range team1copy {
alive += ug.count
}
}
return winner, alive
}
func part1(team1, team2 []*UnitGroup) int {
_, alive := simulateBattle(team1, team2, 0)
return alive
}
func part2(team1, team2 []*UnitGroup) int {
high, low := math.MaxInt32, 0
var result int
for high-low > 1 {
testBoost := (high + low) / 2
winner, alive := simulateBattle(team1, team2, testBoost)
if winner == ImmuneSystem {
high = testBoost
result = alive
} else {
low = testBoost
}
}
return result
}
func main() {
f, _ := os.Open("input/day24.txt")
scanner := bufio.NewScanner(bufio.NewReader(f))
var immuneSystem, infection []*UnitGroup
var team int
for scanner.Scan() {
switch scanner.Text() {
case "":
break
case "Immune System:":
team = ImmuneSystem
case "Infection:":
team = Infection
default:
group := parseGroup(team, scanner.Text())
switch team {
case 0:
immuneSystem = append(immuneSystem, &group)
case 1:
infection = append(infection, &group)
}
}
}
fmt.Println(part1(immuneSystem, infection))
fmt.Println(part2(immuneSystem, infection))
}
|
package vm
import (
"fmt"
"math/rand"
"os"
)
//VM implemets chip8 vm
type VM struct {
Memory [4096]uint8
Gfx [32][64]uint8
Stack [16]uint16
V [16]uint8
I, PC, SP uint16
DelayTimer uint8
SoundTimer uint8
OpCode uint16
DrawFlag bool
Keys [16]bool
}
//Fonts bytes
var Fonts = []uint8{
0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
0x20, 0x60, 0x20, 0x20, 0x70, // 1
0xF0, 0x10, 0xF0, 0x80, 0xF0, // 2
0xF0, 0x10, 0xF0, 0x10, 0xF0, // 3
0x90, 0x90, 0xF0, 0x10, 0x10, // 4
0xF0, 0x80, 0xF0, 0x10, 0xF0, // 5
0xF0, 0x80, 0xF0, 0x90, 0xF0, // 6
0xF0, 0x10, 0x20, 0x40, 0x40, // 7
0xF0, 0x90, 0xF0, 0x90, 0xF0, // 8
0xF0, 0x90, 0xF0, 0x10, 0xF0, // 9
0xF0, 0x90, 0xF0, 0x90, 0x90, // A
0xE0, 0x90, 0xE0, 0x90, 0xE0, // B
0xF0, 0x80, 0x80, 0x80, 0xF0, // C
0xE0, 0x90, 0x90, 0x90, 0xE0, // D
0xF0, 0x80, 0xF0, 0x80, 0xF0, // E
0xF0, 0x80, 0xF0, 0x80, 0x80, // F
}
//New returns new VM
func New() VM {
vm := VM{}
vm.Initialize()
return vm
}
//Initialize the vm
func (vm *VM) Initialize() {
vm.PC = 0x200
vm.DrawFlag = true
//load the fontsets
for i := 0; i < len(Fonts); i++ {
vm.Memory[i] = Fonts[i] //loadfontset
}
}
//Draw called to draw
func (vm *VM) Draw() bool {
sd := vm.DrawFlag
vm.DrawFlag = false
return sd
}
//EmulateCycle fetch->decode->execute->update-timers
func (vm *VM) EmulateCycle() {
//fetch opcode
vm.OpCode = uint16(vm.Memory[vm.PC])<<8 | uint16(vm.Memory[vm.PC+1])
x := (vm.OpCode & 0x0F00) >> 8
y := (vm.OpCode & 0x00F0) >> 4
nn := vm.OpCode & 0x00FF
nnn := vm.OpCode & 0x0FFF
vm.PC += 2
//execute
switch vm.OpCode & 0xF000 {
case 0x0000:
switch vm.OpCode & 0x000F {
case 0x0000: // clear screen
for i := 0; i < len(vm.Gfx); i++ {
for j := 0; j < len(vm.Gfx[i]); j++ {
vm.Gfx[i][j] = 0x0
}
}
vm.DrawFlag = true
case 0x000E: // return from subroutine
vm.SP = vm.SP - 1
vm.PC = vm.Stack[vm.SP]
default:
fmt.Println("Unknown opcode")
}
case 0x1000: // Jumps to NNN
vm.PC = nnn
case 0x2000: // Call subroutine at NNN
vm.Stack[vm.SP] = vm.PC
vm.SP++
vm.PC = 0x0FFF & vm.OpCode
case 0x3000: // vx equals NN at memory
if uint16(vm.V[x]) == nn {
vm.PC += 2
}
case 0x4000: // vx not equals NN at memory
if uint16(vm.V[x]) != nn {
vm.PC += 2
}
case 0x5000: // vx equals vy
if vm.V[x] == vm.V[y] {
vm.PC += 2
}
case 0x6000: // vx to NN
vm.V[x] = uint8(nn)
case 0x7000: // vx += NN
vm.V[x] += uint8(nn)
case 0x8000:
switch vm.OpCode & 0x000F {
case 0x0000: // vx = vy
vm.V[x] = vm.V[y]
case 0x0001: // vx |= vy
vm.V[x] |= vm.V[y]
case 0x0002: // vx &= vy
vm.V[x] &= vm.V[y]
case 0x0003: // vx ^= vy
vm.V[x] ^= vm.V[y]
case 0x0004: // vx += vy
vm.V[0xF] = 0
//check if addition > 255 and set flag reg = 1 if true
if vm.V[x] > (0xFF - vm.V[y]) {
vm.V[0xF] = 1
}
vm.V[x] += vm.V[y]
case 0x0005: // vx -= vy
vm.V[0xF] = 0
//flag = 1 if not borrow i.e vx - vy
if vm.V[x] > vm.V[y] {
vm.V[0xF] = 1
}
vm.V[x] -= vm.V[y]
case 0x0006: // vx >> 1
vm.V[0xF] = vm.V[x] & 0x1
vm.V[x] >>= 1
case 0x0007: // vx = vy - vx
vm.V[0xF] = 0
//flag = 1 if not borrow i.e vx - vy
if vm.V[y] > vm.V[x] {
vm.V[0xF] = 1
}
vm.V[x] = vm.V[y] - vm.V[x]
case 0x000E: // vx << 1
vm.V[0xF] = vm.V[x] >> 7
vm.V[x] <<= 1
default:
fmt.Println("Unknown opcode")
}
case 0x9000: // vx != vy conditional
if vm.V[x] != vm.V[y] {
vm.PC += 2
}
case 0xA000: // load
vm.I = nnn
case 0xB000: // Jump
vm.PC = uint16(vm.V[0x0]) + nnn
case 0xC000: // Rand & nn
vm.V[x] = uint8(nn) & (uint8(rand.Intn(256)))
case 0xD000: //Draw
vm.DrawFlag = true
h := vm.OpCode & 0x000F
vm.V[0xF] = 0
var j uint16 = 0
var i uint16 = 0
for j = 0; j < h; j++ {
pixel := vm.Memory[vm.I+j]
for i = 0; i < 8; i++ {
if (pixel & (0x80 >> i)) != 0 {
if vm.Gfx[(vm.V[y] + uint8(j))][vm.V[x]+uint8(i)] == 1 {
vm.V[0xF] = 1
}
vm.Gfx[(vm.V[y] + uint8(j))][vm.V[x]+uint8(i)] ^= 1
}
}
}
vm.DrawFlag = true
case 0xE000:
switch 0x00FF & vm.OpCode {
case 0x009E:
if vm.Keys[vm.V[x]] {
vm.PC += 2
}
case 0x00A1:
if !vm.Keys[vm.V[x]] {
vm.PC += 2
}
default:
fmt.Println("Unknown opcode")
}
case 0xF000:
switch 0x00FF & vm.OpCode {
case 0x0007:
vm.V[x] = vm.DelayTimer
case 0x000A:
//wait until key is pressed
vm.PC -= 2
for i := uint8(0); i < 16; i++ {
if vm.Keys[i] {
vm.V[x] = i
vm.PC += 2
break
}
}
case 0x0015:
vm.DelayTimer = vm.V[x]
case 0x0018:
vm.SoundTimer = vm.V[x]
case 0x001E:
vm.V[0xF] = 0
if vm.I > 0xFFF-uint16(vm.V[x]) {
vm.V[0xF] = 1
}
vm.I += uint16(vm.V[x])
case 0x0029:
vm.I += uint16(vm.V[x]) * 5
case 0x0033:
vm.Memory[vm.I] = vm.V[x] / 100
vm.Memory[vm.I+1] = (vm.V[x] / 10) % 10
vm.Memory[vm.I+2] = vm.V[x] % 10
case 0x0055:
for i := uint16(0); i < x; i++ {
vm.Memory[vm.I+i] = vm.V[i]
}
vm.I = ((vm.OpCode & 0x0F00) >> 8) + 1
case 0x0065:
for i := uint16(0); i < x; i++ {
vm.V[i] = vm.Memory[vm.I+i]
}
vm.I = ((vm.OpCode & 0x0F00) >> 8) + 1
}
default:
fmt.Println("Unknown opcode")
}
if vm.DelayTimer > 0 {
vm.DelayTimer--
}
if vm.SoundTimer > 0 {
if vm.SoundTimer == 1 {
fmt.Println("BEEP")
}
vm.SoundTimer--
}
}
//LoadProgram in the memory
func (vm *VM) LoadProgram(path string) error {
file, err := os.OpenFile(path, os.O_RDWR, 0777)
if err != nil {
return err
}
defer file.Close()
fStat, err := file.Stat()
if err != nil {
return err
}
if int64(len(vm.Memory)-512) < fStat.Size() { // program is loaded at 0x200
return fmt.Errorf("Program size bigger than memory")
}
buffer := make([]byte, fStat.Size())
if _, err = file.Read(buffer); err != nil {
return err
}
for i := 0; i < len(buffer); i++ {
vm.Memory[i+512] = buffer[i]
}
fmt.Println("here ")
return nil
}
|
package models
type (
GlobalStats struct {
Hostname string `json:"hostname"`
Time string `json:"time"`
Channels int64 `json:"channels"`
WildcardChannels int64 `json:"wildcard_channels"`
PublishedMessages int64 `json:"published_messages"`
StoredMessages int64 `json:"stored_messages"`
MessagesInTrash int64 `json:"messages_in_trash"`
ChannelsInDelete int64 `json:"channels_in_delete"`
ChannelsInTrash int64 `json:"channels_in_trash"`
Subscribers int64 `json:"subscribers"`
Uptime int64 `json:"uptime"`
Agent string `json:"agent"` // set by us, doesn't come from push-stream
}
// returned by push-stream with more fields, but we only use Hostname and Infos
GlobalStatsDetailed struct {
Hostname string `json:"hostname"`
Infos []ChannelStats `json:"infos"`
}
)
|
package main
import "fmt"
/*
当出现多个if-else时可考虑用其代替
!思考：if和switch的区别？
if 可以嵌套 可以判断区间 执行效率比较低
switch 执行效率高 不能嵌套和区间判断
特性：
1.switch 选择项可以是一个整型变量
2.swich中的值不能是浮点型数据 浮点型数据是一个约等于的数据
*/
func main() {
// 判断今天是星期几
var a int
INPUT:
fmt.Println("请输入1～7数字")
fmt.Scan(&a)
switch a {
case 1:
fmt.Println("今天是周一")
case 2:
fmt.Println("今天是周二")
case 3:
fmt.Println("今天是周三")
case 4:
fmt.Println("今天是周四")
case 5:
fmt.Println("今天是周五")
case 6:
fmt.Println("今天是周六")
case 7:
fmt.Println("今天是周日")
default:
goto INPUT
}
// 判断成绩是否合格
var results int
fmt.Println("考了多少分")
fmt.Scan(&results)
switch results >=60{
case true:
fmt.Println("及格")
case false:
fmt.Println("不及格")
i := 5
switch i { // 需要注意的是i和下面case N中的N类型一定是一样的
case 1: // 当i未声明时代表true ex: switch {}
fmt.Println("i 等于 1") // 由于默认每个case的最后都带break所以匹配到结果既跳出判断
fallthrough
case 2,3,4: // 如果需要匹配成功后继续向下执行，则通过fallthrough控制
fmt.Println("i 为 2,3,4 中的一个")
fallthrough
case 5:
fmt.Println("i 等于 5")
fallthrough
default:
fmt.Println("i 比 5 大")
}
}
}
|
package tsmt
import (
"encoding/xml"
"github.com/thought-machine/finance-messaging/iso20022"
)
type Document03100103 struct {
XMLName xml.Name `xml:"urn:iso:std:iso:20022:tech:xsd:tsmt.031.001.03 Document"`
Message *StatusExtensionRequestAcceptanceV03 `xml:"StsXtnsnReqAccptnc"`
}
func (d *Document03100103) AddMessage() *StatusExtensionRequestAcceptanceV03 {
d.Message = new(StatusExtensionRequestAcceptanceV03)
return d.Message
}
// Scope
// The StatusExtensionRequestAcceptance message is sent by the party requested to accept or reject a request to extend the status of a transaction to the matching application.
// This message is used to inform about the acceptance of a request to extend the status of a transaction.
// Usage
// The StatusExtensionRequestAcceptance message can be sent by the party requested to accept or reject the request to extend the status of a transaction to inform that it accepts the request.
// The message can be sent in response to a StatusExtensionRequestNotification message.
// The rejection of a request to extend the status of a transaction can be achieved by sending a StatusExtensionRequestRejection message.
type StatusExtensionRequestAcceptanceV03 struct {
// Identifies the acceptance message.
AcceptanceIdentification *iso20022.MessageIdentification1 `xml:"AccptncId"`
// Unique identification assigned by the matching application to the transaction.
// This identification is to be used in any communication between the parties.
//
TransactionIdentification *iso20022.SimpleIdentificationInformation `xml:"TxId"`
// Reference to the transaction for the requesting financial institution.
SubmitterTransactionReference *iso20022.SimpleIdentificationInformation `xml:"SubmitrTxRef,omitempty"`
// Identifies the status for which the user accepts an extension of the validity period..
ExtendedStatus *iso20022.TransactionStatus4 `xml:"XtndedSts"`
}
func (s *StatusExtensionRequestAcceptanceV03) AddAcceptanceIdentification() *iso20022.MessageIdentification1 {
s.AcceptanceIdentification = new(iso20022.MessageIdentification1)
return s.AcceptanceIdentification
}
func (s *StatusExtensionRequestAcceptanceV03) AddTransactionIdentification() *iso20022.SimpleIdentificationInformation {
s.TransactionIdentification = new(iso20022.SimpleIdentificationInformation)
return s.TransactionIdentification
}
func (s *StatusExtensionRequestAcceptanceV03) AddSubmitterTransactionReference() *iso20022.SimpleIdentificationInformation {
s.SubmitterTransactionReference = new(iso20022.SimpleIdentificationInformation)
return s.SubmitterTransactionReference
}
func (s *StatusExtensionRequestAcceptanceV03) AddExtendedStatus() *iso20022.TransactionStatus4 {
s.ExtendedStatus = new(iso20022.TransactionStatus4)
return s.ExtendedStatus
}
|
// This file was generated for SObject ContentWorkspacePermission, API Version v43.0 at 2018-07-30 03:47:45.900435663 -0400 EDT m=+32.244251991
package sobjects
import (
"fmt"
"strings"
)
type ContentWorkspacePermission struct {
BaseSObject
CreatedById string `force:",omitempty"`
CreatedDate string `force:",omitempty"`
Description string `force:",omitempty"`
Id string `force:",omitempty"`
LastModifiedById string `force:",omitempty"`
LastModifiedDate string `force:",omitempty"`
Name string `force:",omitempty"`
PermissionsAddComment bool `force:",omitempty"`
PermissionsAddContent bool `force:",omitempty"`
PermissionsAddContentOBO bool `force:",omitempty"`
PermissionsArchiveContent bool `force:",omitempty"`
PermissionsChatterSharing bool `force:",omitempty"`
PermissionsDeleteContent bool `force:",omitempty"`
PermissionsDeliverContent bool `force:",omitempty"`
PermissionsFeatureContent bool `force:",omitempty"`
PermissionsManageWorkspace bool `force:",omitempty"`
PermissionsModifyComments bool `force:",omitempty"`
PermissionsOrganizeFileAndFolder bool `force:",omitempty"`
PermissionsTagContent bool `force:",omitempty"`
PermissionsViewComments bool `force:",omitempty"`
SystemModstamp string `force:",omitempty"`
Type string `force:",omitempty"`
}
func (t *ContentWorkspacePermission) ApiName() string {
return "ContentWorkspacePermission"
}
func (t *ContentWorkspacePermission) String() string {
builder := strings.Builder{}
builder.WriteString(fmt.Sprintf("ContentWorkspacePermission #%s - %s\n", t.Id, t.Name))
builder.WriteString(fmt.Sprintf("\tCreatedById: %v\n", t.CreatedById))
builder.WriteString(fmt.Sprintf("\tCreatedDate: %v\n", t.CreatedDate))
builder.WriteString(fmt.Sprintf("\tDescription: %v\n", t.Description))
builder.WriteString(fmt.Sprintf("\tId: %v\n", t.Id))
builder.WriteString(fmt.Sprintf("\tLastModifiedById: %v\n", t.LastModifiedById))
builder.WriteString(fmt.Sprintf("\tLastModifiedDate: %v\n", t.LastModifiedDate))
builder.WriteString(fmt.Sprintf("\tName: %v\n", t.Name))
builder.WriteString(fmt.Sprintf("\tPermissionsAddComment: %v\n", t.PermissionsAddComment))
builder.WriteString(fmt.Sprintf("\tPermissionsAddContent: %v\n", t.PermissionsAddContent))
builder.WriteString(fmt.Sprintf("\tPermissionsAddContentOBO: %v\n", t.PermissionsAddContentOBO))
builder.WriteString(fmt.Sprintf("\tPermissionsArchiveContent: %v\n", t.PermissionsArchiveContent))
builder.WriteString(fmt.Sprintf("\tPermissionsChatterSharing: %v\n", t.PermissionsChatterSharing))
builder.WriteString(fmt.Sprintf("\tPermissionsDeleteContent: %v\n", t.PermissionsDeleteContent))
builder.WriteString(fmt.Sprintf("\tPermissionsDeliverContent: %v\n", t.PermissionsDeliverContent))
builder.WriteString(fmt.Sprintf("\tPermissionsFeatureContent: %v\n", t.PermissionsFeatureContent))
builder.WriteString(fmt.Sprintf("\tPermissionsManageWorkspace: %v\n", t.PermissionsManageWorkspace))
builder.WriteString(fmt.Sprintf("\tPermissionsModifyComments: %v\n", t.PermissionsModifyComments))
builder.WriteString(fmt.Sprintf("\tPermissionsOrganizeFileAndFolder: %v\n", t.PermissionsOrganizeFileAndFolder))
builder.WriteString(fmt.Sprintf("\tPermissionsTagContent: %v\n", t.PermissionsTagContent))
builder.WriteString(fmt.Sprintf("\tPermissionsViewComments: %v\n", t.PermissionsViewComments))
builder.WriteString(fmt.Sprintf("\tSystemModstamp: %v\n", t.SystemModstamp))
builder.WriteString(fmt.Sprintf("\tType: %v\n", t.Type))
return builder.String()
}
type ContentWorkspacePermissionQueryResponse struct {
BaseQuery
Records []ContentWorkspacePermission `json:"Records" force:"records"`
}
|
// Copyright (C) 2015 Nicolas Lamirault <nicolas.lamirault@gmail.com>
// 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 pubsub
import (
"errors"
)
const (
// REDIS PubSub
REDIS string = "redis"
// ZEROMQ PubSub
ZEROMQ string = "zeromq"
// Channel is for publishers
Channel = "warhol"
)
var (
// ErrNotSupported is thrown when the broker is not supported
ErrNotSupported = errors.New("Broker not supported.")
// Messaging is the messaging system
Messaging Broker
)
// Message is a pub-sub message.
type Message struct {
Type string
Channel string
Data string
}
// Config represents the broker configuration
type Config struct {
Type string
Host string
}
// Broker interface for pubsub clients.
type Broker interface {
Subscribe(channels ...interface{}) (err error)
Unsubscribe(channels ...interface{}) (err error)
Publish(channel string, message string)
Receive()
}
// NewBroker creates an instance of broker according to the configuration
func NewBroker(config *Config, msgChan chan *Message) (Broker, error) {
switch config.Type {
case REDIS:
return NewRedisClient(config.Host, msgChan)
case ZEROMQ:
return NewZeroMQClient(config.Host, msgChan)
default:
return nil, ErrNotSupported
}
}
|
package log
import (
"fmt"
"os"
"path"
api "github.com/tkhoa2711/proglog/api/v1"
"google.golang.org/protobuf/proto"
)
// The segment wraps the index and store types to coordinate operations across
// the two.
//
// The base offset tells us where the segment starts. The next offset allows us
// to know where to append new records.
type segment struct {
store *store
index *index
baseOffset, nextOffset uint64
config Config
}
// newSegment creates a new segment in the given directory with the given base
// offset and config.
func newSegment(dir string, baseOffset uint64, c Config) (*segment, error) {
s := &segment{
baseOffset: baseOffset,
config: c,
}
var err error
// Create the store
storeFile, err := os.OpenFile(
path.Join(dir, fmt.Sprintf("%d%s", baseOffset, ".store")),
os.O_RDWR|os.O_CREATE|os.O_APPEND,
0644,
)
if err != nil {
return nil, err
}
if s.store, err = newStore(storeFile); err != nil {
return nil, err
}
// Create the index
indexFile, err := os.OpenFile(
path.Join(dir, fmt.Sprintf("%d%s", baseOffset, ".index")),
os.O_RDWR|os.O_CREATE|os.O_APPEND,
0644,
)
if err != nil {
return nil, err
}
if s.index, err = newIndex(indexFile, c); err != nil {
return nil, err
}
// Determine the next offset to append new records
if off, _, err := s.index.Read(-1); err != nil {
s.nextOffset = baseOffset
} else {
s.nextOffset = baseOffset + uint64(off) + 1
}
return s, nil
}
// Append writes the record to the segment and returns its offset.
func (s *segment) Append(record *api.Record) (offset uint64, err error) {
cur := s.nextOffset
record.Offset = cur
b, err := proto.Marshal(record)
if err != nil {
return 0, err
}
_, pos, err := s.store.Append(b)
if err != nil {
return 0, err
}
if err = s.index.Write(uint32(s.nextOffset-s.baseOffset), pos); err != nil {
return 0, err
}
s.nextOffset++
return cur, nil
}
// Read returns the record for the given offset.
func (s *segment) Read(off uint64) (*api.Record, error) {
_, pos, err := s.index.Read(int64(off - s.baseOffset))
if err != nil {
return nil, err
}
b, err := s.store.Read(pos)
if err != nil {
return nil, err
}
record := &api.Record{}
if err = proto.Unmarshal(b, record); err != nil {
return nil, err
}
return record, nil
}
// Close closes the segment's store and index files.
func (s *segment) Close() error {
if err := s.index.Close(); err != nil {
return err
}
if err := s.store.Close(); err != nil {
return err
}
return nil
}
// Remove closes the segment and remove all of its store and index files.
func (s *segment) Remove() error {
if err := s.Close(); err != nil {
return err
}
if err := os.Remove(s.index.Name()); err != nil {
return err
}
if err := os.Remove(s.store.Name()); err != nil {
return err
}
return nil
}
// IsMaxed checks if the segment has reached its size limit, either for the
// store or the index.
func (s *segment) IsMaxed() bool {
return s.store.size >= s.config.Segment.MaxStoreBytes ||
s.index.size >= s.config.Segment.MaxIndexBytes
}
|
//author xinbing
//time 2018/9/5 13:52
//正则表达式验证集合
package utilities
import (
"regexp"
)
// 校验国内手机号码
var phoneReg = regexp.MustCompile("^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0-3,5-8])|(18[0-9])|166|198|199)\\d{8}$")
func ValidPhone(phone string) bool{
if len(phone) == 0 {
return false
}
return phoneReg.MatchString(phone)
}
// 校验邮箱
var emailReg = regexp.MustCompile("^[A-Za-z0-9]+([-_.][A-Za-z0-9]+)*@([A-Za-z0-9]+[-.])+[A-Za-z0-9]{2,4}$")
func ValidEmail(email string) bool {
if len(email) == 0 {
return false
}
return emailReg.MatchString(email)
}
|
package main
import "project-backend/API"
func main () {
API.Run()
}
|
package file
import (
"io"
"os"
"path"
"sync"
)
func newSingle(filename string) *single {
return &single{
filename: filename,
}
}
var _ io.WriteCloser = (*single)(nil)
type single struct {
sync.Once // to open file
filename string
f *os.File
}
func (s *single) Write(p []byte) (n int, err error) {
s.Do(func() { err = s.open() })
if err != nil {
return
}
return s.f.Write(p)
}
func (s *single) open() error {
// make sure the dir exists
dir := path.Dir(s.filename)
dirExist, err := exist(dir)
if err != nil {
return err
}
if !dirExist {
err = os.MkdirAll(dir, os.ModePerm)
if err != nil {
return err
}
}
// maker sure the file exists
fileExist, err := exist(s.filename)
if err != nil {
return err
}
if fileExist {
s.f, err = os.OpenFile( // nolint: gosec
s.filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
} else {
s.f, err = os.Create(s.filename)
}
return err
}
func (s *single) exist() (bool, error) {
return exist(s.filename)
}
func (s *single) Close() error {
if s.f == nil {
return nil
}
return s.f.Close()
}
|
package internal
import (
"errors"
"os"
"testing"
)
func TestAuxvVDSOMemoryAddress(t *testing.T) {
av, err := os.Open("../testdata/auxv.bin")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { av.Close() })
addr, err := vdsoMemoryAddress(av)
if err != nil {
t.Fatal(err)
}
expected := uint64(0x7ffd377e5000)
if addr != expected {
t.Errorf("Expected vDSO memory address %x, got %x", expected, addr)
}
}
func TestAuxvNoVDSO(t *testing.T) {
// Copy of auxv.bin with the vDSO pointer removed.
av, err := os.Open("../testdata/auxv_no_vdso.bin")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { av.Close() })
_, err = vdsoMemoryAddress(av)
if want, got := errAuxvNoVDSO, err; !errors.Is(got, want) {
t.Fatalf("expected error '%v', got: %v", want, got)
}
}
func TestLinuxVersionCodeEmbedded(t *testing.T) {
tests := []struct {
file string
version uint32
}{
{
"../testdata/vdso.bin",
uint32(328828), // 5.4.124
},
{
"../testdata/vdso_multiple_notes.bin",
uint32(328875), // Container Optimized OS v85 with a 5.4.x kernel
},
}
for _, test := range tests {
t.Run(test.file, func(t *testing.T) {
vdso, err := os.Open(test.file)
if err != nil {
t.Fatal(err)
}
defer vdso.Close()
vc, err := vdsoLinuxVersionCode(vdso)
if err != nil {
t.Fatal(err)
}
if vc != test.version {
t.Errorf("Expected version code %d, got %d", test.version, vc)
}
})
}
}
|
package http
import (
"net/http"
"os"
"github.com/jinzhu/gorm"
"github.com/smilga/analyzer/api"
"github.com/smilga/analyzer/api/comm"
"github.com/smilga/analyzer/api/datastore/cache"
"github.com/smilga/analyzer/api/datastore/mysql"
"github.com/smilga/analyzer/api/ws"
)
type Handler struct {
Auth api.Auth
WebsiteStorage api.WebsiteStorage
UserStorage api.UserStorage
PatternStorage api.PatternStorage
TagStorage api.TagStorage
FeatureStorage api.FeatureStorage
ServiceStorage api.ServiceStorage
FilterStorage api.FilterStorage
ReportStorage api.ReportStorage
ResultStorage api.ResultStorage
Messanger *ws.Messanger
Comm *comm.Comm
}
func (h *Handler) AuthID(r *http.Request) (api.UserID, error) {
id := r.Context().Value(uidKey)
uid, ok := id.(api.UserID)
if !ok {
return uid, api.ErrTokenError
}
return uid, nil
}
func NewHandler(db *gorm.DB, comm *comm.Comm) *Handler {
wstore := mysql.NewWebsiteStore(db)
ps := mysql.NewPatternStore(db.DB())
us := mysql.NewUserStore(db)
ts := mysql.NewTagStore(db)
rs := mysql.NewReportStore(db.DB())
fs := mysql.NewFilterStore(db.DB())
xs := mysql.NewFeatureStore(db)
ss := mysql.NewServiceStore(db)
rss := mysql.NewResultStore(db)
pcache := cache.NewPatternCache(ps)
return &Handler{
Auth: NewJWTAuth(os.Getenv("JWT_SECRET")),
WebsiteStorage: wstore,
UserStorage: us,
PatternStorage: pcache,
TagStorage: ts,
FeatureStorage: xs,
ServiceStorage: ss,
FilterStorage: fs,
ReportStorage: rs,
Messanger: ws.NewMessanger(),
ResultStorage: rss,
Comm: comm,
}
}
// func NewTestHandler() *Handler {
// return &Handler{
// Auth: NewJWTAuth(os.Getenv("JWT_SECRET")),
// WebsiteStorage: inmem.NewWebsiteStore(),
// UserStorage: inmem.NewUserStore(),
// PatternStorage: inmem.NewPatternStore(),
// TagStorage: inmem.NewTagStore(),
// FilterStorage: inmem.NewFilterStore(),
// Analyzer: &api.Analyzer{
// PatternStorage: inmem.NewPatternStore(),
// WebsiteStorage: inmem.NewWebsiteStore(),
// },
// }
// }
|
// Copyright 2022 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 checker
import (
"context"
"database/sql"
"github.com/pingcap/errors"
"github.com/pingcap/tidb/util/dbutil"
)
// DDLSyncer can sync the table structure from upstream(usually MySQL) to ExecutableChecker
type DDLSyncer struct {
db *sql.DB
ec *ExecutableChecker
}
// NewDDLSyncer create a new DDLSyncer
func NewDDLSyncer(cfg *dbutil.DBConfig, executableChecker *ExecutableChecker) (*DDLSyncer, error) {
db, err := dbutil.OpenDB(*cfg, nil)
if err != nil {
return nil, errors.Trace(err)
}
return &DDLSyncer{db, executableChecker}, nil
}
// SyncTable can sync table structure from upstream by table name
func (ds *DDLSyncer) SyncTable(tidbContext context.Context, schemaName string, tableName string) error {
createTableSQL, err := dbutil.GetCreateTableSQL(context.Background(), ds.db, schemaName, tableName)
if err != nil {
return errors.Trace(err)
}
err = ds.ec.DropTable(tidbContext, tableName)
if err != nil {
return errors.Trace(err)
}
err = ds.ec.Execute(tidbContext, createTableSQL)
if err != nil {
return errors.Trace(err)
}
return nil
}
// Close the DDLSyncer, if the ExecutableChecker in DDLSyncer is open, it will be closed, too
func (ds *DDLSyncer) Close() error {
err1 := ds.ec.Close()
err2 := dbutil.CloseDB(ds.db)
if err1 != nil {
return errors.Trace(err1)
}
if err2 != nil {
return errors.Trace(err2)
}
return nil
}
|
package couchdb_test
import (
"testing"
"github.com/Liu710/couchdb"
)
var docID string
func TestNewCouchDB(t *testing.T) {
_, cErr := couchdb.NewCouchDB(couchdb.CouchDBConfig{
Host: "http://localhost:5984",
Username: "test_user",
Password: "test_password",
Database: "test_db",
})
if cErr != nil {
t.Fatal("Failed to initialize couchdb")
}
}
func TestGetAllDocs(t *testing.T) {
c, cErr := couchdb.NewCouchDB(couchdb.CouchDBConfig{
Host: "http://localhost:5984",
Username: "test_user",
Password: "test_password",
Database: "test_db",
})
if cErr != nil {
t.Fatal("Failed to initialize couchdb")
}
result, err := c.GetAllDocs()
if err != nil {
t.Fatal("Failed to get all docs")
}
if len(result) < 1 {
t.Fatal("No doc is in the database")
}
doc := result[0].(map[string]interface{})
docID = doc["_id"].(string)
}
func TestGetDoc(t *testing.T) {
c, cErr := couchdb.NewCouchDB(couchdb.CouchDBConfig{
Host: "http://localhost:5984",
Username: "test_user",
Password: "test_password",
Database: "test_db",
})
if cErr != nil {
t.Fatal("Failed to initialize couchdb")
}
_, err1 := c.GetDoc("id_does_not_exist")
if err1 != nil && err1 != couchdb.ErrDocNotFound {
t.Fatal("Failed to get all docs")
}
_, err2 := c.GetDoc(docID)
if err2 != nil {
t.Fatal("Failed to get all docs")
}
}
|
/*
Copyright 2021 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 util_test
import (
"context"
"fmt"
"hash/adler32"
"testing"
"time"
"github.com/crossplane/crossplane-runtime/pkg/test"
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"sigs.k8s.io/controller-runtime/pkg/client"
"github.com/oam-dev/kubevela/apis/core.oam.dev/common"
"github.com/oam-dev/kubevela/apis/core.oam.dev/condition"
"github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1"
"github.com/oam-dev/kubevela/pkg/oam"
"github.com/oam-dev/kubevela/pkg/oam/mock"
"github.com/oam-dev/kubevela/pkg/oam/util"
)
func TestUnstructured(t *testing.T) {
tests := map[string]struct {
u *unstructured.Unstructured
typeLabel string
exp string
resource string
}{
"native resource": {
u: &unstructured.Unstructured{Object: map[string]interface{}{
"apiVersion": "apps/v1",
"kind": "Deployment",
}},
resource: "deployments",
exp: "deployments.apps",
},
"workload": {
u: &unstructured.Unstructured{Object: map[string]interface{}{
"apiVersion": "apps/v1",
"kind": "Deployment",
"metadata": map[string]interface{}{
"labels": map[string]interface{}{
oam.WorkloadTypeLabel: "deploy",
},
},
}},
typeLabel: oam.WorkloadTypeLabel,
exp: "deploy",
},
}
for name, ti := range tests {
mapper := mock.NewClient(nil, nil).RESTMapper()
got, err := util.GetDefinitionName(mapper, ti.u, ti.typeLabel)
assert.NoError(t, err)
t.Log(fmt.Sprint("Running test: ", name))
assert.Equal(t, ti.exp, got)
}
}
func TestGetGVKFromDef(t *testing.T) {
mapper := mock.NewClient(nil, map[schema.GroupVersionResource][]schema.GroupVersionKind{
schema.GroupVersionResource{Group: "example.com", Resource: "abcs"}: {{Group: "example.com", Version: "v1", Kind: "Abc"}},
schema.GroupVersionResource{Group: "example.com", Resource: "abcs", Version: "v2"}: {{Group: "example.com", Version: "v2", Kind: "Abc"}},
}).RESTMapper()
gvk, err := util.GetGVKFromDefinition(mapper, common.DefinitionReference{Name: "abcs.example.com"})
assert.NoError(t, err)
assert.Equal(t, metav1.GroupVersionKind{
Group: "example.com",
Version: "v1",
Kind: "Abc",
}, gvk)
gvk, err = util.GetGVKFromDefinition(mapper, common.DefinitionReference{Name: "abcs.example.com", Version: "v2"})
assert.NoError(t, err)
assert.Equal(t, metav1.GroupVersionKind{
Group: "example.com",
Version: "v2",
Kind: "Abc",
}, gvk)
gvk, err = util.GetGVKFromDefinition(mapper, common.DefinitionReference{})
assert.NoError(t, err)
assert.Equal(t, metav1.GroupVersionKind{
Group: "",
Version: "",
Kind: "",
}, gvk)
gvk, err = util.GetGVKFromDefinition(mapper, common.DefinitionReference{Name: "dummy"})
assert.NoError(t, err)
assert.Equal(t, metav1.GroupVersionKind{
Group: "",
Version: "",
Kind: "",
}, gvk)
}
func TestConvertWorkloadGVK2Def(t *testing.T) {
mapper := mock.NewClient(nil, map[schema.GroupVersionResource][]schema.GroupVersionKind{}).RESTMapper()
ref, err := util.ConvertWorkloadGVK2Definition(mapper, common.WorkloadGVK{APIVersion: "apps.kruise.io/v1alpha1",
Kind: "CloneSet"})
assert.NoError(t, err)
assert.Equal(t, common.DefinitionReference{
Name: "clonesets.apps.kruise.io",
Version: "v1alpha1",
}, ref)
ref, err = util.ConvertWorkloadGVK2Definition(mapper, common.WorkloadGVK{APIVersion: "apps/v1",
Kind: "Deployment"})
assert.NoError(t, err)
assert.Equal(t, common.DefinitionReference{
Name: "deployments.apps",
Version: "v1",
}, ref)
_, err = util.ConvertWorkloadGVK2Definition(mapper, common.WorkloadGVK{APIVersion: "/apps/v1",
Kind: "Deployment"})
assert.Error(t, err)
}
func TestDeepHashObject(t *testing.T) {
successCases := []func() interface{}{
func() interface{} { return 8675309 },
func() interface{} { return "Jenny, I got your number" },
func() interface{} { return []string{"eight", "six", "seven"} },
}
for _, tc := range successCases {
hasher1 := adler32.New()
util.DeepHashObject(hasher1, tc())
hash1 := hasher1.Sum32()
util.DeepHashObject(hasher1, tc())
hash2 := hasher1.Sum32()
assert.Equal(t, hash1, hash2)
}
}
func TestEndReconcileWithNegativeCondition(t *testing.T) {
var time1, time2 time.Time
time1 = time.Now()
time2 = time1.Add(time.Second)
type args struct {
ctx context.Context
r client.StatusClient
workload util.ConditionedObject
condition []condition.Condition
}
patchErr := fmt.Errorf("eww")
tests := []struct {
name string
args args
expected error
}{
{
name: "no condition is added",
args: args{
ctx: context.Background(),
r: &test.MockClient{
MockStatusPatch: test.NewMockSubResourcePatchFn(nil),
},
workload: &mock.Target{},
condition: []condition.Condition{},
},
expected: nil,
},
{
name: "condition is changed",
args: args{
ctx: context.Background(),
r: &test.MockClient{
MockStatusPatch: test.NewMockSubResourcePatchFn(nil),
},
workload: &mock.Target{
ConditionedStatus: condition.ConditionedStatus{
Conditions: []condition.Condition{
{
Type: "test",
LastTransitionTime: metav1.NewTime(time1),
Reason: "old reason",
Message: "old error msg",
},
},
},
},
condition: []condition.Condition{
{
Type: "test",
LastTransitionTime: metav1.NewTime(time2),
Reason: "new reason",
Message: "new error msg",
},
},
},
expected: nil,
},
{
name: "condition is not changed",
args: args{
ctx: context.Background(),
r: &test.MockClient{
MockStatusPatch: test.NewMockSubResourcePatchFn(nil),
},
workload: &mock.Target{
ConditionedStatus: condition.ConditionedStatus{
Conditions: []condition.Condition{
{
Type: "test",
LastTransitionTime: metav1.NewTime(time1),
Reason: "old reason",
Message: "old error msg",
},
},
},
},
condition: []condition.Condition{
{
Type: "test",
LastTransitionTime: metav1.NewTime(time2),
Reason: "old reason",
Message: "old error msg",
},
},
},
expected: fmt.Errorf(util.ErrReconcileErrInCondition, "test", "old error msg"),
},
{
name: "fail for patching error",
args: args{
ctx: context.Background(),
r: &test.MockClient{
MockStatusPatch: test.NewMockSubResourcePatchFn(patchErr),
},
workload: &mock.Target{},
condition: []condition.Condition{
{},
},
},
expected: errors.Wrap(patchErr, util.ErrUpdateStatus),
},
}
for _, tt := range tests {
err := util.EndReconcileWithNegativeCondition(tt.args.ctx, tt.args.r, tt.args.workload, tt.args.condition...)
if tt.expected == nil {
assert.NoError(t, err)
} else {
assert.Equal(t, tt.expected.Error(), err.Error())
}
}
}
func TestEndReconcileWithPositiveCondition(t *testing.T) {
type args struct {
ctx context.Context
r client.StatusClient
workload util.ConditionedObject
condition []condition.Condition
}
patchErr := fmt.Errorf("eww")
tests := []struct {
name string
args args
expected error
}{
{
name: "success",
args: args{
ctx: context.Background(),
r: &test.MockClient{
MockStatusPatch: test.NewMockSubResourcePatchFn(nil),
},
workload: &mock.Target{},
condition: []condition.Condition{
{},
},
},
expected: nil,
},
{
name: "fail",
args: args{
ctx: context.Background(),
r: &test.MockClient{
MockStatusPatch: test.NewMockSubResourcePatchFn(patchErr),
},
workload: &mock.Target{},
condition: []condition.Condition{
{},
},
},
expected: errors.Wrap(patchErr, util.ErrUpdateStatus),
},
}
for _, tt := range tests {
err := util.EndReconcileWithPositiveCondition(tt.args.ctx, tt.args.r, tt.args.workload, tt.args.condition...)
if tt.expected == nil {
assert.NoError(t, err)
} else {
assert.Equal(t, tt.expected.Error(), err.Error())
}
}
}
func TestAddLabels(t *testing.T) {
basicLabels := map[string]string{
"basic.label.key": "basic",
}
obj1 := new(unstructured.Unstructured)
wantObj1 := new(unstructured.Unstructured)
wantObj1.SetLabels(map[string]string{
"basic.label.key": "basic",
"newKey": "newValue",
})
obj2 := new(unstructured.Unstructured)
wantObj2 := new(unstructured.Unstructured)
obj2.SetLabels(map[string]string{
"key": "value",
})
wantObj2.SetLabels(map[string]string{
"basic.label.key": "basic",
"key": "value",
"newKey2": "newValue2",
})
cases := map[string]struct {
obj *unstructured.Unstructured
newLabels map[string]string
want *unstructured.Unstructured
}{
"add labels to workload without labels": {
obj1,
map[string]string{
"newKey": "newValue",
},
wantObj1,
},
"add labels to workload with labels": {
obj2,
map[string]string{
"newKey2": "newValue2",
},
wantObj2,
},
}
for name, tc := range cases {
t.Log("Running test case: " + name)
obj := tc.obj
wantObj := tc.want
util.AddLabels(obj, basicLabels)
util.AddLabels(obj, tc.newLabels)
assert.Equal(t, wantObj.GetLabels(), obj.GetLabels())
}
}
func TestMergeMapOverrideWithDst(t *testing.T) {
const (
basicKey = "basicKey"
dstKey = "dstKey"
srcKey = "srcKey"
basicValue = "basicValue"
dstValue = "dstValue"
srcValue = "srcValue"
)
basicDst := map[string]string{basicKey: basicValue}
cases := map[string]struct {
src map[string]string
dst map[string]string
want map[string]string
}{
"src is nil, dst is not nil": {
src: nil,
dst: map[string]string{dstKey: dstValue},
want: map[string]string{basicKey: basicValue, dstKey: dstValue},
},
"src is not nil, dst is nil": {
src: map[string]string{srcKey: srcValue},
dst: nil,
want: map[string]string{basicKey: basicValue, srcKey: srcValue},
},
"both nil": {
src: nil,
dst: nil,
want: map[string]string{basicKey: basicValue},
},
"both not nil": {
src: map[string]string{srcKey: srcValue},
dst: map[string]string{dstKey: dstValue},
want: map[string]string{basicKey: basicValue, srcKey: srcValue, dstKey: dstValue},
},
}
for name, tc := range cases {
t.Log("Running test case: " + name)
result := util.MergeMapOverrideWithDst(tc.src, basicDst)
result = util.MergeMapOverrideWithDst(result, tc.dst)
assert.Equal(t, result, tc.want)
}
}
func TestRawExtension2Map(t *testing.T) {
r1 := runtime.RawExtension{
Raw: []byte(`{"a":{"c":"d"},"b":1}`),
Object: nil,
}
exp1 := map[string]interface{}{
"a": map[string]interface{}{
"c": "d",
},
"b": float64(1),
}
got1, err := util.RawExtension2Map(&r1)
assert.NoError(t, err)
assert.Equal(t, exp1, got1)
r2 := runtime.RawExtension{
Raw: nil,
Object: &unstructured.Unstructured{Object: map[string]interface{}{
"a": map[string]interface{}{
"c": "d",
},
"b": float64(1),
}},
}
got2, err := util.RawExtension2Map(&r2)
assert.NoError(t, err)
assert.Equal(t, exp1, got2)
}
func TestGenDefinitionNsFromCtx(t *testing.T) {
type testcase struct {
ctx context.Context
wantNs string
}
testcases := []testcase{
{ctx: context.TODO(), wantNs: "vela-system"},
{ctx: util.SetNamespaceInCtx(context.Background(), "vela-app"), wantNs: "vela-app"},
{ctx: util.SetNamespaceInCtx(context.Background(), ""), wantNs: "default"},
}
for _, ts := range testcases {
resNs := util.GetDefinitionNamespaceWithCtx(ts.ctx)
assert.Equal(t, ts.wantNs, resNs)
}
}
// TestGetDefinitionError is try to mock test when get an not existed definition in namespaced scope cluster
// will get an error that tpye is not found
func TestGetDefinitionError(t *testing.T) {
ctx := context.Background()
ctx = util.SetNamespaceInCtx(ctx, "vela-app")
errNotFound := apierrors.NewNotFound(schema.GroupResource{Group: "core.oma.dev", Resource: "traitDefinition"}, "mock")
errNeedNamespace := fmt.Errorf("an empty namespace may not be set when a resource name is provided")
getFunc := func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
ns := key.Namespace
if ns != "" {
return errNotFound
} else {
return errNeedNamespace
}
}
client := test.MockClient{MockGet: getFunc}
td := new(v1beta1.TraitDefinition)
got := util.GetDefinition(ctx, &client, td, "mock")
assert.Equal(t, errNotFound, got)
}
// TestGetDefinitionWithClusterScope is try to test compatibility of GetDefinition,
// GetDefinition try to search definition in system-level namespace firstly,
// if not found will search in app namespace, still cannot find it, try to search definition without namespace
func TestGetDefinitionWithClusterScope(t *testing.T) {
ctx := context.Background()
ctx = util.SetNamespaceInCtx(ctx, "vela-app")
// system-level definition
sys := v1beta1.TraitDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "sysDefinition",
Namespace: "vela-system",
},
Spec: v1beta1.TraitDefinitionSpec{
Reference: common.DefinitionReference{
Name: "definitionrefrence.core.oam.dev",
},
},
}
// app workload Definition
app := v1beta1.TraitDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "appDefinition",
Namespace: "vela-app",
},
Spec: v1beta1.TraitDefinitionSpec{
Reference: common.DefinitionReference{
Name: "definitionrefrence",
},
},
}
// old cluster workload trait scope definition crd is cluster scope, the namespace field is empty
noNs := v1beta1.TraitDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "noNsDefinition",
},
Spec: v1beta1.TraitDefinitionSpec{
Reference: common.DefinitionReference{
Name: "definitionrefrence",
},
},
}
tdList := []v1beta1.TraitDefinition{app, sys, noNs}
mockIndexer := map[string]v1beta1.TraitDefinition{}
for i := 0; i < len(tdList); i++ {
var key string
if tdList[i].Namespace != "" {
key = tdList[i].Namespace + "/" + tdList[i].Name
} else {
key = tdList[i].Name
}
mockIndexer[key] = tdList[i]
}
getFunc := func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
var namespacedName string
if key.Namespace != "" {
namespacedName = key.Namespace + "/" + key.Name
} else {
namespacedName = key.Name
}
td, ok := mockIndexer[namespacedName]
if ok {
obj, _ := obj.(*v1beta1.TraitDefinition)
*obj = td
return nil
} else {
return apierrors.NewNotFound(schema.GroupResource{Group: "core.oma.dev", Resource: "traitDefinition"}, namespacedName)
}
}
type want struct {
td *v1beta1.TraitDefinition
err error
}
testcases := map[string]struct {
tdName string
want want
}{
"app namespace is first level": {
tdName: "appDefinition",
want: want{
err: nil,
td: &app,
},
},
"got sys namespace in system levle": {
tdName: "sysDefinition",
want: want{
err: nil,
td: &sys,
},
},
"old cluster traitdefinition crd is cluster scope": {
tdName: "noNsDefinition",
want: want{
err: nil,
td: &noNs,
},
},
"return err search not exsited definition": {
tdName: "notExistedDefinition",
want: want{
err: apierrors.NewNotFound(schema.GroupResource{Group: "core.oma.dev", Resource: "traitDefinition"}, "notExistedDefinition"),
td: new(v1beta1.TraitDefinition),
},
},
}
tclient := test.MockClient{MockGet: getFunc}
for name, tc := range testcases {
got := new(v1beta1.TraitDefinition)
err := util.GetDefinition(ctx, &tclient, got, tc.tdName)
t.Log(fmt.Sprint("Running test: ", name))
assert.Equal(t, tc.want.err, err)
assert.Equal(t, tc.want.td, got)
}
}
func TestGetWorkloadDefinition(t *testing.T) {
// Test common variables
ctx := context.Background()
ctx = util.SetNamespaceInCtx(ctx, "vela-app")
// sys workload Definition
sysWorkloadDefinition := v1beta1.WorkloadDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "mockdefinition",
Namespace: "vela-system",
},
Spec: v1beta1.WorkloadDefinitionSpec{
Reference: common.DefinitionReference{
Name: "definitionrefrence.core.oam.dev",
},
},
}
// app workload Definition
appWorkloadDefinition := v1beta1.WorkloadDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "mockdefinition.core.oam.dev",
Namespace: "vela-app",
},
Spec: v1beta1.WorkloadDefinitionSpec{
Reference: common.DefinitionReference{
Name: "definitionrefrence.core.oam.dev",
},
},
}
type fields struct {
getFunc test.MockGetFn
}
type want struct {
wld v1beta1.WorkloadDefinition
err error
}
cases := map[string]struct {
fields fields
want want
}{
"app defintion will overlay system definition": {
fields: fields{
getFunc: func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
o := obj.(*v1beta1.WorkloadDefinition)
if key.Namespace == "vela-system" {
*o = sysWorkloadDefinition
} else {
*o = appWorkloadDefinition
}
return nil
},
},
want: want{
wld: appWorkloadDefinition,
err: nil,
},
},
"return system definition when cannot find in app ns": {
fields: fields{
getFunc: func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
if key.Namespace == "vela-system" {
o := obj.(*v1beta1.WorkloadDefinition)
*o = sysWorkloadDefinition
return nil
}
return apierrors.NewNotFound(schema.GroupResource{Group: "core.oma.dev", Resource: "workloadDefinition"}, key.Name)
},
},
want: want{
wld: sysWorkloadDefinition,
err: nil,
},
},
}
for name, tc := range cases {
tclient := test.MockClient{
MockGet: tc.fields.getFunc,
}
got := new(v1beta1.WorkloadDefinition)
err := util.GetDefinition(ctx, &tclient, got, "mockdefinition")
t.Log(fmt.Sprint("Running test: ", name))
assert.Equal(t, tc.want.err, err)
assert.Equal(t, tc.want.wld, *got)
}
}
func TestGetTraitDefinition(t *testing.T) {
// Test common variables
ctx := context.Background()
ctx = util.SetNamespaceInCtx(ctx, "vela-app")
// sys workload Definition
sysTraitDefinition := v1beta1.TraitDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "mockdefinition",
Namespace: "vela-system",
},
Spec: v1beta1.TraitDefinitionSpec{
Reference: common.DefinitionReference{
Name: "definitionrefrence.core.oam.dev",
},
},
}
// app workload Definition
appTraitDefinition := v1beta1.TraitDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "mockdefinition.core.oam.dev",
Namespace: "vela-app",
},
Spec: v1beta1.TraitDefinitionSpec{
Reference: common.DefinitionReference{
Name: "definitionrefrence.core.oam.dev",
},
},
}
type fields struct {
getFunc test.MockGetFn
}
type want struct {
wld v1beta1.TraitDefinition
err error
}
cases := map[string]struct {
fields fields
want want
}{
"app defintion will overlay system definition": {
fields: fields{
getFunc: func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
o := obj.(*v1beta1.TraitDefinition)
if key.Namespace == "vela-system" {
*o = sysTraitDefinition
} else {
*o = appTraitDefinition
}
return nil
},
},
want: want{
wld: appTraitDefinition,
err: nil,
},
},
"return system definition when cannot find in app ns": {
fields: fields{
getFunc: func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
if key.Namespace == "vela-system" {
o := obj.(*v1beta1.TraitDefinition)
*o = sysTraitDefinition
return nil
}
return apierrors.NewNotFound(schema.GroupResource{Group: "core.oma.dev", Resource: "workloadDefinition"}, key.Name)
},
},
want: want{
wld: sysTraitDefinition,
err: nil,
},
},
}
for name, tc := range cases {
tclient := test.MockClient{
MockGet: tc.fields.getFunc,
}
got := new(v1beta1.TraitDefinition)
err := util.GetDefinition(ctx, &tclient, got, "mockdefinition")
t.Log(fmt.Sprint("Running test: ", name))
assert.Equal(t, tc.want.err, err)
assert.Equal(t, tc.want.wld, *got)
}
}
func TestGetDefinition(t *testing.T) {
// Test common variables
env := "env-namespace"
// sys workload Definition
sysTraitDefinition := v1beta1.TraitDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "mockdefinition",
Namespace: "vela-system",
},
}
// app workload Definition
appTraitDefinition := v1beta1.TraitDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "mockdefinition",
Namespace: "vela-app",
},
}
// env workload Definition
envTraitDefinition := v1beta1.TraitDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: "mockdefinition",
Namespace: env,
},
}
cli := test.MockClient{MockGet: func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
o := obj.(*v1beta1.TraitDefinition)
switch key.Namespace {
case "vela-system":
*o = sysTraitDefinition
case "vela-app":
*o = appTraitDefinition
case env:
*o = envTraitDefinition
default:
return apierrors.NewNotFound(schema.GroupResource{Group: "core.oma.dev", Resource: "traitDefinition"}, key.Name)
}
return nil
}}
ctx := context.Background()
ctx = util.SetNamespaceInCtx(ctx, "vela-app")
appTd := new(v1beta1.TraitDefinition)
err := util.GetDefinition(ctx, &cli, appTd, "mockTrait")
assert.Equal(t, nil, err)
assert.Equal(t, &appTraitDefinition, appTd)
}
func TestExtractRevisionNum(t *testing.T) {
testcases := []struct {
revName string
wantRevisionNum int
delimiter string
hasError bool
}{{
revName: "myapp-v1",
wantRevisionNum: 1,
delimiter: "-",
hasError: false,
}, {
revName: "new-app-v2",
wantRevisionNum: 2,
delimiter: "-",
hasError: false,
}, {
revName: "v1-v10",
wantRevisionNum: 10,
delimiter: "-",
hasError: false,
}, {
revName: "v10-v1-v1",
wantRevisionNum: 1,
delimiter: "-",
hasError: false,
}, {
revName: "myapp-v1-v2",
wantRevisionNum: 2,
delimiter: "-",
hasError: false,
}, {
revName: "myapp-v1-vv",
wantRevisionNum: 0,
delimiter: "-",
hasError: true,
}, {
revName: "v1",
wantRevisionNum: 0,
delimiter: "-",
hasError: true,
}, {
revName: "myapp-a1",
wantRevisionNum: 0,
delimiter: "-",
hasError: true,
}, {
revName: "worker@v1",
wantRevisionNum: 1,
delimiter: "@",
hasError: false,
}, {
revName: "worke@10r@v1",
wantRevisionNum: 1,
delimiter: "@",
hasError: false,
}, {
revName: "webservice@a10",
wantRevisionNum: 0,
delimiter: "@",
hasError: true,
}}
for _, tt := range testcases {
revision, err := util.ExtractRevisionNum(tt.revName, tt.delimiter)
hasError := err != nil
assert.Equal(t, tt.wantRevisionNum, revision)
assert.Equal(t, tt.hasError, hasError)
}
}
func TestConvertDefinitionRevName(t *testing.T) {
testcases := []struct {
defName string
wantRevName string
hasError bool
}{{
defName: "worker@v2",
wantRevName: "worker-v2",
hasError: false,
}, {
defName: "worker@v10",
wantRevName: "worker-v10",
hasError: false,
}, {
defName: "worker",
wantRevName: "worker",
hasError: false,
}, {
defName: "webservice@@v2",
hasError: true,
}, {
defName: "webservice@v10@v3",
hasError: true,
}, {
defName: "@v10",
hasError: true,
}}
for _, tt := range testcases {
revName, err := util.ConvertDefinitionRevName(tt.defName)
assert.Equal(t, tt.hasError, err != nil)
if !tt.hasError {
assert.Equal(t, tt.wantRevName, revName)
}
}
}
func TestXDefinitionNamespaceInCtx(t *testing.T) {
testcases := []struct {
namespace string
expectedNamespace string
}{{
namespace: "",
expectedNamespace: oam.SystemDefinitionNamespace,
}, {
namespace: oam.SystemDefinitionNamespace,
expectedNamespace: oam.SystemDefinitionNamespace,
}, {
namespace: "my-vela-system",
expectedNamespace: "my-vela-system"},
}
ctx := context.Background()
ns := util.GetXDefinitionNamespaceWithCtx(ctx)
assert.Equal(t, oam.SystemDefinitionNamespace, ns)
for _, tc := range testcases {
ctx = util.SetXDefinitionNamespaceInCtx(ctx, tc.namespace)
ns = util.GetXDefinitionNamespaceWithCtx(ctx)
assert.Equal(t, tc.expectedNamespace, ns)
}
}
|
package maps
import "testing"
func TestSearch(t *testing.T) {
t.Run("Known word", func(t *testing.T) {
const testKey string = "test"
const testValue string = "this is just a test"
dictionary := Dictionary{testKey: testValue}
got, _ := dictionary.Search(testKey)
want := testValue
assertStrings(want, got, t)
})
t.Run("Unknown word", func(t *testing.T) {
dictionary := Dictionary{"myKnownKey": "My known value"}
_, err := dictionary.Search("unknown value")
want := WordNotFoundError
if err == nil {
t.Fatal("Expected to get an error!")
}
assertErrors(want, err, t)
})
t.Run("Add a non-existent word", func(t *testing.T) {
dictionary := Dictionary{}
err := dictionary.Add("key", "value")
if err != nil {
t.Fatal("This must not throw an error!")
}
got, _ := dictionary.Search("key")
want := "value"
assertStrings(want, got, t)
})
t.Run("Add same word twice", func(t *testing.T) {
dictionary := Dictionary{"key": "value"}
err := dictionary.Add("key", "overwrite!")
if err == nil {
t.Fatal("Must throw an error!")
}
assertErrors(KeyAlreadyExistsError, err, t)
})
t.Run("Update a word", func(t *testing.T) {
dictionary := Dictionary{"OWL": "Ordinary Wizarding Level"}
dictionary.Update("OWL", "just an owl!")
got, _ := dictionary.Search("OWL")
assertStrings("just an owl!", got, t)
})
t.Run("Update non-existing word", func(t *testing.T) {
dictionary := Dictionary{}
err := dictionary.Update("Owl", "hu huuhh")
if err == nil {
t.Fatal("must throw error")
}
assertErrors(WordNotFoundError, err, t)
})
}
func assertStrings(want string, got string, t *testing.T) {
t.Helper()
if got != want {
t.Errorf("Wanted %q, but got %q", want, got)
}
}
func assertErrors(want error, got error, t *testing.T) {
t.Helper()
if got != want {
t.Errorf("Wanted %q, but got %q", want.Error(), got.Error())
}
}
|
package main
import (
"controller"
"github.com/zenazn/goji"
)
const (
albumRoutePrefix = "/v1/albums"
)
func main() {
albumController := new(controller.AlbumController)
// POST /v1/albums
goji.Post(albumRoutePrefix, albumController.Store)
// GET /v1/albums
goji.Get(albumRoutePrefix, albumController.Index)
// GET /v1/albums/{{id}}
goji.Get(albumRoutePrefix+"/:id", albumController.Show)
// DELETE /v1/albums/{{id}}
goji.Delete(albumRoutePrefix+"/:id", albumController.Destroy)
// PUT /v1/albums/{{id}}
goji.Put(albumRoutePrefix+"/:id", albumController.Update)
// add "Content-Type: application/json" into responded headers
goji.Use(ApplicationJSON)
misc := new(controller.Misc)
// 404 handler
goji.NotFound(misc.NotFound)
goji.Serve()
}
|
package ui
import (
"context"
"fmt"
"log"
"os"
"fyne.io/fyne/v2"
"fyne.io/fyne/v2/dialog"
"fyne.io/fyne/v2/widget"
"github.com/kouame-florent/axone-cx/api/grpc/gen"
"github.com/kouame-florent/axone-cx/internal/axone"
"github.com/kouame-florent/axone-cx/internal/svc"
)
type AuthView struct {
view
loginEntry widget.Entry
passwordEntry widget.Entry
//grpcConn *grpc.ClientConn
}
func NewAuth(app fyne.App, win fyne.Window) *AuthView {
return &AuthView{
view: view{
Win: win,
},
}
}
func (s *AuthView) MakeUI() {
s.loginEntry = widget.Entry{
PlaceHolder: "Entrez votre identifieant",
}
s.passwordEntry = widget.Entry{
PlaceHolder: "Entrez votre mot de passe",
Password: true,
}
dialog.ShowForm("Authentifcation", "Se connecter", "Abandonner",
[]*widget.FormItem{
widget.NewFormItem("Identifiant", &s.loginEntry),
widget.NewFormItem("Mot de passe", &s.passwordEntry),
},
func(r bool) {
if r {
cli, conn, err := svc.Dial(s.loginEntry.Text, s.passwordEntry.Text)
if err != nil {
dialog.ShowError(err, s.Win)
return
}
defer conn.Close()
resp, err := cli.Login(context.Background(), &gen.LoginRequest{Login: "homer", Password: "homer"})
if err != nil {
dialog.ShowError(err, s.Win)
return
}
setEnvVariables(resp)
next, err := nextUI(SEND_TICKET_VIEW, s.Win)
if err != nil {
dialog.ShowError(err, s.Win)
return
}
s.Win.SetContent(next)
} else {
s.Win.Close()
}
}, s.Win)
}
func setEnvVariables(resp *gen.LoginResponse) {
os.Setenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_ID), resp.UserID)
os.Setenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_LOGIN), resp.Login)
os.Setenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_PASSWORD), resp.Password)
os.Setenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_EMAIL), resp.Email)
os.Setenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_FIRST_NAME), resp.FirstName)
os.Setenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_LAST_NAME), resp.LastName)
}
func nextUI(id viewID, win fyne.Window) (fyne.CanvasObject, error) {
log.Printf("AXONE LOGIN: %s", os.Getenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_LOGIN)))
log.Printf("AXONE PASSWORD: %s", os.Getenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_PASSWORD)))
log.Printf("AXONE USER ID: %s", os.Getenv(string(axone.ENVIRONMENT_VARIABLE_KEY_USER_ID)))
if id == SEND_TICKET_VIEW {
sendTicket := NewSendTicket(win)
return sendTicket.MakeUI(), nil
}
return nil, fmt.Errorf("%s", "cannot build 'SEND TICKET' view")
}
|
package api
import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/mojocn/base64Captcha"
"go.uber.org/zap"
"image/color"
"net/http"
"shop-web/user-api/utils"
)
var store = utils.RedisStore{}
func GetCaptcha(ctx *gin.Context) {
rgba := color.RGBA{
R: 3,
G: 102,
B: 214,
A: 254,
}
fonts := []string{"wqy-microhei.ttc"}
driver := base64Captcha.NewDriverMath(50, 140, 0, 0, &rgba, nil, fonts)
captcha := base64Captcha.NewCaptcha(driver, store)
id, b64s, err := captcha.Generate()
fmt.Println("res: " + b64s)
if err != nil {
zap.S().Errorf("生成验证码错误: %s", err.Error())
ctx.JSON(http.StatusInternalServerError, gin.H{
"msg": "生成验证码错误",
})
return
}
ctx.JSON(http.StatusOK, gin.H{
"captchaId": id,
"pic": b64s,
})
}
|
package main
import "fmt"
type N int
func (n N) value() {
n++
fmt.Println("v: %p %v \n ", &n, n)
}
func (n *N) pointer() {
(*n)++
fmt.Println("v: %p %v \n ", n, *n)
}
func main() {
var a N = 25
p := &a
p2 := &p
(*p2).value()
(*p2).pointer()
}
|
/**
* @file
* @copyright defined in aergo/LICENSE.txt
*/
package system
import (
"math/big"
"testing"
"github.com/aergoio/aergo/types"
"github.com/mr-tron/base58/base58"
"github.com/stretchr/testify/assert"
)
func TestBasicExecute(t *testing.T) {
scs, sender, receiver := initTest(t)
defer deinitTest()
tx := &types.Tx{
Body: &types.TxBody{
Account: sender.ID(),
Recipient: []byte(types.AergoSystem),
Amount: types.StakingMinimum.Bytes(),
Payload: []byte(`{"Name":"v1stake"}`),
},
}
sender.AddBalance(types.StakingMinimum)
emptytx := &types.TxBody{}
_, err := ExecuteSystemTx(scs, emptytx, sender, receiver, 0)
assert.EqualError(t, types.ErrTxInvalidPayload, err.Error(), "Execute system tx failed")
events, err := ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, 0)
assert.NoError(t, err, "Execute system tx failed in staking")
assert.Equal(t, sender.Balance().Uint64(), uint64(0), "sender.Balance() should be 0 after staking")
assert.Equal(t, events[0].ContractAddress, types.AddressPadding([]byte(types.AergoSystem)), "check event")
assert.Equal(t, events[0].EventName, types.Stake[2:], "check event")
staking, err := getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(staking.Amount), "check amount of staking")
tx.Body.Payload = []byte(`{"Name":"v1voteBP","Args":["16Uiu2HAmBDcLEjBYeEnGU2qDD1KdpEdwDBtN7gqXzNZbHXo8Q841"]}`)
tx.Body.Amount = big.NewInt(0).Bytes()
events, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, VotingDelay)
assert.NoError(t, err, "Execute system tx failed in voting")
assert.Equal(t, events[0].ContractAddress, types.AddressPadding([]byte(types.AergoSystem)), "check event")
assert.Equal(t, events[0].EventName, types.VoteBP[2:], "check event")
tx.Body.Payload = []byte(`{"Name":"v1unstake"}`)
tx.Body.Amount = types.StakingMinimum.Bytes()
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, VotingDelay+StakingDelay)
assert.NoError(t, err, "Execute system tx failed in unstaking")
assert.Equal(t, types.StakingMinimum.Bytes(), sender.Balance().Bytes(),
"sender.Balance() should be turn back")
staking, err = getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, big.NewInt(0), new(big.Int).SetBytes(staking.Amount), "check amount of staking")
}
func TestBalanceExecute(t *testing.T) {
scs, sender, receiver := initTest(t)
defer deinitTest()
tx := &types.Tx{
Body: &types.TxBody{
Account: sender.ID(),
Recipient: []byte(types.AergoSystem),
Amount: types.StakingMinimum.Bytes(),
Payload: []byte(`{"Name":"v1stake"}`),
},
}
balance3 := new(big.Int).Mul(types.StakingMinimum, big.NewInt(3))
balance2 := new(big.Int).Mul(types.StakingMinimum, big.NewInt(2))
sender.AddBalance(balance3)
blockNo := uint64(0)
//staking 1
//balance 3-1=2
events, err := ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "Execute system tx failed in staking")
assert.Equal(t, balance2, sender.Balance(), "sender.Balance() should be 0 after staking")
assert.Equal(t, events[0].ContractAddress, types.AddressPadding([]byte(types.AergoSystem)), "check event")
assert.Equal(t, events[0].EventName, types.Stake[2:], "check event")
staking, err := getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(staking.Amount), "check amount of staking")
assert.Equal(t, types.StakingMinimum, receiver.Balance(), "check amount of staking")
tx.Body.Payload = []byte(`{"Name":"v1voteBP","Args":["16Uiu2HAmBDcLEjBYeEnGU2qDD1KdpEdwDBtN7gqXzNZbHXo8Q841"]}`)
tx.Body.Amount = big.NewInt(0).Bytes()
blockNo += VotingDelay
//voting when 1
events, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "Execute system tx failed in voting")
assert.Equal(t, events[0].ContractAddress, types.AddressPadding([]byte(types.AergoSystem)), "check event")
assert.Equal(t, events[0].EventName, types.VoteBP[2:], "check event")
voteResult, err := getVoteResult(scs, defaultVoteKey, 1)
assert.NoError(t, err, "get vote result")
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(voteResult.Votes[0].Amount), "")
tx.Body.Payload = []byte(`{"Name":"v1stake"}`)
tx.Body.Amount = balance2.Bytes()
blockNo += StakingDelay
//staking 1+2 = 3
//balance 2-2 = 0
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "Execute system tx failed in staking")
assert.Equal(t, big.NewInt(0), sender.Balance(), "sender.Balance() should be 0 after staking")
staking, err = getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, balance3, new(big.Int).SetBytes(staking.Amount), "check amount of staking")
assert.Equal(t, balance3, receiver.Balance(), "check amount of staking")
//voting still 1
voteResult, err = getVoteResult(scs, defaultVoteKey, 1)
assert.NoError(t, err, "get vote result")
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(voteResult.Votes[0].Amount), "")
tx.Body.Payload = []byte(`{"Name":"v1unstake"}`)
tx.Body.Amount = types.StakingMinimum.Bytes()
blockNo += StakingDelay
//unstaking 3-1 = 2
//balance 0+1 = 1
//voting still 1
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "Execute system tx failed in unstaking")
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(sender.Balance().Bytes()), "sender.Balance() should be turn back")
staking, err = getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, balance2, new(big.Int).SetBytes(staking.Amount), "check amount of staking")
assert.Equal(t, balance2, receiver.Balance(), "check amount of staking")
voteResult, err = getVoteResult(scs, defaultVoteKey, 1)
assert.NoError(t, err, "get vote reulst")
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(voteResult.Votes[0].Amount), "")
//unstaking 2-3 = -1(fail)
//balance 1
//voting 1
tx.Body.Amount = balance3.Bytes()
blockNo += StakingDelay
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, blockNo)
assert.EqualError(t, types.ErrExceedAmount, err.Error(), "should return exceed error")
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(sender.Balance().Bytes()), "sender.Balance() should be turn back")
staking, err = getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, balance2, new(big.Int).SetBytes(staking.Amount), "check amount of staking")
voteResult, err = getVoteResult(scs, defaultVoteKey, 1)
assert.NoError(t, err, "get vote reulst")
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(voteResult.Votes[0].Amount), "")
tx.Body.Amount = balance2.Bytes()
blockNo += StakingDelay
//unstaking 2-2 = 0
//balance 1+2 = 3
//voting 0
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "Execute system tx failed in unstaking")
assert.Equal(t, balance3, new(big.Int).SetBytes(sender.Balance().Bytes()), "sender.Balance() should be turn back")
staking, err = getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, big.NewInt(0), new(big.Int).SetBytes(staking.Amount), "check amount of staking")
voteResult, err = getVoteResult(scs, defaultVoteKey, 1)
assert.NoError(t, err, "get vote reulst")
assert.Equal(t, big.NewInt(0), new(big.Int).SetBytes(voteResult.Votes[0].Amount), "")
}
func TestBasicFailedExecute(t *testing.T) {
scs, sender, receiver := initTest(t)
defer deinitTest()
tx := &types.Tx{
Body: &types.TxBody{
Account: sender.ID(),
Recipient: []byte(types.AergoSystem),
Amount: types.StakingMinimum.Bytes(),
Payload: buildStakingPayload(false),
},
}
senderBalance := big.NewInt(0).Add(types.StakingMinimum, types.StakingMinimum)
sender.AddBalance(senderBalance)
emptytx := &types.TxBody{}
_, err := ExecuteSystemTx(scs, emptytx, sender, receiver, 0)
assert.EqualError(t, types.ErrTxInvalidPayload, err.Error(), "should error")
//staking 0+1 = 1
//balance 2-1 = 1
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, 0)
assert.Error(t, err, "Execute system tx failed in unstaking")
assert.Equal(t, sender.Balance(), senderBalance, "sender.Balance() should not chagned after failed unstaking")
tx.Body.Payload = buildStakingPayload(true)
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, 0)
assert.NoError(t, err, "Execute system tx failed in staking")
assert.Equal(t, sender.Balance(), types.StakingMinimum, "sender.Balance() should be 0 after staking")
staking, err := getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(staking.Amount), "check amount of staking")
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, StakingDelay-1)
assert.EqualError(t, types.ErrLessTimeHasPassed, err.Error(), "check staking delay")
tx.Body.Payload = buildVotingPayload(1)
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, VotingDelay)
assert.NoError(t, err, "Execute system tx failed in voting")
result, err := getVoteResult(scs, defaultVoteKey, 1)
assert.Equal(t, types.StakingMinimum, result.Votes[0].GetAmountBigInt(), "check vote result")
tx.Body.Payload = buildStakingPayload(false)
tx.Body.Amount = senderBalance.Bytes()
//staking 1-2 = -1 (fail)
//balance still 1
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, VotingDelay+StakingDelay)
assert.Error(t, err, "should failed with exceed error")
assert.Equal(t, types.StakingMinimum, sender.Balance(),
"sender.Balance() should be turn back")
staking, err = getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, types.StakingMinimum, new(big.Int).SetBytes(staking.Amount), "check amount of staking")
//staking 1-1 = 0
//balance 1+1 = 2
tx.Body.Amount = types.StakingMinimum.Bytes()
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, VotingDelay+StakingDelay)
assert.NoError(t, err, "Execute system tx failed in staking")
staking, err = getStaking(scs, tx.GetBody().GetAccount())
assert.Equal(t, senderBalance, sender.Balance(),
"sender.Balance() should be turn back")
assert.Equal(t, big.NewInt(0), new(big.Int).SetBytes(staking.Amount), "check amount of staking")
//staking 0-1 = -1 (fail)
//balance still 2
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, VotingDelay+StakingDelay)
assert.EqualError(t, types.ErrMustStakeBeforeUnstake, err.Error(), "Execute system tx failed in unstaking")
}
func TestValidateSystemTxForStaking(t *testing.T) {
scs, sender, receiver := initTest(t)
defer deinitTest()
scs, err := cdb.GetStateDB().OpenContractStateAccount(types.ToAccountID([]byte("aergo.system")))
assert.NoError(t, err, "could not open contract state")
tx := &types.Tx{
Body: &types.TxBody{
Account: sender.ID(),
Recipient: receiver.ID(),
Amount: types.StakingMinimum.Bytes(),
Payload: buildStakingPayload(true),
},
}
sender.AddBalance(types.StakingMinimum)
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), sender, scs, 0)
assert.NoError(t, err, "Validate system tx failed")
tx.Body.Amount = new(big.Int).Sub(types.StakingMinimum, new(big.Int).SetUint64(1)).Bytes()
}
func TestValidateSystemTxForUnstaking(t *testing.T) {
scs, sender, receiver := initTest(t)
defer deinitTest()
const testSender = "AmPNYHyzyh9zweLwDyuoiUuTVCdrdksxkRWDjVJS76WQLExa2Jr4"
scs, err := cdb.GetStateDB().OpenContractStateAccount(types.ToAccountID([]byte("aergo.system")))
assert.NoError(t, err, "could not open contract state")
account, err := types.DecodeAddress(testSender)
assert.NoError(t, err, "could not decode test address")
tx := &types.Tx{
Body: &types.TxBody{
Account: account,
Amount: types.StakingMinimum.Bytes(),
Payload: buildStakingPayload(false),
},
}
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, 0)
assert.EqualError(t, types.ErrMustStakeBeforeUnstake, err.Error(), "Validate system tx failed")
tx.Body.Amount = new(big.Int).Sub(types.StakingMinimum, new(big.Int).SetUint64(1)).Bytes()
//_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, 0)
//assert.EqualError(t, err, types.ErrMustStakeBeforeUnstake.Error(), "Validate system tx failed")
stakingTx := &types.Tx{
Body: &types.TxBody{
Account: account,
Amount: types.StakingMinimum.Bytes(),
Payload: buildStakingPayload(true),
Type: types.TxType_GOVERNANCE,
},
}
sender.AddBalance(types.StakingMinimum)
_, err = ExecuteSystemTx(scs, stakingTx.GetBody(), sender, receiver, 0)
assert.NoError(t, err, "could not execute system tx")
tx.Body.Amount = types.StakingMinimum.Bytes()
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, StakingDelay-1)
assert.EqualError(t, types.ErrLessTimeHasPassed, err.Error(), "Validate system tx failed")
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, StakingDelay)
assert.NoError(t, err, "failed to validate system tx for unstaking")
}
func TestValidateSystemTxForVoting(t *testing.T) {
scs, sender, receiver := initTest(t)
defer deinitTest()
const testSender = "AmPNYHyzyh9zweLwDyuoiUuTVCdrdksxkRWDjVJS76WQLExa2Jr4"
const testCandidate = "16Uiu2HAmUJhjwotQqm7eGyZh1ZHrVviQJrdm2roQouD329vxZEkx"
candidates, err := base58.Decode(testCandidate)
assert.NoError(t, err, "could not decode candidates")
account, err := types.DecodeAddress(testSender)
assert.NoError(t, err, "could not decode test address")
tx := &types.Tx{
Body: &types.TxBody{
Account: account,
Payload: buildVotingPayload(0),
Type: types.TxType_GOVERNANCE,
},
}
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, 1)
assert.EqualError(t, err, types.ErrMustStakeBeforeVote.Error(), "Execute system tx failed")
tx.Body.Payload = append(tx.Body.Payload, candidates...)
sender.AddBalance(types.StakingMinimum)
stakingTx := &types.Tx{
Body: &types.TxBody{
Account: account,
Amount: types.StakingMinimum.Bytes(),
Payload: buildStakingPayload(true),
Type: types.TxType_GOVERNANCE,
},
}
unStakingTx := &types.Tx{
Body: &types.TxBody{
Account: account,
Amount: types.StakingMinimum.Bytes(),
Payload: buildStakingPayload(false),
Type: types.TxType_GOVERNANCE,
},
}
var blockNo uint64
blockNo = 1
_, err = ExecuteSystemTx(scs, stakingTx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "could not execute system tx")
blockNo += StakingDelay
_, err = ExecuteSystemTx(scs, stakingTx.GetBody(), sender, receiver, blockNo)
assert.EqualError(t, err, types.ErrInsufficientBalance.Error(), "2nd staking tx")
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, blockNo)
assert.Error(t, err, "empty vote should not allowed")
tx.Body.Payload = buildVotingPayload(10)
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, blockNo)
assert.NoError(t, err, "fisrt voting validation should success")
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "fisrt voting execution should success")
blockNo++
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, blockNo)
assert.Error(t, err, "not enough delay, voting should fail")
blockNo += VotingDelay
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, blockNo)
assert.NoError(t, err, "after delay, voting should success")
tx.Body.Payload[1] = '2'
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, blockNo)
t.Log(err.Error())
assert.NotNil(t, err, "failed to validate system tx for voting")
tx.Body.Payload = append(tx.Body.Payload, 'i')
_, err = ValidateSystemTx(tx.Body.Account, tx.GetBody(), nil, scs, blockNo)
assert.EqualError(t, types.ErrTxInvalidPayload, err.Error(), "failed to validate system tx for voting")
blockNo += StakingDelay
_, err = ExecuteSystemTx(scs, unStakingTx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "should execute unstaking system tx")
}
func TestRemainStakingMinimum(t *testing.T) {
scs, sender, receiver := initTest(t)
defer deinitTest()
balance0_5 := new(big.Int).Div(types.StakingMinimum, big.NewInt(2))
balance1 := types.StakingMinimum
balance1_5 := new(big.Int).Add(balance1, balance0_5)
balance2 := new(big.Int).Mul(balance1, big.NewInt(2))
balance3 := new(big.Int).Mul(balance1, big.NewInt(3))
sender.AddBalance(balance3)
stakingTx := &types.Tx{
Body: &types.TxBody{
Account: sender.ID(),
Payload: buildStakingPayload(true),
Type: types.TxType_GOVERNANCE,
},
}
var blockNo uint64
blockNo = 1
stakingTx.Body.Amount = balance0_5.Bytes()
_, err := ExecuteSystemTx(scs, stakingTx.GetBody(), sender, receiver, blockNo)
assert.EqualError(t, err, types.ErrTooSmallAmount.Error(), "could not execute system tx")
//balance 3-1.5=1.5
//staking 0+1.5=1.5
stakingTx.Body.Amount = balance1_5.Bytes()
_, err = ExecuteSystemTx(scs, stakingTx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "could not execute system tx")
blockNo += StakingDelay
stakingTx.Body.Amount = balance0_5.Bytes()
//balance 1.5-0.5=1
//staking 1.5+1.5=3
_, err = ExecuteSystemTx(scs, stakingTx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "could not execute system tx")
stakingTx.Body.Amount = balance2.Bytes()
//balance 1-2=-1 (fail)
_, err = ExecuteSystemTx(scs, stakingTx.GetBody(), sender, receiver, blockNo+1)
assert.EqualError(t, err, types.ErrInsufficientBalance.Error(), "check error")
stakingTx.Body.Amount = balance1.Bytes()
//time fail
_, err = ExecuteSystemTx(scs, stakingTx.GetBody(), sender, receiver, blockNo+1)
assert.EqualError(t, err, types.ErrLessTimeHasPassed.Error(), "check error")
unStakingTx := &types.Tx{
Body: &types.TxBody{
Account: sender.ID(),
Amount: balance0_5.Bytes(),
Payload: buildStakingPayload(false),
Type: types.TxType_GOVERNANCE,
},
}
blockNo += StakingDelay - 1
_, err = ExecuteSystemTx(scs, unStakingTx.GetBody(), sender, receiver, blockNo)
assert.EqualError(t, err, types.ErrLessTimeHasPassed.Error(), "check error")
blockNo += 1
//balance 1+0.5 =1.5
//staking 2-0.5 =1.5
_, err = ExecuteSystemTx(scs, unStakingTx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "could not execute system tx")
staked, err := getStaking(scs, sender.ID())
assert.NoError(t, err, "could not get staking")
assert.Equal(t, balance1_5, sender.Balance(), "could not get staking")
assert.Equal(t, balance1_5, staked.GetAmountBigInt(), "could not get staking")
blockNo += StakingDelay
//balance 1.5+0.5 =2
//staking 1.5-0.5 =1
_, err = ExecuteSystemTx(scs, unStakingTx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "could not execute system tx")
staked, err = getStaking(scs, sender.ID())
assert.NoError(t, err, "could not get staking")
assert.Equal(t, balance2, sender.Balance(), "could not get staking")
assert.Equal(t, balance1, staked.GetAmountBigInt(), "could not get staking")
blockNo += StakingDelay
//staking 1-0.5 =0.5 (fail)
_, err = ExecuteSystemTx(scs, unStakingTx.GetBody(), sender, receiver, blockNo)
assert.EqualError(t, err, types.ErrTooSmallAmount.Error(), "staked aergo remain 0.5")
staked, err = getStaking(scs, sender.ID())
assert.NoError(t, err, "could not get staking")
assert.Equal(t, balance2, sender.Balance(), "could not get staking")
assert.Equal(t, balance1, staked.GetAmountBigInt(), "could not get staking")
blockNo += StakingDelay
unStakingTx.Body.Amount = balance1.Bytes()
//balance 2+1 =3
//staking 1-1 =0
_, err = ExecuteSystemTx(scs, unStakingTx.GetBody(), sender, receiver, blockNo)
assert.NoError(t, err, "could not execute system tx")
staked, err = getStaking(scs, sender.ID())
assert.NoError(t, err, "could not get staking")
assert.Equal(t, balance3, sender.Balance(), "could not get staking")
assert.Equal(t, big.NewInt(0), staked.GetAmountBigInt(), "could not get staking")
_, err = ExecuteSystemTx(scs, unStakingTx.GetBody(), sender, receiver, blockNo)
assert.EqualError(t, err, types.ErrMustStakeBeforeUnstake.Error(), "check error")
}
/*
func TestValidateVoteNumpBP(t *testing.T) {
scs,sender,receiver:=initTest(t)
defer deinitTest()
const testSender = "AmPNYHyzyh9zweLwDyuoiUuTVCdrdksxkRWDjVJS76WQLExa2Jr4"
scs, err := cdb.GetStateDB().OpenContractStateAccount(types.ToAccountID([]byte("aergo.system")))
assert.NoError(t, err, "could not open contract state")
account, err := types.DecodeAddress(testSender)
assert.NoError(t, err, "could not decode test address")
tx := &types.Tx{
Body: &types.TxBody{
Account: account,
Amount: types.StakingMinimum.Bytes(),
Payload: buildStakingPayload(true),
},
}
sender, err := sdb.GetAccountStateV(tx.Body.Account)
assert.NoError(t, err, "could not get test address state")
receiver, err := sdb.GetAccountStateV(tx.Body.Recipient)
assert.NoError(t, err, "could not get test address state")
sender.AddBalance(types.StakingMinimum)
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, 0)
assert.NoError(t, err, "Execute system tx failed in staking")
tx.Body.Payload = buildVotingPayloadEx(1, types.VoteBP)
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, 1)
assert.NoError(t, err, "Execute system tx failed in voting")
tx.Body.Payload = buildVotingPayloadEx(1, types.VoteNumBP)
_, err = ExecuteSystemTx(scs, tx.GetBody(), sender, receiver, 2)
assert.NoError(t, err, "Execute system tx failed in voting")
}
*/
|
package guidService
import (
"github.com/button-tech/BNBTextWallet/data"
"github.com/button-tech/BNBTextWallet/services/redisService"
"github.com/google/uuid"
"time"
)
const guidLifetime = 100 * time.Minute
func Generate(data data.DiscordGuidStamp) (string, error) {
guid := generateGuid()
return guid, redisService.CreateOrUpdateGuid(guid, data, guidLifetime)
}
func Read(guid string) (data.DiscordGuidStamp, error) {
return redisService.ReadGuid(guid)
}
func Delete(guid string) error {
return redisService.DeleteGuid(guid)
}
func generateGuid() string {
guid := uuid.New().String()
return guid[:10]
}
|
package api
import (
"fmt"
)
func main() {
fmt.Println('api')
}
|
package carbonserver
import (
"encoding/json"
"fmt"
"go.uber.org/zap/zapcore"
"net/http"
_ "net/http/pprof"
"strconv"
"strings"
"sync/atomic"
"time"
"go.uber.org/zap"
tindex "github.com/lomik/go-carbon/tags/index"
// protov2 "github.com/go-graphite/protocol/carbonapi_v2_pb"
// protov3 "github.com/go-graphite/protocol/carbonapi_v3_pb"
)
type tagValue struct {
Count int32
Value string
}
type statTagResponse struct {
Tag string
Values []tagValue
}
type listTagsResponse struct {
Tags []tagType
}
type tagType struct {
Tag string
}
func (listener *CarbonserverListener) statTagHandler(wr http.ResponseWriter, req *http.Request) {
// URL: /tags/datacenter?format=pickle&pretty=1&filter=data
t0 := time.Now()
ctx := req.Context()
atomic.AddUint64(&listener.metrics.StatTag, 1)
req.ParseForm()
format := req.FormValue("format")
filter := req.FormValue("filter")
var tag string
if strings.Count(req.URL.Path, "/") >= 2 {
tag = req.URL.Path[6:]
}
var limit = 100
if num, err := strconv.Atoi(req.FormValue("limit")); err == nil {
limit = num
}
accessLogger := TraceContextToZap(ctx, listener.accessLogger.With(
zap.String("handler", "statTag"),
zap.String("url", req.URL.RequestURI()),
zap.String("peer", req.RemoteAddr),
zap.String("format", format),
zap.String("filter", filter),
))
if format != "json" && format != "pickle" && format != "protobuf" && format != "protobuf3" {
atomic.AddUint64(&listener.metrics.StatTagErrors, 1)
accessLogger.Error("statTag failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", "unsupported format"),
zap.Int("http_code", http.StatusBadRequest),
)
http.Error(wr, "Bad request (unsupported format)",
http.StatusBadRequest)
return
}
if tag == "" {
atomic.AddUint64(&listener.metrics.StatTagErrors, 1)
accessLogger.Error("statTag failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", "empty tag name"),
zap.Int("http_code", http.StatusBadRequest),
)
http.Error(wr, "Bad request (no query)", http.StatusBadRequest)
return
}
var err error
var contentType string
var data = []byte("{}")
stat := listener.tagsIdx.StatTag(tag, filter, limit)
if stat != nil {
var resp statTagResponse
resp.Tag = stat.Tag
for _, val := range stat.Values {
resp.Values = append(resp.Values, tagValue{Count: int32(val.Count), Value: val.Value})
}
switch format {
case "json":
contentType = "application/json"
data, err = json.Marshal(resp)
/*
case "protobuf", "protobuf3":
contentType = "application/protobuf"
data, err = resp.Marshal()
*/
}
}
if err != nil {
accessLogger.Error("statTag failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", "internal error while processing request"),
zap.Error(err),
zap.Int("http_code", http.StatusInternalServerError),
)
http.Error(wr, fmt.Sprintf("Internal error while processing request (%v)", err),
http.StatusInternalServerError)
return
}
wr.Header().Set("Content-Type", contentType)
wr.Write(data)
accessLogger.Info("statTag success",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("tag", tag),
zap.String("filter", filter),
zap.Int("http_code", http.StatusOK),
)
return
}
func (listener *CarbonserverListener) listTagsHandler(wr http.ResponseWriter, req *http.Request) {
// URL: /tags/?format=pickle&pretty=1&filter=data
t0 := time.Now()
ctx := req.Context()
atomic.AddUint64(&listener.metrics.FindTags, 1)
req.ParseForm()
format := req.FormValue("format")
filter := req.FormValue("filter")
var limit = 100
if num, err := strconv.Atoi(req.FormValue("limit")); err == nil {
limit = num
}
accessLogger := TraceContextToZap(ctx, listener.accessLogger.With(
zap.String("handler", "listTags"),
zap.String("url", req.URL.RequestURI()),
zap.String("peer", req.RemoteAddr),
zap.String("format", format),
zap.String("filter", filter),
))
if format != "json" && format != "pickle" && format != "protobuf" && format != "protobuf3" {
atomic.AddUint64(&listener.metrics.FindTagsErrors, 1)
accessLogger.Error("listTags failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", "unsupported format"),
zap.Int("http_code", http.StatusBadRequest),
)
http.Error(wr, "Bad request (unsupported format)",
http.StatusBadRequest)
return
}
var err error
var data = []byte(`{}`)
var contentType string
tags := listener.tagsIdx.ListTags(filter, limit)
var resp listTagsResponse
for _, tag := range tags {
resp.Tags = append(resp.Tags, tagType{Tag: tag})
}
switch format {
case "json":
contentType = "application/json"
data, err = json.Marshal(resp)
/*
case "protobuf", "protobuf3":
contentType = "application/protobuf"
data, err = resp.Marshal()
*/
}
if err != nil {
accessLogger.Error("listTags failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", "internal error while processing request"),
zap.Error(err),
zap.Int("http_code", http.StatusInternalServerError),
)
http.Error(wr, fmt.Sprintf("Internal error while processing request (%v)", err),
http.StatusInternalServerError)
return
}
wr.Header().Set("Content-Type", contentType)
wr.Write(data)
accessLogger.Info("listTags success",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.Int("tags", len(tags)),
zap.String("filter", filter),
zap.Int("http_code", http.StatusOK),
)
return
}
func (listener *CarbonserverListener) seriesByTagHandler(wr http.ResponseWriter, req *http.Request) {
// URL: /seriesByTag?format=pickle&pretty=1&filter=data
t0 := time.Now()
ctx := req.Context()
atomic.AddUint64(&listener.metrics.SeriesByTag, 1)
req.ParseForm()
from := req.FormValue("from")
until := req.FormValue("until")
var metricExpr *tindex.TagValueExpr
if req.FormValue("metricExpr") != "" {
metricExpr = tindex.NewTagValueExpr(req.FormValue("metricExpr"))
}
var tagValues []*tindex.TagValueExpr
for _, expr := range req.Form["tagValues"] {
tagValues = append(tagValues, tindex.NewTagValueExpr(expr))
}
var limit = 100
if num, err := strconv.Atoi(req.FormValue("limit")); err == nil {
limit = num
}
zapFields := []zapcore.Field{
zap.String("handler", "seriesByTag"),
zap.String("url", req.URL.RequestURI()),
zap.String("peer", req.RemoteAddr),
// zap.String("format", format),
zap.String("from", from),
zap.String("until", until),
zap.String("metricExpr", req.FormValue("metricExpr")),
zap.Strings("tagValues", req.Form["tagValues"]),
}
logger := TraceContextToZap(ctx, listener.logger.With(zapFields...))
accessLogger := TraceContextToZap(ctx, listener.accessLogger.With(zapFields...))
format, err := getFormat(req)
if err != nil {
atomic.AddUint64(&listener.metrics.RenderErrors, 1)
accessLogger.Error("fetch failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", err.Error()),
zap.Int("http_code", http.StatusBadRequest),
)
http.Error(wr, fmt.Sprintf("Bad request: %s", err), http.StatusBadRequest)
return
}
targets, err := getTargets(req, format)
if err != nil {
atomic.AddUint64(&listener.metrics.RenderErrors, 1)
accessLogger.Error("fetch failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", err.Error()),
zap.Int("http_code", http.StatusBadRequest),
)
http.Error(wr, fmt.Sprintf("Bad request: %s", err), http.StatusBadRequest)
return
}
tgs := getTargetNames(targets)
accessLogger = accessLogger.With(
zap.Strings("targets", tgs),
)
if len(tagValues) == 0 {
atomic.AddUint64(&listener.metrics.SeriesByTagErrors, 1)
accessLogger.Error("seriesByTag failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", "empty tagValues"),
zap.Int("http_code", http.StatusBadRequest),
)
http.Error(wr, "Bad request (no query)", http.StatusBadRequest)
return
}
metrics := listener.tagsIdx.ListMetrics(metricExpr, tagValues, limit)
paths := make([]string, 0, len(metrics))
for _, m := range metrics {
paths = append(paths, m.Path)
}
response, _, err := listener.fetchWithCache(logger, format, targets)
if err != nil {
accessLogger.Error("seriesByTag failed",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.String("reason", "internal error while processing request"),
zap.Error(err),
zap.Int("http_code", http.StatusInternalServerError),
)
http.Error(wr, fmt.Sprintf("Internal error while processing request (%v)", err),
http.StatusInternalServerError)
return
}
wr.Header().Set("Content-Type", response.contentType)
wr.Write(response.data)
accessLogger.Info("seriesByTag success",
zap.Duration("runtime_seconds", time.Since(t0)),
zap.Int("metrics_size", len(metrics)),
zap.Int("http_code", http.StatusOK),
)
return
}
|
package env
import (
"flag"
"fmt"
"os"
"time"
)
var (
appname string
nodeid string
)
func init() {
flag.StringVar(&appname, "appname", "", "AppName of application. e.g. -appname=nekoq")
flag.StringVar(&nodeid, "node", "", "Unique Node Id of application. e.g. -node=nekoq001")
flag.Parse()
ensure, found := os.LookupEnv("NEKO_NOT_ENSURE_ENV")
if found && ensure == "true" {
return
} else {
EnsureEnvFlag()
return
}
}
func EnsureEnvFlag() {
if appname == "" {
_, _ = fmt.Fprintln(os.Stderr, "Please set AppName using flag '-appname'.")
n := time.Now()
appname = fmt.Sprintf("sampleapp_%d", n.Unix())
}
if nodeid == "" {
_, _ = fmt.Fprintln(os.Stderr, "Please set NodeId using flag '-node'.")
n := time.Now()
appname = fmt.Sprintf("samplenode_%d", n.Unix())
}
}
|
package usecase
import (
"github.com/Arkadiyche/bd_techpark/internal/pkg/models"
"github.com/Arkadiyche/bd_techpark/internal/pkg/user"
)
type UserUseCase struct {
UserRepository user.Repository
}
func NewUserUseCase(userRepository user.Repository) *UserUseCase {
return &UserUseCase{
UserRepository: userRepository,
}
}
func (u *UserUseCase) Create(user models.User) (users *models.Users, error error) {
if err := u.UserRepository.Insert(user); err != nil {
users, err = u.UserRepository.SelectByNicknameOrEmail(user.Nickname, user.Email)
if err != nil {
return nil, err
}
return users, models.Exist
}
return nil, nil
}
func (u *UserUseCase) GetProfile(nickname string) (user *models.User, error *models.Error) {
user, err := u.UserRepository.SelectByNickname(nickname)
return user, err
}
func (u *UserUseCase) UpdateProfile(user *models.User) (error *models.Error) {
err := u.UserRepository.Update(user)
return err
}
|
package controllers
import (
"github.com/devplayg/ipas-mcs/objs"
"github.com/devplayg/ipas-mcs/models"
"strconv"
log "github.com/sirupsen/logrus"
"strings"
)
type IpaslistController struct {
baseController
}
func (c *IpaslistController) GetIpasInOrg() {
filter := c.getFilter()
logs, total, err := models.GetIpaslist(c.member, filter)
c.serveResultJson(logs, total, err, filter.FastPaging)
}
func (c *IpaslistController) GetIpasInGroup() {
filter := c.getFilter()
logs, total, err := models.GetIpaslist(c.member, filter)
c.serveResultJson(logs, total, err, filter.FastPaging)
}
func (c *IpaslistController) getFilter() *objs.IpasFilter {
filter := objs.IpasFilter{}
if err := c.ParseForm(&filter); err != nil {
log.Error(err)
}
orgId, _ := strconv.Atoi(c.Ctx.Input.Param(":orgId"))
if orgId > 0 {
filter.OrgId = append(filter.OrgId, orgId)
}
groupId, _ := strconv.Atoi(c.Ctx.Input.Param(":groupId"))
if groupId > 0 {
filter.GroupId = append(filter.GroupId, groupId)
}
// 페이징 처리
if filter.Sort == "" {
filter.Sort = "equip_id"
}
if filter.Order == "" {
filter.Order = "asc"
}
if filter.Limit < 1 {
filter.Limit = 15
}
if filter.FastPaging == "" {
filter.FastPaging = "off"
}
return &filter
}
func (c *IpaslistController) UpdateIpasGroup() {
groupId, _ := strconv.Atoi(c.Ctx.Input.Param(":groupId"))
type input struct {
List []string `form:"list[]"`
}
form := input{}
if err := c.ParseForm(&form); err != nil {
CheckError(err)
}
list := make([]objs.Ipas, 0)
for _, s := range form.List {
arr := strings.SplitN(s, "/", 2)
orgId, _ := strconv.Atoi(arr[0])
list = append(list, objs.Ipas{
OrgId: orgId,
EquipId: arr[1],
})
}
dbResult := objs.NewDbResult()
rs, err := models.UpdateIpasGroup(groupId, list)
if err != nil {
dbResult.Message = err.Error()
} else {
dbResult.State = true
dbResult.AffectedRows, _ = rs.RowsAffected()
}
c.Data["json"] = dbResult
c.ServeJSON()
}
|
// Copyright © 2019 IBM Corporation and others.
//
// 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 cmd_test
import (
"testing"
"github.com/appsody/appsody/cmd/cmdtest"
)
var repoListTests = []struct {
configFile string // input
expectedNumRepos int // number of expected repositories to list
}{
{"testdata/empty_repository_config/config.yaml", 0},
{"testdata/default_repository_config/config.yaml", 1},
{"testdata/multiple_repository_config/config.yaml", 2},
}
func TestRepoList(t *testing.T) {
for _, tt := range repoListTests {
// call t.Run so that we can name and report on individual tests
t.Run(tt.configFile, func(t *testing.T) {
args := []string{"repo", "list"}
if tt.configFile != "" {
args = append(args, "--config", tt.configFile)
}
output, err := cmdtest.RunAppsodyCmdExec(args, ".")
if err != nil {
t.Fatal(err)
}
repos := cmdtest.ParseRepoList(output)
if len(repos) != tt.expectedNumRepos {
t.Errorf("Expected %d repos but found %d. CLI output:\n%s",
tt.expectedNumRepos, len(repos), output)
}
})
}
}
|
package main
import (
"github.com/stretchr/testify/assert"
"testing"
)
func Test_test(t *testing.T) {
res := maxSumAfterPartitioning([]int{1, 15, 7, 9, 2, 5, 10}, 3)
assert.Equal(t, 84, res)
}
|
package router
import (
"collectbackend/controllers"
middlewares "collectbackend/middlewares"
"github.com/gin-gonic/gin"
)
// InitRouter 路由初始化
func InitRouter() {
router := gin.Default()
// 要在路由组之前全局使用「跨域中间件」, 否则OPTIONS会返回404
router.Use(middlewares.Cors())
// 使用 session(cookie-based)
// router.Use(sessions.Sessions("myyyyysession", Sessions.Store))
backend := router.Group("backend")
{
// v1.POST("/testinsert", controllers.IndexPage)
backend.GET("/indexpage", controllers.IndexPageGET)
backend.POST("/searchindex", controllers.IndexPageSearch)
backend.GET("/getallcate", controllers.GetAllCategory)
// v1.GET("/getdetail",)
backend.POST("/newIndex", controllers.NewIndx)
backend.GET("/getIndexTable", controllers.IndxRecordTable)
backend.GET("/getIndexInfo", controllers.IndxInfo)
backend.POST("/newrecord", controllers.NewRecord)
// backend.GET("/test", controllers.NewCate)
}
router.Run(":8080")
}
|
package client
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"os"
"strconv"
"strings"
"time"
"github.com/sirupsen/logrus"
tuf "github.com/theupdateframework/notary/tuf/data"
)
type Api struct {
serverUrl string
apiToken string
}
type NetInfo struct {
Hostname string `json:"hostname"`
Ipv4 string `json:"local_ipv4"`
MAC string `json:"mac"`
}
type Update struct {
CorrelationId string `json:"correlation-id"`
Target string `json:"target"`
Version string `json:"version"`
Time string `json:"time"`
}
type UpdateList struct {
Updates []Update `json:"updates"`
Total int `json:"total"`
Next *string `json:"next"`
}
type EventType struct {
Id string `json:"id"`
}
type EventDetail struct {
Version string `json:"version"`
TargetName string `json:"targetName"`
Success *bool `json:"success,omitempty"`
}
type UpdateEvent struct {
Time string `json:"deviceTime"`
Type EventType `json:"eventType"`
Detail EventDetail `json:"event"`
}
type Device struct {
Uuid string `json:"uuid"`
Name string `json:"name"`
Owner string `json:"owner"`
Factory string `json:"factory"`
CreatedAt string `json:"created-at"`
LastSeen string `json:"last-seen"`
OstreeHash string `json:"ostree-hash"`
DockerApps []string `json:"docker-apps,omitempty"`
Tags []string `json:"device-tags,omitempty"`
Network *NetInfo `json:"network-info,omitempty"`
Hardware *json.RawMessage `json:"hardware-info,omitempty"`
TargetName string `json:"target-name"`
Status string `json:"status"`
CurrentUpdate string `json:"current-update"`
}
type DeviceList struct {
Devices []Device `json:"devices"`
Total int `json:"total"`
Next *string `json:"next"`
}
type DockerApp struct {
FileName string `json:"filename"`
}
type TufCustom struct {
HardwareIds []string `json:"hardwareIds,omitempty"`
Tags []string `json:"tags,omitempty"`
TargetFormat string `json:"targetFormat,omitempty"`
Version string `json:"version,omitempty"`
DockerApps map[string]DockerApp `json:"docker_apps,omitempty"`
}
func NewApiClient(serverUrl, apiToken string) *Api {
api := Api{strings.TrimRight(serverUrl, "/"), apiToken}
return &api
}
func (a *Api) RawGet(url string, headers *map[string]string) (*http.Response, error) {
client := http.Client{
Timeout: time.Second * 10,
}
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
return nil, err
}
req.Header.Set("User-Agent", "fioctl")
req.Header.Set("OSF-TOKEN", a.apiToken)
if headers != nil {
for key, val := range *headers {
req.Header.Set(key, val)
}
}
return client.Do(req)
}
func (a *Api) Get(url string) (*[]byte, error) {
res, err := a.RawGet(url, nil)
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
if res.StatusCode != 200 {
return nil, fmt.Errorf("Unable to get '%s': HTTP_%d\n=%s", url, res.StatusCode, body)
}
return &body, nil
}
func (a *Api) Patch(url string, data []byte) (*[]byte, error) {
client := http.Client{
Timeout: time.Second * 10,
}
req, err := http.NewRequest(http.MethodPatch, url, bytes.NewBuffer(data))
if err != nil {
return nil, err
}
req.Header.Set("User-Agent", "fioctl")
req.Header.Set("OSF-TOKEN", a.apiToken)
req.Header.Set("Content-Type", "application/json")
res, err := client.Do(req)
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
if res.StatusCode != 202 {
return nil, fmt.Errorf("Unable to PATCH '%s': HTTP_%d\n=%s", url, res.StatusCode, body)
}
return &body, nil
}
func (a *Api) Delete(url string, data []byte) (*[]byte, error) {
client := http.Client{
Timeout: time.Second * 10,
}
req, err := http.NewRequest(http.MethodDelete, url, bytes.NewBuffer(data))
if err != nil {
return nil, err
}
req.Header.Set("User-Agent", "fioctl")
req.Header.Set("OSF-TOKEN", a.apiToken)
req.Header.Set("Content-Type", "application/json")
res, err := client.Do(req)
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
if res.StatusCode != 202 && res.StatusCode != 200 {
return nil, fmt.Errorf("Unable to DELETE '%s': HTTP_%d\n=%s", url, res.StatusCode, body)
}
return &body, nil
}
func (a *Api) DeviceGet(device string) (*Device, error) {
body, err := a.Get(a.serverUrl + "/ota/devices/" + device + "/")
if err != nil {
return nil, err
}
d := Device{}
err = json.Unmarshal(*body, &d)
if err != nil {
return nil, err
}
return &d, nil
}
func (a *Api) DeviceList(shared bool, match_tag, name_ilike string) (*DeviceList, error) {
shared_int := 0
if shared {
shared_int = 1
}
url := a.serverUrl + "/ota/devices/?"
url += fmt.Sprintf("shared=%d&match_tag=%s&name_ilike=%s", shared_int, match_tag, name_ilike)
logrus.Debugf("DeviceList with url: %s", url)
return a.DeviceListCont(url)
}
func (a *Api) DeviceListCont(url string) (*DeviceList, error) {
body, err := a.Get(url)
if err != nil {
return nil, err
}
devices := DeviceList{}
err = json.Unmarshal(*body, &devices)
if err != nil {
return nil, err
}
return &devices, nil
}
func (a *Api) DeviceDelete(device string) error {
bytes := []byte{}
_, err := a.Delete(a.serverUrl+"/ota/devices/"+device+"/", bytes)
return err
}
func (a *Api) DeviceListUpdates(device string) (*UpdateList, error) {
return a.DeviceListUpdatesCont(a.serverUrl + "/ota/devices/" + device + "/updates/")
}
func (a *Api) DeviceListUpdatesCont(url string) (*UpdateList, error) {
body, err := a.Get(url)
if err != nil {
return nil, err
}
updates := UpdateList{}
err = json.Unmarshal(*body, &updates)
if err != nil {
return nil, err
}
return &updates, nil
}
func (a *Api) DeviceUpdateEvents(device, correlationId string) ([]UpdateEvent, error) {
var events []UpdateEvent
body, err := a.Get(a.serverUrl + "/ota/devices/" + device + "/updates/" + correlationId + "/")
if err != nil {
return nil, err
}
err = json.Unmarshal(*body, &events)
if err != nil {
return events, err
}
return events, nil
}
func (a *Api) TargetsListRaw(factory string) (*[]byte, error) {
url := a.serverUrl + "/ota/repo/" + factory + "/api/v1/user_repo/targets.json"
return a.Get(url)
}
func (a *Api) TargetsList(factory string) (*tuf.SignedTargets, error) {
body, err := a.TargetsListRaw(factory)
if err != nil {
return nil, err
}
targets := tuf.SignedTargets{}
err = json.Unmarshal(*body, &targets)
if err != nil {
return nil, err
}
return &targets, nil
}
func (a *Api) TargetCustom(target tuf.FileMeta) (*TufCustom, error) {
custom := TufCustom{}
err := json.Unmarshal(*target.Custom, &custom)
if err != nil {
return nil, err
}
return &custom, nil
}
func (a *Api) TargetUpdateTags(factory string, target_names []string, tag_names []string) (string, error) {
type EmptyTarget struct {
Custom TufCustom `json:"custom"`
}
tags := EmptyTarget{TufCustom{Tags: tag_names}}
type Update struct {
Targets map[string]EmptyTarget `json:"targets"`
}
update := Update{map[string]EmptyTarget{}}
for idx := range target_names {
update.Targets[target_names[idx]] = tags
}
data, err := json.Marshal(update)
if err != nil {
return "", err
}
url := a.serverUrl + "/ota/factories/" + factory + "/targets/"
resp, err := a.Patch(url, data)
if err != nil {
return "", err
}
type PatchResp struct {
JobServUrl string `json:"jobserv-url"`
}
pr := PatchResp{}
if err := json.Unmarshal(*resp, &pr); err != nil {
return "", err
}
return pr.JobServUrl + "runs/UpdateTargets/console.log", nil
}
func (a *Api) TargetDeleteTargets(factory string, target_names []string) (string, error) {
type Update struct {
Targets []string `json:"targets"`
}
update := Update{}
update.Targets = target_names
data, err := json.Marshal(update)
if err != nil {
return "", err
}
url := a.serverUrl + "/ota/factories/" + factory + "/targets/"
resp, err := a.Delete(url, data)
if err != nil {
return "", err
}
type PatchResp struct {
JobServUrl string `json:"jobserv-url"`
}
pr := PatchResp{}
if err := json.Unmarshal(*resp, &pr); err != nil {
return "", err
}
return pr.JobServUrl + "runs/UpdateTargets/console.log", nil
}
func (a *Api) JobservTail(url string) {
offset := 0
status := ""
for {
headers := map[string]string{"X-OFFSET": strconv.Itoa(offset)}
resp, err := a.RawGet(url, &headers)
if err != nil {
fmt.Printf("TODO LOG ERROR OR SOMETHING: %s\n", err)
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Printf("Unable to read body resp: %s", err)
}
if resp.StatusCode != 200 {
fmt.Printf("Unable to get '%s': HTTP_%d\n=%s", url, resp.StatusCode, body)
}
newstatus := resp.Header.Get("X-RUN-STATUS")
if newstatus == "QUEUED" {
if status == "" {
os.Stdout.Write(body)
} else {
os.Stdout.WriteString(".")
}
} else if len(newstatus) == 0 {
body = body[offset:]
os.Stdout.Write(body)
return
} else {
if newstatus != status {
fmt.Printf("\n--- Status change: %s -> %s\n", status, newstatus)
}
os.Stdout.Write(body)
offset += len(body)
}
status = newstatus
time.Sleep(5 * time.Second)
}
}
|
package account
import (
"github.com/go-openapi/runtime/middleware"
"github.com/go-openapi/swag"
"mingchuan.me/api"
"mingchuan.me/api/models"
apiAccount "mingchuan.me/api/restapi/operations/account"
"mingchuan.me/app/errors"
)
// Routes - create a struct with instance inside it
// this is to help do mock testing
type AccountController struct {
*api.API
Service *AccountService
}
// CreateController -
func CreateController(api *api.API, service *AccountService) *AccountController {
return &AccountController{
API: api,
Service: service,
}
}
// TODO - use a unique key to avoid uncontrol register admin
// RegisterAdmin -
func (c *AccountController) RegisterAdmin() {
API := c.API
service := c.Service
API.AccountRegisterAdminHandler = apiAccount.RegisterAdminHandlerFunc(
func(params apiAccount.RegisterAdminParams) middleware.Responder {
request := params.Request
// parse params
name := swag.StringValue(request.Name)
password := swag.StringValue(request.Password)
isAdmin := true
// service
jwt, err := service.RegisterAndSign(name, password, isAdmin)
if err != nil {
// TODO: more specific error
wErr := errors.UnknownError(err)
return apiAccount.NewRegisterAdminBadRequest().WithPayload(api.ModelServiceError(wErr))
}
// construct payload
resp := models.JwtResponse{
Jwt: swag.String(jwt),
}
return apiAccount.NewRegisterAdminOK().WithPayload(&resp)
})
}
// Login -
func (c *AccountController) Login() {
API := c.API
service := c.Service
API.AccountLoginHandler = apiAccount.LoginHandlerFunc(
func(params apiAccount.LoginParams) middleware.Responder {
request := params.Request
// parse params
name := swag.StringValue(request.Name)
password := swag.StringValue(request.Password)
// service
jwt, err := service.VerifyAccount(name, password)
if err != nil {
wErr := errors.UnknownError(err)
return apiAccount.NewLoginBadRequest().WithPayload(api.ModelServiceError(wErr))
}
resp := models.JwtResponse{
Jwt: swag.String(jwt),
}
return apiAccount.NewLoginOK().WithPayload(&resp)
})
}
|
package actions
import (
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"log"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/lestrrat/go-libxml2"
"github.com/lestrrat/go-libxml2/types"
"github.com/mahendrakalkura/torrents/go/settings"
"github.com/mvdan/xurls"
"github.com/xtgo/set"
)
// Item ...
type Item struct {
Category string `json:"category"`
Timestamp string `json:"timestamp"`
Seeds int `json:"seeds"`
URL string `json:"url"`
Title string `json:"title"`
URLs []string `json:"urls"`
Magnet string `json:"magnet"`
}
// Items ...
type Items []Item
func (items Items) Len() int {
return len(items)
}
func (items Items) Swap(one, two int) {
items[one], items[two] = items[two], items[one]
}
func (items Items) Less(one, two int) bool {
if items[one].Category < items[two].Category {
return true
}
if items[one].Category > items[two].Category {
return false
}
if items[one].Timestamp > items[two].Timestamp {
return true
}
if items[one].Timestamp < items[two].Timestamp {
return false
}
return items[one].Seeds > items[two].Seeds
}
func exists(items Items, message Item) bool {
for _, item := range items {
if item.URL == message.URL {
return true
}
}
return false
}
func consumer(waitGroup *sync.WaitGroup, count int, outgoing chan string, incoming chan Items) {
defer waitGroup.Done()
items := Items{}
for messages := range incoming {
for _, message := range messages {
if exists(items, message) {
continue
}
items = append(items, message)
}
count--
if count == 0 {
close(outgoing)
close(incoming)
break
}
}
sort.Sort(items)
marshal, marshalErr := json.Marshal(items)
if marshalErr != nil {
log.Fatalln(marshalErr)
}
err := ioutil.WriteFile("torrents.json", marshal, 0644)
if err != nil {
log.Fatalln(err)
}
}
func producer(waitGroup *sync.WaitGroup, outgoing chan string, incoming chan Items) {
defer waitGroup.Done()
for url := range outgoing {
items, itemsErr := getItems(url)
if itemsErr != nil {
outgoing <- url
continue
}
incoming <- items
}
}
func getCategory(node types.Node) string {
xPath, xPathErr := node.Find(`.//center`)
if xPathErr != nil {
return ""
}
text := xPath.String()
xPath.Free()
regularExpression := regexp.MustCompile(`\s+`)
replaceAllString := regularExpression.ReplaceAllString(text, " ")
trimSpace := strings.TrimSpace(replaceAllString)
return trimSpace
}
func getSeeds(node types.Node) int {
xPath, xPathErr := node.Find(`.//text()`)
if xPathErr != nil {
return 0
}
text := xPath.String()
xPath.Free()
seeds, seedsErr := strconv.Atoi(text)
if seedsErr != nil {
return 0
}
return seeds
}
func getURL(baseURL string, node types.Node) string {
parse, parseErr := url.Parse(baseURL)
if parseErr != nil {
return ""
}
xPath, xPathErr := node.Find(`.//div/a/@href`)
if xPathErr != nil {
return ""
}
text := xPath.String()
xPath.Free()
url := fmt.Sprintf("%s://%s%s", parse.Scheme, parse.Host, text)
return url
}
func getTitle(node types.Node) string {
xPath, xPathErr := node.Find(`.//div/a/text()`)
if xPathErr != nil {
return ""
}
title := xPath.String()
xPath.Free()
return title
}
func getURLsA(document types.Document) []string {
xPath, xPathErr := document.Find(`//div[@class="nfo"]/pre`)
if xPathErr != nil {
return []string{}
}
text := xPath.String()
xPath.Free()
urls := xurls.Strict.FindAllString(text, -1)
return urls
}
func getURLsB(document types.Document) []string {
xPath, xPathErr := document.Find(`//a`)
if xPathErr != nil {
return []string{}
}
urls := []string{}
bodes := xPath.NodeList()
for _, bode := range bodes {
xPath, xPathErr := bode.Find(`.//@href`)
if xPathErr != nil {
continue
}
text := xPath.String()
xPath.Free()
if !strings.HasPrefix(text, "http") {
continue
}
parse, parseErr := url.Parse(text)
if parseErr != nil {
continue
}
if parse.Host != "imdb.com" {
continue
}
urls = append(urls, text)
}
return urls
}
func getTimestamp(document types.Document) string {
xPath, xPathErr := document.Find(`//dt[contains(text(), "Uploaded:")]/following-sibling::dd/text()`)
if xPathErr != nil {
return "0000-00-00 00:00:00"
}
timestamp := xPath.String()
xPath.Free()
if len(timestamp) >= 18 {
timestamp = timestamp[0:18]
}
return timestamp
}
func getURLs(document types.Document) []string {
urls := []string{}
urlsA := getURLsA(document)
urls = append(urls, urlsA...)
urlsB := getURLsB(document)
urls = append(urls, urlsB...)
urls = set.Strings(urls)
return urls
}
func getMagnet(document types.Document) string {
xPath, xPathErr := document.Find(`//div[@class="download"]/a/@href`)
if xPathErr != nil {
return ""
}
magnet := xPath.String()
xPath.Free()
return magnet
}
func getTimestampAndURLsAndMagnet(url string) (string, []string, string, error) {
timeout := time.Duration(15 * time.Second)
client := http.Client{
Timeout: timeout,
}
response, responseError := client.Get(url)
if responseError != nil {
return "", []string{}, "", errors.New("#1")
}
defer response.Body.Close()
document, documentErr := libxml2.ParseHTMLReader(response.Body)
if documentErr != nil {
return "", []string{}, "", errors.New("#2")
}
timestamp := getTimestamp(document)
urls := getURLs(document)
magnet := getMagnet(document)
document.Free()
return timestamp, urls, magnet, nil
}
func getItems(url string) (Items, error) {
timeout := time.Duration(15 * time.Second)
client := http.Client{
Timeout: timeout,
}
response, responseError := client.Get(url)
if responseError != nil {
return Items{}, errors.New("#1")
}
defer response.Body.Close()
document, documentErr := libxml2.ParseHTMLReader(response.Body)
if documentErr != nil {
return Items{}, errors.New("#2")
}
items := Items{}
trXPath, trXPathErr := document.Find(`//table[@id="searchResult"]/tr`)
if trXPathErr != nil {
return Items{}, errors.New("#3")
}
trNodes := trXPath.NodeList()
trXPath.Free()
for _, trNode := range trNodes {
tdXPath, tdXPathErr := trNode.Find(`.//td`)
if tdXPathErr != nil {
return Items{}, errors.New("#4")
}
tdNodes := tdXPath.NodeList()
tdXPath.Free()
if len(tdNodes) != 4 {
continue
}
category := getCategory(tdNodes[0])
seeds := getSeeds(tdNodes[2])
if seeds < 100 {
continue
}
url := getURL(url, tdNodes[1])
if url == "" {
continue
}
title := getTitle(tdNodes[1])
timestamp, urls, magnet, err := getTimestampAndURLsAndMagnet(url)
if err != nil {
continue
}
items = append(
items,
Item{
Category: category,
Timestamp: timestamp,
Title: title,
URL: url,
Seeds: seeds,
URLs: urls,
Magnet: magnet,
},
)
}
document.Free()
return items, nil
}
// Query ...
func Query() {
waitGroup := &sync.WaitGroup{}
urls := settings.Container.Spiders.URLs
count := len(urls)
outgoing := make(chan string)
incoming := make(chan Items)
waitGroup.Add(1)
go consumer(waitGroup, count, outgoing, incoming)
for index := 1; index <= count; index++ {
waitGroup.Add(1)
go producer(waitGroup, outgoing, incoming)
}
for _, url := range urls {
outgoing <- url
}
waitGroup.Wait()
}
|
package main
import (
"encoding/json"
"flag"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
"text/template"
"github.com/0LuigiCode0/go-gen/tmp"
"github.com/0LuigiCode0/logger"
)
//config модель конфигураций
type config struct {
ModuleName string `json:"module_name"`
GoVersion float32 `json:"go_version"`
DBS map[string]tmp.DBType `json:"dbs"`
Handlers map[string]tmp.HandlerType `json:"handlers"`
WorkDir string `json:"work_dir"`
}
//глобальная инициализация логгера
var log = logger.InitLogger("")
var fileConfig string
func main() {
flag.StringVar(&fileConfig, "file", "", "generation setup file")
flag.Parse()
conf, err := parseConfig(fileConfig)
if err != nil {
log.Fatalf("cannot parse tmp.config: %v", err)
}
if len(conf.Handlers) == 0 {
log.Fatal("handlers si null")
}
if conf.GoVersion <= 0 {
log.Fatal("version si null")
}
if conf.ModuleName == "" {
log.Fatal("module si null")
}
if err = conf.bMain(); err != nil {
log.Fatalf("cannot create %v: %v", tmp.FileMain, err)
}
if err = conf.bServer(); err != nil {
log.Fatalf("cannot create %v: %v", tmp.FileServer, err)
}
if len(conf.DBS) > 0 {
if err = conf.bDatabase(); err != nil {
log.Fatalf("cannot create %v: %v", tmp.FileDatabase, err)
}
if err = conf.bStore(); err != nil {
log.Fatalf("cannot create %v: %v", tmp.DirStore, err)
}
}
if err = conf.bHub(); err != nil {
log.Fatalf("cannot create %v: %v", tmp.DirHub, err)
}
if err = conf.bHandlers(); err != nil {
log.Fatalf("cannot create %v: %v", tmp.DirHandlers, err)
}
if err = conf.bHelper(); err != nil {
log.Fatalf("cannot create %v: %v", tmp.DirHelper, err)
}
if err = conf.bUtils(); err != nil {
log.Fatalf("cannot create %v: %v", "utils", err)
}
}
//parseConfig парсит конфиг
func parseConfig(configName string) (*config, error) {
_, err := os.Stat(configName)
if err != nil {
return nil, fmt.Errorf("file not found: %v", configName)
}
file, err := os.Open(configName)
if err != nil {
return nil, fmt.Errorf("cannot open file : %v", err)
}
defer file.Close()
buf, err := ioutil.ReadAll(file)
if err != nil {
return nil, fmt.Errorf("read body is invalid : %v", err)
}
data := new(config)
err = json.Unmarshal(buf, data)
if err != nil {
return nil, fmt.Errorf("unmarshal is invalid : %v", err)
}
data.ModuleName = strings.TrimSpace(data.ModuleName)
data.WorkDir = strings.TrimSpace(data.WorkDir)
return data, err
}
//isOneTCP возвращает true при первом вхождении tcp, нужно для template
func (c *config) isOneTCP() bool {
for _, v := range c.Handlers {
if v == tmp.TCP {
return true
}
}
return false
}
//isOneTCP возвращает true при первом вхождении mqtt, нужно для template
func (c *config) isOneMQTT() bool {
for _, v := range c.Handlers {
if v == tmp.MQTT {
return true
}
}
return false
}
//isOneTCP возвращает true при первом вхождении websocket, нужно для template
func (c *config) isOneWS() bool {
for _, v := range c.Handlers {
if v == tmp.WS {
return true
}
}
return false
}
//isOneTCP возвращает true при первом вхождении postgres, нужно для template
func (c *config) isOnePostgres() bool {
for _, v := range c.DBS {
if v == tmp.Postgres {
return true
}
}
return false
}
//isOneTCP возвращает true при первом вхождении mongodb, нужно для template
func (c *config) isOneMongo() bool {
for _, v := range c.DBS {
if v == tmp.Mongodb {
return true
}
}
return false
}
//bMain генерирует core/cmd/main.go
func (c *config) bMain() error {
pathDir := filepath.Join(c.WorkDir, tmp.DirCore, tmp.DirCmd)
pathFile := filepath.Join(pathDir, tmp.FileMain)
os.MkdirAll(pathDir, 0777)
f, err := os.OpenFile(pathFile, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileMain, err)
}
defer f.Close()
t, err := template.New("main").Parse(tmp.MainTmp)
if err != nil {
return err
}
if err = t.Execute(f, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileMain, err)
}
return nil
}
//bServer генерирует core/server.go - отвечает за запуск всех модулей и ожидание завершения
func (c *config) bServer() error {
pathDir := filepath.Join(c.WorkDir, tmp.DirCore)
pathFile := filepath.Join(pathDir, tmp.FileServer)
os.MkdirAll(pathDir, 0777)
f, err := os.OpenFile(pathFile, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileServer, err)
}
defer f.Close()
t, err := template.New("server").Parse(tmp.ServerTmp)
if err != nil {
return err
}
if err = t.Execute(f, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileServer, err)
}
return nil
}
//bDatabase генерирует core/database/database.go - отвечает за подключение к бд и генирацию сторов
func (c *config) bDatabase() error {
pathDir := filepath.Join(c.WorkDir, tmp.DirCore, tmp.DirDatabase)
pathFile := filepath.Join(pathDir, tmp.FileDatabase)
os.MkdirAll(pathDir, 0777)
f, err := os.OpenFile(pathFile, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileDatabase, err)
}
defer f.Close()
fmap := template.FuncMap{
"title": strings.Title,
"isOnePostgres": c.isOnePostgres,
"isOneMongo": c.isOneMongo,
}
t, err := template.New("database").Funcs(fmap).Parse(tmp.DatabaseTmp)
if err != nil {
return err
}
if err = t.Execute(f, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileDatabase, err)
}
return nil
}
//bStore генерирует store/*/store.go - отвечает за CRUD с определенной бд
func (c *config) bStore() error {
pathDir := filepath.Join(c.WorkDir, tmp.DirStore)
os.MkdirAll(pathDir, 0777)
for i, v := range c.DBS {
pathDirStore := filepath.Join(pathDir, fmt.Sprintf(tmp.DirDBSStore, i))
pathFileStore := filepath.Join(pathDirStore, tmp.FileStore)
os.MkdirAll(pathDirStore, 0777)
f, err := os.OpenFile(pathFileStore, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileStore, err)
}
defer f.Close()
t, err := template.New("store").Parse(tmp.StoreTmp)
if err != nil {
return err
}
if err = t.Execute(f, []interface{}{i, v}); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileStore, err)
}
}
return nil
}
//bHub генерирует пакет hub.
//включает в себя hub/hub.go отвечающий за инициализацию всех web интерфейсов,
//хелпер с функциями используемыми в web интерфейсах hub/helper/helper.go
func (c *config) bHub() error {
pathDir := filepath.Join(c.WorkDir, tmp.DirHub)
pathDirHelper := filepath.Join(pathDir, tmp.DirHubHelper)
pathFileHub := filepath.Join(pathDir, tmp.FileHub)
pathFileHelperModel := filepath.Join(pathDirHelper, tmp.FileModel)
pathFileHelperFucntion := filepath.Join(pathDirHelper, tmp.FileFunction)
os.MkdirAll(pathDir, 0777)
os.MkdirAll(pathDirHelper, 0777)
fhub, err := os.OpenFile(pathFileHub, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileHub, err)
}
defer fhub.Close()
fmodel, err := os.OpenFile(pathFileHelperModel, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileModel, err)
}
defer fmodel.Close()
ffunc, err := os.OpenFile(pathFileHelperFucntion, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileFunction, err)
}
defer ffunc.Close()
fmap := template.FuncMap{
"title": strings.Title,
"isOneTCP": c.isOneTCP,
}
t, err := template.New("hub").Funcs(fmap).Parse(tmp.HubTmp)
if err != nil {
return err
}
if err = t.Execute(fhub, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileHub, err)
}
tmodel, err := template.New("helper").Funcs(fmap).Parse(tmp.HubHelperModelTmp)
if err != nil {
return err
}
tfunc, err := template.New("helper").Funcs(fmap).Parse(tmp.HubHelperFuncTmp)
if err != nil {
return err
}
if err = tmodel.Execute(fmodel, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileModel, err)
}
if err = tfunc.Execute(ffunc, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileFunction, err)
}
return nil
}
//bHandlers генерирует пакет web интерфейса.
//Включает в себя сам инициализатор интерфейса handlers/*/handler.go,
//middleware handlers/*/middleware.go,
//хелпер в котором описан интерфейс который избавляет от циклических зависимостей handlers/*/helper/helper.go
func (c *config) bHandlers() error {
pathDir := filepath.Join(c.WorkDir, tmp.DirHandlers)
os.MkdirAll(pathDir, 0777)
for i, v := range c.Handlers {
pathDirHandler := filepath.Join(pathDir, fmt.Sprintf(tmp.DirHandler, i))
pathDiHelper := filepath.Join(pathDirHandler, fmt.Sprintf(tmp.DirHandlerHelper, i))
pathFileHandler := filepath.Join(pathDirHandler, tmp.FileHandler)
pathFileMiddleware := filepath.Join(pathDirHandler, tmp.FileHubMiddleware)
pathFileHelperModel := filepath.Join(pathDiHelper, tmp.FileModel)
pathFileHelperFucntion := filepath.Join(pathDiHelper, tmp.FileFunction)
os.MkdirAll(pathDirHandler, 0777)
os.MkdirAll(pathDiHelper, 0777)
fhand, err := os.OpenFile(pathFileHandler, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileHandler, err)
}
defer fhand.Close()
fmidl, err := os.OpenFile(pathFileMiddleware, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileHubMiddleware, err)
}
defer fmidl.Close()
fmodel, err := os.OpenFile(pathFileHelperModel, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileModel, err)
}
defer fmodel.Close()
ffunc, err := os.OpenFile(pathFileHelperFucntion, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileFunction, err)
}
defer ffunc.Close()
var thub, tmiddl, tmodel, tfunc *template.Template
switch v {
case tmp.TCP:
thub, err = template.New("handler").Parse(tmp.HandlerTCPTmp)
if err != nil {
return err
}
tmiddl, err = template.New("middleware").Parse(tmp.MiddlewareTCPTmp)
if err != nil {
return err
}
case tmp.MQTT:
thub, err = template.New("handler").Parse(tmp.HandlerMQTTTmp)
if err != nil {
return err
}
tmiddl, err = template.New("middleware").Parse(tmp.MiddleWareMQTTTmp)
if err != nil {
return err
}
case tmp.WS:
thub, err = template.New("handler").Parse(tmp.HandlerWSTmp)
if err != nil {
return err
}
tmiddl, err = template.New("middleware").Parse(tmp.MiddleWareWSTmp)
if err != nil {
return err
}
}
tmodel, err = template.New("helper").Parse(string(tmp.HandlerHelperModelTmp))
if err != nil {
return err
}
tfunc, err = template.New("helper").Parse(string(tmp.HandlerHelperFuncTmp))
if err != nil {
return err
}
if err = thub.Execute(fhand, []interface{}{i, c.ModuleName}); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileHandler, err)
}
if err = tmiddl.Execute(fmidl, []interface{}{i, c.ModuleName}); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileHubMiddleware, err)
}
if err = tfunc.Execute(ffunc, []interface{}{i, v}); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileFunction, err)
}
if err = tmodel.Execute(fmodel, []interface{}{i, v}); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileModel, err)
}
}
return nil
}
//bHelper генерирует пакет хелпера.
//Включат в себя хранилище всех моделей и переменных используемых в проекте helper/model.go,
//хранилище полезнфх функции helper/function.go,
func (c *config) bHelper() error {
pathDir := filepath.Join(c.WorkDir, tmp.DirHelper)
pathFileFunc := filepath.Join(pathDir, tmp.FileFunction)
pathFileModel := filepath.Join(pathDir, tmp.FileModel)
os.MkdirAll(pathDir, 0777)
ff, err := os.OpenFile(pathFileFunc, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileFunction, err)
}
defer ff.Close()
fm, err := os.OpenFile(pathFileModel, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileModel, err)
}
defer fm.Close()
if _, err = ff.WriteString(tmp.HelperFuncTmp); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileFunction, err)
}
if _, err = fm.WriteString(tmp.HelperModelTmp); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileModel, err)
}
return nil
}
//bHelper генерирует главный конфиг source/configs/configServe.json,
//а также папку source/uploads для хранения загруженных файлов и go.mod go.sum
func (c *config) bUtils() error {
pathDir := filepath.Join(c.WorkDir, tmp.DirSource)
pathDirConf := filepath.Join(pathDir, tmp.DirConfigs)
pathDirUplo := filepath.Join(pathDir, tmp.DirUploads)
pathFileConf := filepath.Join(pathDirConf, tmp.FileConfigServer)
pathFileDockerfile := filepath.Join(c.WorkDir, tmp.FileDocker)
pathFileComposeLocal := filepath.Join(c.WorkDir, tmp.FileComposeLocal)
pathFileComposeBuild := filepath.Join(c.WorkDir, tmp.FileComposeBuild)
pathFileMod := filepath.Join(c.WorkDir, tmp.FileMod)
pathFileSum := filepath.Join(c.WorkDir, tmp.FileSum)
os.MkdirAll(pathDir, 0777)
os.MkdirAll(pathDirConf, 0777)
os.MkdirAll(pathDirUplo, 0777)
fc, err := os.OpenFile(pathFileConf, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileConfigServer, err)
}
defer fc.Close()
fd, err := os.OpenFile(pathFileDockerfile, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileDocker, err)
}
defer fd.Close()
fl, err := os.OpenFile(pathFileComposeLocal, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileComposeLocal, err)
}
defer fl.Close()
fb, err := os.OpenFile(pathFileComposeBuild, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileComposeBuild, err)
}
defer fb.Close()
fm, err := os.OpenFile(pathFileMod, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileMod, err)
}
defer fm.Close()
fs, err := os.OpenFile(pathFileSum, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0777)
if err != nil {
return fmt.Errorf("file %v cannot open: %v", tmp.FileSum, err)
}
defer fs.Close()
t, err := template.New("config").Parse(tmp.ConfigTmp)
if err != nil {
return err
}
if err = t.Execute(fc, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileConfigServer, err)
}
t, err = template.New("docker").Parse(tmp.DockerTmp)
if err != nil {
return err
}
if err = t.Execute(fd, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileDocker, err)
}
t, err = template.New("build").Parse(tmp.ComposeBuildTmp)
if err != nil {
return err
}
if err = t.Execute(fb, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileComposeBuild, err)
}
t, err = template.New("local").Parse(tmp.ComposeLocalTmp)
if err != nil {
return err
}
if err = t.Execute(fl, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileComposeLocal, err)
}
t, err = template.New("mod").Funcs(template.FuncMap{
"isOneTCP": c.isOneTCP,
"isOneWS": c.isOneWS,
"isOneMQTT": c.isOneMQTT,
"isOnePostgres": c.isOnePostgres,
"isOneMongo": c.isOneMongo,
}).Parse(tmp.ModTmp)
if err != nil {
return err
}
if err = t.Execute(fm, c); err != nil {
return fmt.Errorf("file %v cannot write: %v", tmp.FileMod, err)
}
return nil
}
|
package handlers
import (
"encoding/json"
"time"
rest "github.com/danteay/ginrest"
"github.com/danteay/lanago/api/models"
"github.com/danteay/lanago/api/config"
"github.com/gin-gonic/gin"
)
// addBasketItemRequest is the request data of the endpoint
type addBasketItemRequest struct {
Code string `json:"code,required"`
}
// AddBasketItem is the action handler to add a new Product to an specific
// basket. If the basket is not found it fails, and if found, the product
// will be added asynchronously
func AddBasketItem(context *config.ServiceClients) func(c *gin.Context) {
return func(c *gin.Context) {
u := c.Request.RequestURI
r := rest.New(u, "").SetGin(c)
id := c.Param("basketId")
data, err := context.Redis.Get(id).Result()
if err != nil {
context.Logger.Error("lanago.post.AddBasketItem", err.Error())
addBasketItemErrorResponse(r, err, 500)
return
}
var req addBasketItemRequest
err = c.BindJSON(&req)
if err != nil {
context.Logger.Error("lanago.post.AddBasketItem", err.Error())
addBasketItemErrorResponse(r, err, 500)
return
}
var basket models.Basket
err = json.Unmarshal([]byte(data), &basket)
if err != nil {
context.Logger.Error(err.Error())
return
}
finded := false
for i, item := range basket.Items {
if item.Code == req.Code {
item.Qty++
basket.Items[i] = item
finded = true
break
}
}
var aux *models.Product
if !finded {
aux, err = context.ProductsService.FindProduct(req.Code)
if err != nil {
context.Logger.Error(err.Error())
addBasketItemErrorResponse(r, err, 422)
return
}
aux.Qty = 1
basket.Items = append(basket.Items, *aux)
}
go saveBasket(&basket, context)
r.Res(202, rest.Payload{
"status": "success",
"object": "lanago.post.AddBasketItem",
}, "action performed")
return
}
}
// addBasketItemErrorResponse is a wrapper for a general error response inside
// the main handler AddBasketItem
func addBasketItemErrorResponse(r *rest.IO, err error, code int) {
r.Res(code, rest.Payload{
"status": "error",
"object": "lanago.post.AddBasketItem",
}, err.Error())
}
// SaveBasket storage the computed information into Redis
func saveBasket(b *models.Basket, c *config.ServiceClients) {
j, err := json.Marshal(b)
if err != nil {
c.Logger.Error(err.Error())
return
}
err = c.Redis.Set(b.ID, string(j), time.Hour).Err()
if err != nil {
c.Logger.Error(err.Error())
return
}
}
|
package processAvaatechSpe
import (
spereader "readAvaatechSpe"
)
type Spectrum struct {
SPE *spereader.SPE `json:"SPE"`
MaxChannel int `json:"-"`
Signal []float64 `json:"-"`
Peaks []*Peak `json:"-"`
Lines map[string]*Peak `json:"Lines"`
Gain float64 `json:"-"`
Offset float64 `json:"-"`
R2 float64 `json:"-"`
}
type Peak struct {
Channel float64 `json:"Channel"`
Height float64 `json:"Height"`
Total float64 `json:"Total"`
}
|
package game
import (
"github.com/tanema/amore/gfx"
"github.com/tanema/amore/keyboard"
)
const (
playerAcc = 200
playerMaxSpeed = 400
playerRotationSpeed = 6
playerFireRate = 0.40
playerJetSize = 25
playerJetWidth = 0.15
)
type Player struct {
*Sprite
lastFire float32
isAccelerating bool
}
func newPlayer() *Player {
new_player := &Player{}
new_player.Sprite = NewSprite(new_player, "ship", screenWidth/2, screenHeight/2, 1,
[]float32{
-5, 4,
0, -12,
5, 4,
-5, 4,
}, true)
return new_player
}
func (player *Player) Update(dt float32) {
player.isAccelerating = false
if keyboard.IsDown(keyboard.KeyLeft) {
player.vrot = -playerRotationSpeed
} else if keyboard.IsDown(keyboard.KeyRight) {
player.vrot = playerRotationSpeed
} else {
player.vrot = 0
}
if keyboard.IsDown(keyboard.KeyUp) {
player.isAccelerating = true
player.ay = -(playerAcc * cos(player.rot))
player.ax = playerAcc * sin(player.rot)
} else {
player.ax = 0
player.ay = 0
}
player.lastFire += dt
if keyboard.IsDown(keyboard.KeySpace) && player.lastFire > playerFireRate {
addObject(newBullet(player.x, player.y, player.rot))
lazer.Play()
player.lastFire = 0
}
if collisions := player.UpdateMovement(dt); len(collisions) > 0 {
for _, c := range collisions {
if c.Name == "asteroid" {
player.Destroy(false)
}
}
}
// limit the ship's speed
if sqrt(player.vx*player.vx+player.vy*player.vy) > playerMaxSpeed {
player.vx *= 0.95
player.vy *= 0.95
}
}
func (player *Player) Draw() {
player.Sprite.Draw()
if player.isAccelerating {
points := player.Sprite.body.GetPoints()
gfx.PolyLine([]float32{
points[0] + ((points[4] - points[0]) * playerJetWidth),
points[1] + ((points[5] - points[1]) * playerJetWidth),
points[2] + (-sin(player.rot) * playerJetSize),
points[3] + (cos(player.rot) * playerJetSize),
points[4] + ((points[0] - points[4]) * playerJetWidth),
points[5] + ((points[1] - points[5]) * playerJetWidth),
})
}
}
func (player *Player) Destroy(force bool) {
removeObject(player)
player.Sprite.Destroy()
if !force {
bomb.Play()
gameOver = true
newExplosion(player.Sprite)
}
}
|
package integration_test
import (
"os"
"path/filepath"
"github.com/cloudfoundry/libbuildpack/cutlass"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("deploy a basic auth app", func() {
var app *cutlass.App
AfterEach(func() {
if app != nil {
app.Destroy()
}
app = nil
})
It("the app uses Staticfile.auth", func() {
app = cutlass.New(Fixtures("basic_auth"))
PushAppAndConfirm(app)
By("uses the provided credentials for authorization", func() {
body, _, err := app.Get("/", map[string]string{"user": "bob", "password": "bob"})
Expect(err).To(BeNil())
Expect(body).To(ContainSubstring("This site is protected by basic auth. User: <code>bob</code>; Password: <code>bob</code>."))
body, _, err = app.Get("/", map[string]string{})
Expect(err).To(BeNil())
Expect(body).To(ContainSubstring("401 Authorization Required"))
body, _, err = app.Get("/", map[string]string{"user": "bob", "password": "bob1"})
Expect(err).To(BeNil())
Expect(body).To(ContainSubstring("401 Authorization Required"))
})
By("does not write the contents of .htpasswd to the logs", func() {
Expect(app.Stdout.String()).ToNot(ContainSubstring("bob:$"))
Expect(app.Stdout.String()).ToNot(ContainSubstring("dave:$"))
})
By("logs the source of authentication credentials", func() {
Expect(app.Stdout.String()).To(ContainSubstring("-----> Enabling basic authentication using Staticfile.auth"))
})
})
Context("and is missing Staticfile", func() {
var appDir string
BeforeEach(func() {
var err error
appDir, err = cutlass.CopyFixture(Fixtures("basic_auth"))
Expect(err).To(BeNil())
Expect(os.Remove(filepath.Join(appDir, "Staticfile"))).To(Succeed())
app = cutlass.New(appDir)
app.Buildpacks = []string{"staticfile_buildpack"}
PushAppAndConfirm(app)
})
AfterEach(func() {
if appDir != "" {
os.RemoveAll(appDir)
}
appDir = ""
})
It("uses the provided credentials for authorization", func() {
body, _, err := app.Get("/", map[string]string{"user": "bob", "password": "bob"})
Expect(err).To(BeNil())
Expect(body).To(ContainSubstring("This site is protected by basic auth. User: <code>bob</code>; Password: <code>bob</code>."))
body, _, err = app.Get("/", map[string]string{})
Expect(err).To(BeNil())
Expect(body).To(ContainSubstring("401 Authorization Required"))
body, _, err = app.Get("/", map[string]string{"user": "bob", "password": "bob1"})
Expect(err).To(BeNil())
Expect(body).To(ContainSubstring("401 Authorization Required"))
})
})
})
|
package main
import "fmt"
func main() {
// Returning a string
s1 := foo()
fmt.Println("foo:", s1)
// Returning a func
x := bar()
fmt.Printf("bar type: %T\n", x)
fmt.Println("bar:", x())
}
func foo() string {
return "Hello world"
}
// func() int is the type that will be returned
// in the return statement, it is the anonymous function of type func() int that is being returned
func bar() func() int {
return func() int {
return 451
}
}
|
package main
import (
"fmt"
"os"
)
func main() {
Alice := "Alice"
Borys := "Borys"
n := readInt32()
a := readInt32()
b := readInt32()
if n <= 2 {
fmt.Println(Borys)
os.Exit(0)
}
if absInt32(a, b)%2 == 0 {
fmt.Println(Alice)
} else {
fmt.Println(Borys)
}
}
func readInt32() int32 {
var a int32
fmt.Scan(&a)
return a
}
func absInt32(a, b int32) int32 {
ret := a - b
if ret >= 0 {
return ret
}
return ret * -1
}
|
package tls
import (
"bytes"
"fmt"
"net"
"testing"
)
func TestHTTPS(t *testing.T) {
c, err := net.Dial("tcp", "www.cloudflare.com:443")
if err != nil {
t.Fatal("connect failed", err)
}
tlsConn := &TLS13Conn{Conn: c}
tlsConn.Handshake()
tlsConn.Write([]byte("GET / HTTP/1.1\r\nHost: www.cloudflare.com\r\n\r\n"))
resp := tlsConn.Read()
fmt.Printf("%s\n", resp)
if !bytes.HasPrefix(resp, []byte("HTTP/1.1 200 OK")) {
t.FailNow()
}
}
|
package mysqldb
import (
"context"
"os"
"path/filepath"
"strconv"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
// UserTestSuite 是 User 的 testSuite
type UserTestSuite struct {
suite.Suite
db *DbClient
}
// SetupSuite 准备设置 Test Suite 执行
func (suite *UserTestSuite) SetupSuite() {
envFilepath := filepath.Join("testdata", "local.svc-jinmuid.env")
suite.db, _ = newTestingDbClientFromEnvFile(envFilepath)
}
// FindUserByPhone 通过电话找到用户
func (suite *UserTestSuite) TestFindUserByPhone() {
t := suite.T()
phone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
ctx := context.Background()
username, err := suite.db.GetDB(ctx).FindUserByPhone(ctx, phone, nationCode)
assert.NoError(t, err)
assert.NotNil(t, username)
}
// FindUserByUsername 通过用户名找到base64密码
func (suite *UserTestSuite) TestFindUserByUsername() {
t := suite.T()
ctx := context.Background()
_, err := suite.db.GetDB(ctx).FindUserByUsername(ctx, os.Getenv("X_TEST_USERNAME"))
assert.NoError(t, err)
}
// SetLanguageByUserID 通过userID设置Language
func (suite *UserTestSuite) TestSetLanguageByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
err := suite.db.GetDB(ctx).SetLanguageByUserID(ctx, int32(userID), os.Getenv("X_TEST_LANGUAGE"))
assert.NoError(t, err)
}
// FindLanguageByUserID 通过userID找到Language
func (suite *UserTestSuite) TestFindLanguageByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
_, err := suite.db.GetDB(ctx).FindLanguageByUserID(ctx, int32(userID))
assert.NoError(t, err)
}
// ExistUserByUserID 查看 user 能否存在
func (suite *UserTestSuite) TestExistUserByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
_, err := suite.db.GetDB(ctx).ExistUserByUserID(ctx, int32(userID))
assert.NoError(t, err)
}
// ExistPasswordByUserID 查看 password 能否存在
func (suite *UserTestSuite) TestExistPasswordByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
password, err := suite.db.GetDB(ctx).ExistPasswordByUserID(ctx, int32(userID))
assert.NoError(t, err)
assert.Equal(t, false, password)
}
// SetPasswordByUserID 通过userID设置密码
func (suite *UserTestSuite) TestSetPasswordByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
err := suite.db.GetDB(ctx).SetPasswordByUserID(ctx, int32(userID), os.Getenv("X_TEST_ENCRYPTEDPASSWORD"), os.Getenv("X_TEST_SEED"))
assert.NoError(t, err)
}
// FindSecureQuestionByUserID 通过userID找到密保问题和答案
func (suite *UserTestSuite) TestFindSecureQuestionByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
_, err := suite.db.GetDB(ctx).FindSecureQuestionByUserID(ctx, int32(userID))
assert.NoError(t, err)
}
// FindSecureQuestionByPhone 通过电话号码找到找到密保问题和答案
func (suite *UserTestSuite) TestFindSecureQuestionByPhone() {
t := suite.T()
phone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).FindSecureQuestionByPhone(ctx, phone, nationCode)
assert.NoError(t, err)
}
// FindSecureQuestionByUsername 通过用户名找到密保问题和答案
func (suite *UserTestSuite) TestFindSecureQuestionByUsername() {
t := suite.T()
username := os.Getenv("X_TEST_USERNAME")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).FindSecureQuestionByUsername(ctx, username)
assert.NoError(t, err)
}
// SetPasswordByPhone 根据手机号重置密码
func (suite *UserTestSuite) TestFindSetPasswordByPhone() {
t := suite.T()
phone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
encryptedPassword := os.Getenv("X_TEST_ENCRYPTEDPASSWORD")
seed := os.Getenv("X_TEST_SEED")
ctx := context.Background()
err := suite.db.GetDB(ctx).SetPasswordByPhone(ctx, phone, nationCode, encryptedPassword, seed)
assert.NoError(t, err)
}
// SetPasswordByUsername 根据用户名重置密码
func (suite *UserTestSuite) TestSetPasswordByUsername() {
t := suite.T()
username := os.Getenv("X_TEST_USERNAME")
encryptedPassword := os.Getenv("X_TEST_ENCRYPTEDPASSWORD")
seed := os.Getenv("X_TEST_SEED")
ctx := context.Background()
err := suite.db.GetDB(ctx).SetPasswordByUsername(ctx, username, encryptedPassword, seed)
assert.NoError(t, err)
}
// IsPasswordSameByPhone 根据手机号判断密码是否与之前密码相同
func (suite *UserTestSuite) TestIsPasswordSameByPhone() {
t := suite.T()
phone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
encryptedPassword := os.Getenv("X_TEST_ENCRYPTEDPASSWORD")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).IsPasswordSameByPhone(ctx, phone, nationCode, encryptedPassword)
assert.NoError(t, err)
}
// IsPasswordSameByUsername 根据用户名判断密码是否与之前密码相同
func (suite *UserTestSuite) TestIsPasswordSameByUsername() {
t := suite.T()
username := os.Getenv("X_TEST_USERNAME")
encryptedPassword := os.Getenv("X_TEST_ENCRYPTEDPASSWORD")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).IsPasswordSameByUsername(ctx, username, encryptedPassword)
assert.NoError(t, err)
}
// FindUserIDByPhone 通过电话号码找到userID
func (suite *UserTestSuite) TestFindUserIDByPhone() {
t := suite.T()
phone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
ctx := context.Background()
user, err := suite.db.GetDB(ctx).FindUserIDByPhone(ctx, phone, nationCode)
assert.NoError(t, err)
assert.Equal(t, 105546, user)
}
// FindUserIDByUsername 通过用户名找到userID
func (suite *UserTestSuite) TestFindUserIDByUsername() {
t := suite.T()
username := os.Getenv("X_TEST_USERNAME")
ctx := context.Background()
user, err := suite.db.GetDB(ctx).FindUserIDByUsername(ctx, username)
assert.NoError(t, err)
assert.Equal(t, int32(786), user)
}
// ExistUsername 用户名是否存在
func (suite *UserTestSuite) TestExistUsername() {
t := suite.T()
username := os.Getenv("X_TEST_USERNAME")
ctx := context.Background()
user, err := suite.db.GetDB(ctx).ExistUsername(ctx, username)
assert.NoError(t, err)
assert.Equal(t, true, user)
}
// ExistPhone 手机号是否已经存在
func (suite *UserTestSuite) TestExistPhone() {
t := suite.T()
phone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).ExistPhone(ctx, phone, nationCode)
assert.NoError(t, err)
}
// ExistSignInPhone 登录手机号是否已经存在
func (suite *UserTestSuite) TestExistSignInPhone() {
t := suite.T()
phone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).ExistSignInPhone(ctx, phone, nationCode)
assert.NoError(t, err)
}
// SecureEmailExists 当前用户是否已经设置了安全邮箱
func (suite *UserTestSuite) TestSecureEmailExists() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
_, err := suite.db.GetDB(ctx).SecureEmailExists(ctx, int32(userID))
assert.NoError(t, err)
}
// MatchSecureEmail 安全邮箱是否与原来邮箱一致
func (suite *UserTestSuite) TestMatchSecureEmail() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
email := os.Getenv("X_TEST_EMAIL")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).MatchSecureEmail(ctx, email, int32(userID))
assert.NoError(t, err)
}
// CreateUserByPhone 创建user通过电话
func (suite *UserTestSuite) TestCreateUserByPhone() {
t := suite.T()
now := time.Now()
user := &User{
SigninPhone: os.Getenv("X_TEST_PHONE"),
HasSetPhone: true,
RegisterSource: os.Getenv("X_TEST_REGISTER_SOURCE"),
NationCode: os.Getenv("X_TEST_NATION_CODE"),
RegisterTime: now.UTC(),
CreatedAt: now.UTC(),
UpdatedAt: now.UTC(),
}
ctx := context.Background()
_, err := suite.db.GetDB(ctx).CreateUserByPhone(ctx, user)
assert.NoError(t, err)
}
// SetSecureEmail 设置安全邮箱
func (suite *UserTestSuite) TestSetSecureEmail() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
email := os.Getenv("X_TEST_EMAIL")
ctx := context.Background()
err := suite.db.GetDB(ctx).SetSecureEmail(ctx, email, int32(userID))
assert.NoError(t, err)
}
// UnsetSecureEmail 解除设置安全邮箱
func (suite *UserTestSuite) TestUnsetSecureEmail() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
err := suite.db.GetDB(ctx).UnsetSecureEmail(ctx, int32(userID))
assert.NoError(t, err)
}
// ExistsSecureQuestion 用户是否已经设置了密保问题
func (suite *UserTestSuite) TestExistsSecureQuestion() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
_, err := suite.db.GetDB(ctx).ExistsSecureQuestion(ctx, int32(userID))
assert.NoError(t, err)
}
// SetSecureQuestion 设置密保问题
func (suite *UserTestSuite) TestSetSecureQuestion() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
secureQuestion := make([]SecureQuestion, 3)
secureQuestion[0] = SecureQuestion{
SecureQuestionKey: "1",
SecureAnswer: "1",
}
secureQuestion[1] = SecureQuestion{
SecureQuestionKey: "1",
SecureAnswer: "1",
}
secureQuestion[2] = SecureQuestion{
SecureQuestionKey: "1",
SecureAnswer: "1",
}
ctx := context.Background()
err := suite.db.GetDB(ctx).SetSecureQuestion(ctx, int32(userID), secureQuestion)
assert.NoError(t, err)
}
// SetSigninPhoneByUserID 通过userID设置登录手机号
func (suite *UserTestSuite) TestSetSigninPhoneByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
signinPhone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
ctx := context.Background()
err := suite.db.GetDB(ctx).SetSigninPhoneByUserID(ctx, int32(userID), signinPhone, nationCode)
assert.NoError(t, err)
}
// SetUserRegion 设置用户区域
func (suite *UserTestSuite) TestSetUserRegion() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
region := MainlandChina
ctx := context.Background()
err := suite.db.GetDB(ctx).SetUserRegion(ctx, int32(userID), region)
assert.NoError(t, err)
}
// GetSecureQuestionListToModifyByUserID 通过userID找到密保问题
func (suite *UserTestSuite) TestGetSecureQuestionListToModifyByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
_, err := suite.db.GetDB(ctx).GetSecureQuestionListToModifyByUserID(ctx, int32(userID))
assert.NoError(t, err)
}
// FindUserBySecureEmail 通过安全邮箱找到User
func (suite *UserTestSuite) TestFindUserBySecureEmail() {
t := suite.T()
email := os.Getenv("X_TEST_EMAIL")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).FindUserBySecureEmail(ctx, email)
assert.NoError(t, err)
}
// FindUsernameBySecureEmail 通过邮箱查找用户名
func (suite *UserTestSuite) TestFindUsernameBySecureEmail() {
t := suite.T()
email := os.Getenv("X_TEST_EMAIL")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).FindUsernameBySecureEmail(ctx, email)
assert.NoError(t, err)
}
// GetSecureQuestionsByPhone 根据手机号获取当前设置的密保问题
func (suite *UserTestSuite) TestGetSecureQuestionsByPhone() {
t := suite.T()
phone := os.Getenv("X_TEST_PHONE")
nationCode := os.Getenv("X_TEST_NATION_CODE")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).GetSecureQuestionsByPhone(ctx, phone, nationCode)
assert.NoError(t, err)
}
// GetSecureQuestionsByUsername 根据用户名获取当前设置的密保问题
func (suite *UserTestSuite) TestGetSecureQuestionsByUsername() {
t := suite.T()
username := os.Getenv("X_TEST_USERNAME")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).GetSecureQuestionsByUsername(ctx, username)
assert.NoError(t, err)
}
// FindUserByEmail 通过邮箱找到User
func (suite *UserTestSuite) TestFindUserByEmail() {
t := suite.T()
email := os.Getenv("X_TEST_EMAIL")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).FindUserByEmail(ctx, email)
assert.NoError(t, err)
}
// SetSecureEmailByUserID 根据userID重置安全邮箱
func (suite *UserTestSuite) TestSetSecureEmailByUserID() {
t := suite.T()
email := os.Getenv("X_TEST_EMAIL")
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
err := suite.db.GetDB(ctx).SetSecureEmailByUserID(ctx, int32(userID), email)
assert.NoError(t, err)
}
// ModifyHasSetUserProfileStatus 修改HasSetUserProfile状态
func (suite *UserTestSuite) TestModifyHasSetUserProfileStatus() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
err := suite.db.GetDB(ctx).ModifyHasSetUserProfileStatus(ctx, int32(userID))
assert.NoError(t, err)
}
// HasSecureEmailSet 当前安全邮箱是否被任何人设置
func (suite *UserTestSuite) TestHasSecureEmailSets() {
t := suite.T()
email := os.Getenv("X_TEST_EMAIL")
ctx := context.Background()
_, err := suite.db.GetDB(ctx).HasSecureEmailSet(ctx, email)
assert.NoError(t, err)
}
// FindUserByUserID 获取用户和用户档案信息
func (suite *UserTestSuite) TestFindUserByUserID() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
ctx := context.Background()
user, err := suite.db.GetDB(ctx).FindUserByUserID(ctx, int32(userID))
assert.NoError(t, err)
assert.Equal(t, "13221058643", user.SigninPhone)
}
// ModifyUser 修改用户信息
func (suite *UserTestSuite) TestModifyUser() {
t := suite.T()
userID, _ := strconv.Atoi(os.Getenv("X_TEST_USER_ID"))
user := &User{
UserID: int32(userID),
Remark: os.Getenv("X_TEST_REMARK"),
CustomizedCode: os.Getenv("X_TEST_CUSTOMIZED_CODE"),
HasSetUserProfile: true,
UpdatedAt: time.Now().UTC(),
}
ctx := context.Background()
err := suite.db.GetDB(ctx).ModifyUser(ctx, user)
assert.NoError(t, err)
}
func TestUserTestSuite(t *testing.T) {
suite.Run(t, new(UserTestSuite))
}
|
package transdsl
type Fragment interface {
Exec(transInfo *TransInfo) error
Rollback(transInfo *TransInfo)
}
func forEachFragments(fragments []Fragment, transInfo *TransInfo) (int, error) {
for i, fragment := range fragments {
err := fragment.Exec(transInfo)
if err != nil {
if isEqual(err, ErrSucc) {
return 0, nil
}
return i, err
}
}
return 0, nil
}
func backEachFragments(fragments []Fragment, transInfo *TransInfo, index int) {
if index <= 0 {
return
}
index--
for ; index >= 0; index-- {
fragments[index].Rollback(transInfo)
}
}
|
package main
/*
delta is a command-line diff utility.
Usage:
`delta <file1> <file2> <merged>`
file1 is set to the name of the temporary file containing the contents of the diff pre-image.
file2 is set to the name of the temporary file containing the contents of the diff post-image.
merged is the name of the file which is being compared.
*/
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"html/template"
"io/ioutil"
"os"
"strings"
"time"
"github.com/octavore/delta/lib"
"github.com/octavore/delta/lib/formatter"
"github.com/pkg/browser"
)
// constants for command line options
const (
OutputOptionCLI = "cli"
OutputOptionBrowser = "browser"
OutputOptionGist = "gist"
FormatOptionHTML = "html"
FormatOptionText = "text"
FormatOptionDefault = "default"
compareHTML = `<!DOCTYPE html>
<html>
<head>
<style>{{ .CSS }}</style>
</head>
<body>
<div id="app">
<div id="diff">
<div class="diff-contents">
{{ .content }}
</div>
</div>
</div>
</body>
</html>`
)
var (
// commands
install = flag.Bool("install", false, "Install to gitconfig.")
uninstall = flag.Bool("uninstall", false, "Remove from gitconfig.")
version = flag.Bool("version", false, "Display delta version.")
// diff settings
output = flag.String("output", "cli", "Where to send the output. Valid values: browser (default), cli, gist.")
format = flag.String("format", "default", `Format of the output. `)
)
func main() {
flag.CommandLine.Usage = printHelp
flag.Parse()
if *install || *uninstall || *version {
switch {
case *version:
printVersion()
case *install:
installGit()
case *uninstall:
uninstallGit()
}
return
}
if flag.NArg() < 2 {
printVersion()
printHelp()
return
}
pathFrom, pathTo := flag.Arg(0), flag.Arg(1)
pathBase := pathTo
if flag.NArg() > 2 {
pathBase = flag.Arg(2)
}
runDiff(pathFrom, pathTo, pathBase)
}
func printHelp() {
fmt.Println()
fmt.Println("USAGE:")
fmt.Println()
fmt.Println("delta OPTION_COMMAND")
fmt.Printf("%-20s %s\n", " --install", "Install delta to gitconfig.")
fmt.Printf("%-20s %s\n", " --uninstall", "Remove delta from gitconfig.")
fmt.Printf("%-20s %s\n", " --version", "Display delta version.")
// diff settings
fmt.Println("\ndelta [OPTIONS] FILE1 FILE2")
fmt.Printf("%-20s %s\n", " --output", "Where to send the output. Valid values: browser, cli (default), gist.")
fmt.Printf("%-20s %s\n", " --format", `Valid values: default (text for cli, html otherwise), html, text.`)
fmt.Println()
}
func printVersion() {
fmt.Println("delta", Version)
}
func runDiff(pathFrom, pathTo, pathBase string) {
config, err := loadConfig()
if err != nil {
os.Stderr.WriteString("warning: error parsing .deltarc file")
}
d, err := diff(pathFrom, pathTo)
if err != nil {
os.Stderr.WriteString(err.Error())
return
}
if err != nil {
os.Stderr.WriteString(err.Error())
return
}
if *format == FormatOptionDefault {
switch *output {
case OutputOptionBrowser, OutputOptionGist:
*format = FormatOptionHTML
case OutputOptionCLI:
*format = FormatOptionText
}
}
switch *format {
case FormatOptionHTML:
page, err := html(d, pathFrom, pathTo, pathBase, config)
if err != nil {
os.Stderr.WriteString(err.Error())
return
}
switch *output {
case OutputOptionCLI:
page.WriteTo(os.Stdout)
case OutputOptionGist:
uploadGist(page.Bytes())
case OutputOptionBrowser:
browser.OpenReader(page)
}
case FormatOptionText:
switch *output {
case OutputOptionCLI:
fmt.Println(formatter.ColoredText(d))
case OutputOptionGist:
uploadGist([]byte(formatter.Text(d)))
case OutputOptionBrowser:
browser.OpenReader(bytes.NewBufferString(formatter.Text(d)))
}
}
}
// openDiffs diffs the given files and writes the result to a tempfile,
// then opens it in the gui.
func html(d *delta.DiffSolution, pathFrom, pathTo, pathBase string, config Config) (*bytes.Buffer, error) {
change := changeModified
if pathTo == "/dev/null" {
change = changeDeleted
} else if pathFrom == "/dev/null" {
change = changeAdded
}
// normalize paths so we don't have tmp on the path
tmpFrom := strings.HasPrefix(pathFrom, os.TempDir())
tmpTo := strings.HasPrefix(pathTo, os.TempDir())
if tmpFrom && !tmpTo {
pathFrom = pathTo
} else if !tmpFrom && tmpTo {
pathTo = pathFrom
}
wd, _ := os.Getwd()
html := formatter.HTML(d)
fmt.Println("html ", html)
m := &Metadata{
From: pathFrom,
To: pathTo,
Merged: pathBase,
Dir: wd,
Change: change,
Hash: md5sum(html),
DirHash: md5sum(wd),
Timestamp: time.Now().UnixNano() / 1000000, // convert to millis
}
meta, _ := json.Marshal(m)
cfg, _ := json.Marshal(config)
tmpl := template.Must(template.New("compare").Parse(compareHTML))
buf := &bytes.Buffer{}
err := tmpl.Execute(buf, map[string]interface{}{
"metadata": template.JS(string(meta)),
"config": template.JS(cfg),
"content": template.HTML(html),
"CSS": template.CSS(getAsset("app.css")),
})
return buf, err
}
// diff reads in files in pathFrom and pathTo, and returns a diff
func diff(pathFrom, pathTo string) (*delta.DiffSolution, error) {
from, err := ioutil.ReadFile(pathFrom)
if err != nil {
return nil, fmt.Errorf("error reading %q: %v", pathFrom, err)
}
to, err := ioutil.ReadFile(pathTo)
if err != nil {
return nil, fmt.Errorf("error reading %q: %v", pathTo, err)
}
return delta.HistogramDiff(string(from), string(to)), nil
}
|
package app
import (
"bytes"
"compress/gzip"
"context"
"errors"
"io"
"io/ioutil"
"net/http"
"net/url"
"sync"
"time"
"github.com/Sirupsen/logrus"
"github.com/honeycombio/honeycomb-opentracing-proxy/sinks"
"github.com/honeycombio/honeycomb-opentracing-proxy/types"
v1 "github.com/honeycombio/honeycomb-opentracing-proxy/types/v1"
v2 "github.com/honeycombio/honeycomb-opentracing-proxy/types/v2"
)
const V1Endpoint string = "/api/v1/spans"
const V2Endpoint string = "/api/v2/spans"
type App struct {
Port string
server *http.Server
Sink sinks.Sink
Mirror *Mirror
}
// handleSpansV1 handles the /api/v1/spans POST endpoint. It decodes the request
// body and normalizes it to a slice of types.Span instances. The Sink
// handles that slice. The Mirror, if configured, takes the request body
// verbatim and sends it to another host.
func (a *App) handleSpansV1(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
data, err := ioutil.ReadAll(r.Body)
if err != nil {
logrus.WithError(err).Info("Error reading request body")
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("error reading request"))
}
contentType := r.Header.Get("Content-Type")
if a.Mirror != nil {
if err := a.Mirror.Send(payload{Endpoint: V1Endpoint, ContentType: contentType, Body: data}); err != nil {
logrus.WithError(err).Info("Error mirroring data")
}
}
var spans []*types.Span
switch contentType {
case "application/json":
spans, err = v1.DecodeJSON(bytes.NewReader(data))
case "application/x-thrift":
spans, err = v1.DecodeThrift(bytes.NewReader(data))
default:
logrus.WithField("contentType", contentType).Info("unknown content type")
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("unknown content type"))
return
}
if err != nil {
logrus.WithError(err).WithField("type", contentType).Info("error unmarshaling spans")
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("error unmarshaling span data"))
return
}
if err := a.Sink.Send(spans); err != nil {
logrus.WithError(err).Info("error forwarding spans")
}
w.WriteHeader(http.StatusAccepted)
}
// handleSpansV2 handles the /api/v2/spans POST endpoint. It decodes the request
// body and normalizes it to a slice of types.Span instances. The Sink
// handles that slice. The Mirror, if configured, takes the request body
// verbatim and sends it to another host.
func (a *App) handleSpansV2(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
data, err := ioutil.ReadAll(r.Body)
if err != nil {
logrus.WithError(err).Info("Error reading request body")
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("error reading request"))
}
contentType := r.Header.Get("Content-Type")
if a.Mirror != nil {
if err := a.Mirror.Send(payload{Endpoint: V2Endpoint, ContentType: contentType, Body: data}); err != nil {
logrus.WithError(err).Info("Error mirroring data")
}
}
var spans []*types.Span
switch contentType {
case "application/json":
spans, err = v2.DecodeJSON(bytes.NewReader(data))
default:
logrus.WithField("contentType", contentType).Info("unknown content type")
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("unknown content type"))
return
}
if err != nil {
logrus.WithError(err).WithField("type", contentType).Info("error unmarshaling spans")
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("error unmarshaling span data"))
return
}
if err := a.Sink.Send(spans); err != nil {
logrus.WithError(err).Info("error forwarding spans")
}
w.WriteHeader(http.StatusAccepted)
}
// ungzipWrap wraps a handleFunc and transparently ungzips the body of the
// request if it is gzipped
func ungzipWrap(hf func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
var newBody io.ReadCloser
isGzipped := r.Header.Get("Content-Encoding")
if isGzipped == "gzip" {
buf := bytes.Buffer{}
if _, err := io.Copy(&buf, r.Body); err != nil {
logrus.WithError(err).Info("error allocating buffer for ungzipping")
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("error allocating buffer for ungzipping"))
return
}
var err error
newBody, err = gzip.NewReader(&buf)
if err != nil {
logrus.WithError(err).Info("error ungzipping span data")
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("error ungzipping span data"))
return
}
r.Body = newBody
}
hf(w, r)
}
}
func (a *App) Start() error {
mux := http.NewServeMux()
mux.HandleFunc(V1Endpoint, ungzipWrap(a.handleSpansV1))
mux.HandleFunc(V2Endpoint, ungzipWrap(a.handleSpansV2))
a.server = &http.Server{
Addr: a.Port,
Handler: mux,
}
go a.server.ListenAndServe()
logrus.WithField("port", a.Port).Info("Listening")
return nil
}
func (a *App) Stop() error {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
return a.server.Shutdown(ctx)
}
type payload struct {
Endpoint string
ContentType string
Body []byte
}
type Mirror struct {
DownstreamURL *url.URL
BufSize int
MaxConcurrency int
payloads chan payload
stopped bool
wg sync.WaitGroup
}
func (m *Mirror) Start() error {
if m.MaxConcurrency == 0 {
m.MaxConcurrency = 100
}
if m.BufSize == 0 {
m.BufSize = 4096
}
m.payloads = make(chan payload, m.BufSize)
for i := 0; i < m.MaxConcurrency; i++ {
m.wg.Add(1)
go m.runWorker()
}
return nil
}
func (m *Mirror) Stop() error {
m.stopped = true
if m.payloads == nil {
return nil
}
close(m.payloads)
m.wg.Wait()
return nil
}
func (m *Mirror) runWorker() {
for p := range m.payloads {
downstreamURL := m.DownstreamURL
downstreamURL.Path = p.Endpoint
r, err := http.NewRequest("POST", downstreamURL.String(), bytes.NewReader(p.Body))
r.Header.Set("Content-Type", p.ContentType)
if err != nil {
logrus.WithError(err).Info("Error building downstream request")
return
}
client := &http.Client{}
resp, err := client.Do(r)
if err != nil {
logrus.WithError(err).Info("Error sending payload downstream")
continue
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusAccepted {
responseBody, _ := ioutil.ReadAll(&io.LimitedReader{R: resp.Body, N: 1024})
logrus.WithField("status", resp.Status).
WithField("response", string(responseBody)).
Info("Error response sending payload downstream")
}
}
m.wg.Done()
}
func (m *Mirror) Send(p payload) error {
if m.stopped {
return errors.New("sink stopped")
}
select {
case m.payloads <- p:
return nil
default:
return errors.New("sink full")
}
}
|
package src
import (
"github.com/llir/llvm/ir"
"io/ioutil"
"os/exec"
)
const (
// emit an exe
AHEAD_COMPILE uint8 = 0x0
// JIT compile using LLVM execution engine (used for compile time execution)
JIT_COMPILE uint8 = 0x1
SUCCESS_COMP uint8 = 0x0
SUCCESS_JIT uint8 = 0x1
FAIL_COMP uint8 = 0x2
TAV_OUT = "tavout/"
)
func BuildExe(filename string, module *ir.Module) uint8 {
ioutil.WriteFile(TAV_OUT+filename+".ll", []byte(module.String()), 0644)
c := exec.Command("llc", TAV_OUT+filename+".ll")
err := c.Run()
Log("llc err",err)
c = exec.Command("gcc", "-c", TAV_OUT+filename+".s", "-o", TAV_OUT+filename+".o")
err = c.Run()
Log("gcc o err",err)
c = exec.Command("gcc", TAV_OUT+filename+".o", "-o", TAV_OUT+filename+".exe")
err = c.Run()
Log("gcc exe err",err)
return SUCCESS_COMP
}
|
package models
import "time"
type SysQuartzLog struct {
ID int `gorm:"primary_key" json:"id"` //ID
BeanName string `json:"bean_name"` //bean对象名称
CronExpression string `json:"cron_expression"` //cron表达式
ExceptionDetail string `json:"exception_detail"` //异常详情
IsSuccess []byte `json:"is_success"` //状态（是否成功）1成功，0失败(默认)
JobName string `json:"job_name"` //任务名称
MethodName string `json:"method_name"` //执行方法
Params string `json:"params"` //方法参数
Time int `json:"time"` //执行时间(ms)
CreateTime time.Time `json:"create_time"` //创建时间
UpdateTime time.Time `json:"update_time"` //更新时间
CreateBy int `json:"create_by"` //创建者
UpdateBy int `json:"update_by"` //更新者
IsDeleted []byte `json:"is_deleted"` //逻辑删除：0启用（默认）、1删除
}
|
package main
import (
_ "fresh/Fresh-order/FreshOrder/routers"
"github.com/astaxie/beego"
_"fresh/Fresh-order/FreshOrder/models"
)
func main() {
beego.Run()
}
|
package tokensource
import "os"
var debug bool
func init() {
debug = os.Getenv("DEBUG") != ""
}
|
package cmd
import (
"github.com/devspace-cloud/devspace/cmd/flags"
"github.com/devspace-cloud/devspace/pkg/devspace/config/generated"
"github.com/devspace-cloud/devspace/pkg/devspace/services/targetselector"
"github.com/devspace-cloud/devspace/pkg/util/factory"
"github.com/pkg/errors"
"github.com/spf13/cobra"
)
// AttachCmd is a struct that defines a command call for "enter"
type AttachCmd struct {
*flags.GlobalFlags
LabelSelector string
Image string
Container string
Pod string
Pick bool
}
// NewAttachCmd creates a new attach command
func NewAttachCmd(f factory.Factory, globalFlags *flags.GlobalFlags) *cobra.Command {
cmd := &AttachCmd{GlobalFlags: globalFlags}
attachCmd := &cobra.Command{
Use: "attach",
Short: "Attaches to a container",
Long: `
#######################################################
################# devspace attach #####################
#######################################################
Attaches to a running container
devspace attach
devspace attach --pick # Select pod to enter
devspace attach -c my-container
devspace attach -n my-namespace
#######################################################`,
RunE: func(cobraCmd *cobra.Command, args []string) error {
return cmd.Run(f, cobraCmd, args)
},
}
attachCmd.Flags().StringVarP(&cmd.Container, "container", "c", "", "Container name within pod where to execute command")
attachCmd.Flags().StringVar(&cmd.Pod, "pod", "", "Pod to open a shell to")
attachCmd.Flags().StringVar(&cmd.Image, "image", "", "Image is the config name of an image to select in the devspace config (e.g. 'default'), it is NOT a docker image like myuser/myimage")
attachCmd.Flags().StringVarP(&cmd.LabelSelector, "label-selector", "l", "", "Comma separated key=value selector list (e.g. release=test)")
attachCmd.Flags().BoolVar(&cmd.Pick, "pick", false, "Select a pod")
return attachCmd
}
// Run executes the command logic
func (cmd *AttachCmd) Run(f factory.Factory, cobraCmd *cobra.Command, args []string) error {
// Set config root
log := f.GetLog()
configLoader := f.NewConfigLoader(cmd.ToConfigOptions(), log)
configExists, err := configLoader.SetDevSpaceRoot()
if err != nil {
return err
}
// Load generated config if possible
var generatedConfig *generated.Config
if configExists {
generatedConfig, err = configLoader.Generated()
if err != nil {
return err
}
}
// Use last context if specified
err = cmd.UseLastContext(generatedConfig, log)
if err != nil {
return err
}
// Get kubectl client
client, err := f.NewKubeClientFromContext(cmd.KubeContext, cmd.Namespace, cmd.SwitchContext)
if err != nil {
return errors.Wrap(err, "new kube client")
}
err = client.PrintWarning(generatedConfig, cmd.NoWarn, false, log)
if err != nil {
return err
}
// Signal that we are working on the space if there is any
err = f.NewSpaceResumer(client, log).ResumeSpace(true)
if err != nil {
return err
}
// Build params
selectorParameter := &targetselector.SelectorParameter{
CmdParameter: targetselector.CmdParameter{
ContainerName: cmd.Container,
LabelSelector: cmd.LabelSelector,
Namespace: cmd.Namespace,
PodName: cmd.Pod,
},
}
if cmd.Pick != false {
selectorParameter.CmdParameter.Pick = &cmd.Pick
}
// get imageselector if specified
imageSelector, err := getImageSelector(configLoader, cmd.Image)
if err != nil {
return err
}
servicesClient := f.NewServicesClient(nil, nil, client, selectorParameter, log)
// Start attach
return servicesClient.StartAttach(imageSelector, make(chan error))
}
|
// Copyright 2021 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
package charset_test
import (
"fmt"
"testing"
"unicode/utf8"
"github.com/pingcap/tidb/parser/charset"
"github.com/stretchr/testify/require"
"golang.org/x/text/transform"
)
func TestEncoding(t *testing.T) {
enc := charset.FindEncoding(charset.CharsetGBK)
require.Equal(t, charset.CharsetGBK, enc.Name())
txt := []byte("一二三四")
e, _ := charset.Lookup("gbk")
gbkEncodedTxt, _, err := transform.Bytes(e.NewEncoder(), txt)
require.NoError(t, err)
result, err := enc.Transform(nil, gbkEncodedTxt, charset.OpDecode)
require.NoError(t, err)
require.Equal(t, txt, result)
gbkEncodedTxt2, err := enc.Transform(nil, txt, charset.OpEncode)
require.NoError(t, err)
require.Equal(t, gbkEncodedTxt2, gbkEncodedTxt)
result, err = enc.Transform(nil, gbkEncodedTxt2, charset.OpDecode)
require.NoError(t, err)
require.Equal(t, txt, result)
GBKCases := []struct {
utf8Str string
result string
isValid bool
}{
{"一二三", "涓?簩涓?", false}, // MySQL reports '涓?簩涓'.
{"一二三123", "涓?簩涓?23", false},
{"测试", "娴嬭瘯", true},
{"案1案2", "妗?妗?", false},
{"焊䏷菡釬", "鐒婁彿鑿￠嚞", true},
{"鞍杏以伊位依", "闉嶆潖浠ヤ紛浣嶄緷", true},
{"移維緯胃萎衣謂違", "绉荤董绶?儍钀庤。璎傞仌", false},
{"仆仂仗仞仭仟价伉佚估", "浠嗕粋浠椾粸浠?粺浠蜂級浣氫及", false},
{"佝佗佇佶侈侏侘佻佩佰侑佯", "浣濅綏浣囦蕉渚堜緩渚樹交浣╀桨渚戜蒋", true},
{"\x80", "?", false},
{"\x80a", "?", false},
{"\x80aa", "?a", false},
{"aa\x80ab", "aa?b", false},
{"a你好\x80a测试", "a浣犲ソ?娴嬭瘯", false},
{"aa\x80", "aa?", false},
}
for _, tc := range GBKCases {
cmt := fmt.Sprintf("%v", tc)
result, err := enc.Transform(nil, []byte(tc.utf8Str), charset.OpDecodeReplace)
if tc.isValid {
require.NoError(t, err, cmt)
} else {
require.Error(t, err, cmt)
}
require.Equal(t, tc.result, string(result), cmt)
}
utf8Cases := []struct {
utf8Str string
result string
isValid bool
}{
{"一二三", "һ\xb6\xfe\xc8\xfd", true},
{"🀁", "?", false},
{"valid_string_🀁", "valid_string_?", false},
{"€", "?", false},
{"€a", "?a", false},
{"a€aa", "a?aa", false},
{"aaa€", "aaa?", false},
}
for _, tc := range utf8Cases {
cmt := fmt.Sprintf("%v", tc)
result, err := enc.Transform(nil, []byte(tc.utf8Str), charset.OpEncodeReplace)
if tc.isValid {
require.NoError(t, err, cmt)
} else {
require.Error(t, err, cmt)
}
require.Equal(t, tc.result, string(result), cmt)
}
}
func TestEncodingValidate(t *testing.T) {
oxfffefd := string([]byte{0xff, 0xfe, 0xfd})
testCases := []struct {
chs string
str string
expected string
nSrc int
ok bool
}{
{charset.CharsetASCII, "", "", 0, true},
{charset.CharsetASCII, "qwerty", "qwerty", 6, true},
{charset.CharsetASCII, "qwÊrty", "qw?rty", 2, false},
{charset.CharsetASCII, "中文", "??", 0, false},
{charset.CharsetASCII, "中文?qwert", "???qwert", 0, false},
{charset.CharsetUTF8MB4, "", "", 0, true},
{charset.CharsetUTF8MB4, "qwerty", "qwerty", 6, true},
{charset.CharsetUTF8MB4, "qwÊrty", "qwÊrty", 7, true},
{charset.CharsetUTF8MB4, "qwÊ合法字符串", "qwÊ合法字符串", 19, true},
{charset.CharsetUTF8MB4, "😂", "😂", 4, true},
{charset.CharsetUTF8MB4, oxfffefd, "???", 0, false},
{charset.CharsetUTF8MB4, "中文" + oxfffefd, "中文???", 6, false},
{charset.CharsetUTF8MB4, string(utf8.RuneError), "�", 3, true},
{charset.CharsetUTF8, "", "", 0, true},
{charset.CharsetUTF8, "qwerty", "qwerty", 6, true},
{charset.CharsetUTF8, "qwÊrty", "qwÊrty", 7, true},
{charset.CharsetUTF8, "qwÊ合法字符串", "qwÊ合法字符串", 19, true},
{charset.CharsetUTF8, "😂", "?", 0, false},
{charset.CharsetUTF8, "valid_str😂", "valid_str?", 9, false},
{charset.CharsetUTF8, oxfffefd, "???", 0, false},
{charset.CharsetUTF8, "中文" + oxfffefd, "中文???", 6, false},
{charset.CharsetUTF8, string(utf8.RuneError), "�", 3, true},
{charset.CharsetGBK, "", "", 0, true},
{charset.CharsetGBK, "asdf", "asdf", 4, true},
{charset.CharsetGBK, "中文", "中文", 6, true},
{charset.CharsetGBK, "À", "?", 0, false},
{charset.CharsetGBK, "中文À中文", "中文?中文", 6, false},
{charset.CharsetGBK, "asdfÀ", "asdf?", 4, false},
}
for _, tc := range testCases {
msg := fmt.Sprintf("%v", tc)
enc := charset.FindEncoding(tc.chs)
if tc.chs == charset.CharsetUTF8 {
enc = charset.EncodingUTF8MB3StrictImpl
}
strBytes := []byte(tc.str)
require.Equal(t, tc.ok, enc.IsValid(strBytes), msg)
replace, _ := enc.Transform(nil, strBytes, charset.OpReplaceNoErr)
require.Equal(t, tc.expected, string(replace), msg)
}
}
|
/*
Copyright 2021 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 cli
import (
"context"
"os"
"testing"
"github.com/stretchr/testify/require"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"github.com/oam-dev/kubevela/apis/core.oam.dev/common"
"github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1"
cmdutil "github.com/oam-dev/kubevela/pkg/utils/util"
)
func TestDebugApplicationWithWorkflow(t *testing.T) {
c := initArgs()
ioStream := cmdutil.IOStreams{In: os.Stdin, Out: os.Stdout, ErrOut: os.Stderr}
ctx := context.TODO()
testCases := map[string]struct {
app *v1beta1.Application
cm *corev1.ConfigMap
step string
focus string
expectedErr string
}{
"no debug config map": {
app: &v1beta1.Application{
ObjectMeta: metav1.ObjectMeta{
Name: "no-debug-config-map",
Namespace: "default",
},
Spec: workflowSpec,
Status: common.AppStatus{
Workflow: &common.WorkflowStatus{},
},
},
step: "test-wf1",
focus: "test",
expectedErr: "failed to get debug configmap",
},
"config map no data": {
app: &v1beta1.Application{
ObjectMeta: metav1.ObjectMeta{
Name: "config-map-no-data",
Namespace: "default",
UID: "12345",
},
Spec: workflowSpec,
Status: common.AppStatus{
Workflow: &common.WorkflowStatus{},
},
},
cm: &corev1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: "config-map-no-data-test-wf1-debug-12345",
Namespace: "default",
},
},
step: "test-wf1",
focus: "test",
expectedErr: "debug configmap is empty",
},
"config map error data": {
app: &v1beta1.Application{
ObjectMeta: metav1.ObjectMeta{
Name: "config-map-error-data",
Namespace: "default",
UID: "12345",
},
Spec: workflowSpec,
Status: common.AppStatus{
Workflow: &common.WorkflowStatus{},
},
},
cm: &corev1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: "config-map-error-data-test-wf1-debug-12345",
Namespace: "default",
},
Data: map[string]string{
"debug": "error",
},
},
step: "test-wf1",
},
"success": {
app: &v1beta1.Application{
ObjectMeta: metav1.ObjectMeta{
Name: "success",
Namespace: "default",
UID: "12345",
},
Spec: workflowSpec,
Status: common.AppStatus{
Workflow: &common.WorkflowStatus{},
},
},
cm: &corev1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: "success-test-wf1-debug-12345",
Namespace: "default",
},
Data: map[string]string{
"debug": `
test: test
`,
},
},
step: "test-wf1",
focus: "test",
},
"success-component": {
app: &v1beta1.Application{
ObjectMeta: metav1.ObjectMeta{
Name: "success",
Namespace: "default",
},
Spec: v1beta1.ApplicationSpec{
Components: []common.ApplicationComponent{{
Name: "test-component",
Type: "worker",
Properties: &runtime.RawExtension{Raw: []byte(`{"cmd":["sleep","1000"],"image":"busybox"}`)},
}},
},
Status: common.AppStatus{
Workflow: &common.WorkflowStatus{},
},
},
step: "test-component",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
r := require.New(t)
d := &debugOpts{
step: tc.step,
focus: tc.focus,
}
client, err := c.GetClient()
r.NoError(err)
if tc.cm != nil {
err := client.Create(ctx, tc.cm)
r.NoError(err)
}
wargs := &WorkflowArgs{
Args: c,
Type: instanceTypeApplication,
App: tc.app,
}
err = wargs.generateWorkflowInstance(ctx, client)
r.NoError(err)
err = d.debugApplication(ctx, wargs, c, ioStream)
if tc.expectedErr != "" {
r.Contains(err.Error(), tc.expectedErr)
return
}
r.NoError(err)
})
}
}
|
package antminer
import (
"bytes"
"context"
"sync"
"github.com/ka2n/masminer/machine"
"github.com/ka2n/masminer/machine/asic/base"
mnet "github.com/ka2n/masminer/net"
"golang.org/x/crypto/ssh"
"golang.org/x/sync/errgroup"
)
// GetSystemInfo returns SystemInfo
func (c *Client) GetSystemInfo() (info SystemInfo, err error) {
return c.GetSystemInfoContext(context.Background())
}
// GetSystemInfoContext returns SystemInfo
func (c *Client) GetSystemInfoContext(ctx context.Context) (info SystemInfo, err error) {
// Read from cache
c.MU.RLock()
if c.systemInfo != nil {
c.MU.RUnlock()
return *c.systemInfo, nil
}
c.MU.RUnlock()
info, err = c.getSystemInfo(ctx)
if err != nil {
return info, err
}
// Cache
c.MU.Lock()
defer c.MU.Unlock()
c.systemInfo = &info
return info, nil
}
func (c *Client) getSystemInfo(ctx context.Context) (info SystemInfo, err error) {
var mu sync.Mutex
client := c.SSH
info.MinerType = c.minerType
wg, ctx := errgroup.WithContext(ctx)
wg.Go(func() error {
ret, err := getMacAddr(ctx, client, c.ipCMDPath)
if err != nil {
return err
}
mu.Lock()
defer mu.Unlock()
info.MACAddr = ret
return nil
})
wg.Go(func() error {
ret, err := getIPAddr(ctx, client, c.ipCMDPath)
if err != nil {
return err
}
mu.Lock()
defer mu.Unlock()
info.IPAddr = ret
return nil
})
wg.Go(func() error {
ret, err := base.GetHostname(ctx, client)
if err != nil {
return err
}
mu.Lock()
defer mu.Unlock()
info.Hostname = ret
return nil
})
wg.Go(func() error {
ret, err := getModel(ctx, client)
if err != nil {
return err
}
mu.Lock()
defer mu.Unlock()
info.Model = ret
return nil
})
wg.Go(func() error {
ret, err := base.GetKernelVersion(ctx, client)
if err != nil {
return err
}
mu.Lock()
defer mu.Unlock()
info.KernelVersion = ret
return nil
})
wg.Go(func() error {
ret, err := getFileSystemVersion(ctx, client)
if err != nil {
return err
}
mu.Lock()
defer mu.Unlock()
info.FileSystemVersion = ret
return nil
})
wg.Go(func() error {
ret, err := getMinerVersion(ctx, client, c.versionCMD)
if err != nil {
return err
}
mu.Lock()
defer mu.Unlock()
info.MinerVersion = ret
return nil
})
wg.Go(func() error {
ret, err := getHardwareVersions(ctx, client, c.statsCMD)
if err != nil {
return err
}
mu.Lock()
defer mu.Unlock()
info.HardwareVersions = ret
return nil
})
return info, wg.Wait()
}
func getMacAddr(ctx context.Context, client *ssh.Client, ipCMD string) (string, error) {
cmd := ipCMD + ` link show eth0 | grep -o 'link/.*' | cut -d' ' -f2`
ret, err := base.OutputRemoteShell(ctx, client, cmd)
return string(bytes.TrimSpace(ret)), err
}
func getModel(ctx context.Context, client *ssh.Client) (machine.Model, error) {
cmd := `sed -n 2p ` + metadataPath
ret, err := base.OutputRemoteShell(ctx, client, cmd)
if err != nil {
return machine.ModelUnknown, err
}
return MinerTypeFromString(string(ret))
}
func getFileSystemVersion(ctx context.Context, client *ssh.Client) (string, error) {
cmd := `sed -n 1p ` + metadataPath
ret, _ := base.OutputRemoteShell(ctx, client, cmd)
// let ignore error. some model have FileSystemVersion in it's binary, support it someday.
return string(bytes.TrimSpace(ret)), nil
}
func getMinerVersion(ctx context.Context, client *ssh.Client, cmd string) (string, error) {
ret, err := base.OutputRemoteShell(ctx, client, cmd)
if err != nil {
return "", err
}
return parseCGMinerVersion(ret)
}
func getHardwareVersions(ctx context.Context, client *ssh.Client, cmd string) ([]string, error) {
ret, err := base.OutputRemoteShell(ctx, client, cmd)
if err != nil {
return nil, err
}
return parseHWVersionsFromCGMinerStats(bytes.TrimSpace(ret))
}
func getIPAddr(ctx context.Context, client *ssh.Client, ipCMD string) (string, error) {
cmd := ipCMD + ` addr show eth0 | grep -o 'inet\s.*' | cut -d' ' -f2`
ret, err := base.OutputRemoteShell(ctx, client, cmd)
if err != nil {
return string(ret), err
}
return mnet.ParseIPAddr(string(bytes.TrimSpace(ret)))
}
|
/*
* @lc app=leetcode.cn id=1078 lang=golang
*
* [1078] Bigram 分词
*/
package main
import (
"strings"
)
// @lc code=start
func findOcurrences(text string, first string, second string) []string {
ret := []string{}
words := strings.Split(text, " ")
for i := 0; i < len(words)-2; i++ {
if words[i] == first && words[i+1] == second {
ret = append(ret, words[i+2])
}
}
return ret
}
// func main() {
// fmt.Println(findOcurrences("alice is a good girl she is a good student", "a", "good"),
// findOcurrences("we will we will rock you", "we", "will"))
// }
// @lc code=end
|
package distribution
import (
"container/ring"
"io"
"sync"
)
func NewRoundRobin() Distribution {
return &RoundRobin{
connections: ring.New(1),
}
}
type RoundRobin struct {
connections *ring.Ring
mu sync.Mutex
}
func (r *RoundRobin) Attach(c io.Writer) error {
r.mu.Lock()
defer r.mu.Unlock()
nr := ring.New(1)
nr.Value = c
if r.connections == nil {
r.connections = nr
return nil
}
r.connections.Link(nr)
return nil
}
func (r *RoundRobin) Write(b []byte) (int, error) {
r.mu.Lock()
defer r.mu.Unlock()
if r.connections != nil {
v := r.connections
for v.Value == nil {
v = r.connections.Unlink(1)
}
for _, err := v.Value.(io.Writer).Write(b); err != nil; {
v.Value = nil
v = v.Next()
}
r.connections = v
}
return len(b), nil
}
|
package crud
import (
"encoding/json"
"fmt"
"net/http"
"reflect"
"strings"
"github.com/go-msvc/errors"
"github.com/go-msvc/log"
"github.com/go-msvc/store"
)
//New ...
func New() Server {
return Server{
stores: make([]store.IStore, 0),
opers: make(map[string]operInfo),
}
}
//Server ...
type Server struct {
stores []store.IStore
opers map[string]operInfo
}
//With another store
func (server Server) With(s store.IStore) Server {
//todo: s.Name() name must be unique
server.stores = append(server.stores, s)
return server
}
//WithOper adds a custom operation
func (server Server) WithOper(path string, oper IOper) Server {
//validate the operation to have a Process() method
operType := reflect.TypeOf(oper)
operProcessMethod, ok := operType.MethodByName("Process")
if !ok {
panic(errors.Errorf("%T does not have Process(request)->(response,error) method", oper))
}
if operProcessMethod.Type.NumIn() != 2 {
panic(errors.Errorf("%T.Process() does not have prototype Process(request)->(response,error)", oper))
}
operRequestType := operProcessMethod.Type.In(1)
if err := store.ValidateUserType(operRequestType); err != nil {
panic(errors.Wrapf(err, "invalid oper request %s used as arg %T.Process(<request>)", operRequestType.Name(), oper))
}
server.opers[path] = operInfo{
oper: oper,
processMethod: reflect.ValueOf(oper).MethodByName("Process"), //of value, not of type as above :-)
requestType: operRequestType,
}
return server
}
//AddToMux ...
func (server Server) AddToMux(mux *http.ServeMux) {
for _, s := range server.stores {
mux.Handle("/"+s.Name(), server.storeHandler(server.storePost, server.storeGet, s))
mux.Handle("/"+s.Name()+"/", server.storeHandler(server.storePost, server.storeGet, s))
}
for operPath, operInfo := range server.opers {
mux.Handle(operPath, server.operHandler(server.operPost, operInfo))
}
}
func (server Server) storeHandler(
postFunc func(s store.IStore, res http.ResponseWriter, req *http.Request),
getFunc func(s store.IStore, res http.ResponseWriter, req *http.Request),
s store.IStore,
) http.HandlerFunc {
return func(res http.ResponseWriter, req *http.Request) {
log.Debugf("HTTP %s %s", req.Method, req.URL.Path)
switch req.Method {
case http.MethodPost:
postFunc(s, res, req)
return
case http.MethodGet:
getFunc(s, res, req)
return
} //switch(method)
http.Error(res, "CRUD: Create with POST, Read with GET, Update with PUT, Delete with DELETE.", http.StatusMethodNotAllowed)
return
} //handlerFunc()
} //Server.storeHandler()
//POST /item {...} to create a new item -> {"type":"<store.name>", "id":"<id>", "rev":<rev>, "ts":"<ts>", "user":"<user.id>"}
func (server Server) storePost(s store.IStore, res http.ResponseWriter, req *http.Request) {
if req.URL.Path != "/"+s.Name() {
http.Error(res, fmt.Sprintf("Expecting POST /%s", s.Name()), http.StatusBadRequest)
return
}
itemPtrValue := reflect.New(s.Type())
if err := json.NewDecoder(req.Body).Decode(itemPtrValue.Interface()); err != nil {
http.Error(res, fmt.Sprintf("Cannot parse body as JSON %s", s.Name()), http.StatusBadRequest)
return
}
itemDataPtr := itemPtrValue.Interface()
if itemValidator, ok := itemDataPtr.(IWithValidate); ok {
//call validate with pointer receiver
if err := itemValidator.Validate(); err != nil {
http.Error(res, errors.Wrapf(err, "invalid %s", s.Name()).Error(), http.StatusBadRequest)
return
}
}
itemData := itemPtrValue.Elem().Interface()
if itemValidator, ok := itemData.(IWithValidate); ok {
//call validate with const receiver
if err := itemValidator.Validate(); err != nil {
http.Error(res, errors.Wrapf(err, "invalid %s", s.Name()).Error(), http.StatusBadRequest)
return
}
}
info, err := s.Add(itemData)
if err != nil {
http.Error(res, errors.Wrapf(err, "failed to add").Error(), http.StatusInternalServerError)
return
}
jsonValue, _ := json.Marshal(info)
res.Header().Set("Item-ID", string(info.ID))
res.Header().Set("Item-User-ID", string(info.UserID))
res.Header().Set("Item-Timestamp", fmt.Sprintf("%s", info.Timestamp.Format(timestampFormat)))
res.Header().Set("Item-Revision", fmt.Sprintf("%d", info.Rev))
res.Header().Set("Content-Type", "application/json")
res.Write(jsonValue)
} //Server.storePost()
//GET /item/id -> item data
func (server Server) storeGet(s store.IStore, res http.ResponseWriter, req *http.Request) {
parts := strings.SplitN(req.URL.Path, "/", 4)
if len(parts) != 3 || len(parts[2]) == 0 {
http.Error(res, fmt.Sprintf("Expecting GET /%s/<id>", s.Name()), http.StatusNotFound)
return
}
id := parts[2]
v, info, err := s.Get(store.ID(id))
if err != nil {
http.Error(res, fmt.Sprintf("Expecting GET /%s/<id>", s.Name()), http.StatusNotFound)
return
}
res.Header().Set("Item-Timestamp", fmt.Sprintf("%s", info.Timestamp.Format(timestampFormat)))
res.Header().Set("Item-Revision", fmt.Sprintf("%d", info.Rev))
res.Header().Set("Content-Type", "application/json")
jsonValue, _ := json.Marshal(v)
res.Write(jsonValue)
} //server.storeGet()
type operInfo struct {
oper IOper
processMethod reflect.Value
requestType reflect.Type
}
func (server Server) operHandler(
postFunc func(o operInfo, res http.ResponseWriter, req *http.Request),
o operInfo,
) http.HandlerFunc {
return func(res http.ResponseWriter, req *http.Request) {
log.Debugf("HTTP %s %s", req.Method, req.URL.Path)
switch req.Method {
case http.MethodPost:
postFunc(o, res, req)
return
} //switch(method)
http.Error(res, req.URL.Path+" accepts only POST", http.StatusMethodNotAllowed)
return
} //handlerFunc()
} //Server.operHandler()
//POST /path {...} to call the operation
func (server Server) operPost(o operInfo, res http.ResponseWriter, req *http.Request) {
requestPtrValue := reflect.New(o.requestType)
if err := json.NewDecoder(req.Body).Decode(requestPtrValue.Interface()); err != nil {
http.Error(res, fmt.Sprintf("Cannot parse body as JSON %s", o.requestType.Name()), http.StatusBadRequest)
return
}
requestDataPtr := requestPtrValue.Interface()
if requestValidator, ok := requestDataPtr.(IWithValidate); ok {
//call validate with pointer receiver
if err := requestValidator.Validate(); err != nil {
http.Error(res, errors.Wrapf(err, "invalid %s", o.requestType.Name()).Error(), http.StatusBadRequest)
return
}
}
requestData := requestPtrValue.Elem().Interface()
if requestValidator, ok := requestData.(IWithValidate); ok {
//call validate with const receiver
if err := requestValidator.Validate(); err != nil {
http.Error(res, errors.Wrapf(err, "invalid %s", o.requestType.Name()).Error(), http.StatusBadRequest)
return
}
}
//call the oper.Process() method to make the response
in := make([]reflect.Value, 0)
//in = append(in, ...) //receiver
in = append(in, reflect.ValueOf(requestData))
out := o.processMethod.Call(in)
if len(out) != 2 {
http.Error(res, errors.Errorf("%T.Process() returned %d instead of %d values", o.oper, len(out), 2).Error(), http.StatusInternalServerError)
return
}
responseData := out[0].Interface()
var err error
if out[1].Interface() != nil {
var ok bool
err, ok = out[1].Interface().(error)
if !ok {
panic(errors.Errorf("%T:%v is not error", out[1], out[1]))
}
http.Error(res, errors.Errorf("failed: %v", err).Error(), http.StatusBadRequest)
return
}
jsonValue, _ := json.Marshal(responseData)
res.Header().Set("Content-Type", "application/json")
res.Write(jsonValue)
} //Server.operPost()
const timestampFormat = "2006-01-02 15:04:05-0700"
//IWithValidate ...
type IWithValidate interface {
Validate() error
}
|
package google
import (
"context"
"net/http"
"time"
"github.com/otamoe/oauth-client"
)
type (
Client struct {
oauth.OAuth2
}
)
var Endpoint = oauth.Endpoint{
Name: "google",
AuthorizeURL: "https://accounts.google.com/o/oauth2/auth",
AccessTokenURL: "https://accounts.google.com/o/oauth2/token",
RefreshTokenURL: "https://accounts.google.com/o/oauth2/token",
RevokeTokenURL: "https://accounts.google.com/o/oauth2/revoke",
APIURL: "https://www.googleapis.com",
ClientHeader: "Basic",
TokenHeader: "Bearer",
}
func (c *Client) User(ctx context.Context, token *oauth.Token) (user *oauth.User, err error) {
now := time.Now()
var req *http.Request
// if req, err = http.NewRequest("GET", c.Endpoint.APIURL+"/userinfo/v2/me", nil); err != nil {
if req, err = http.NewRequest("GET", c.Endpoint.APIURL+"/oauth2/v2/userinfo", nil); err != nil {
return
}
httpClient := oauth.HTTPClient(ctx, c, token)
var raw map[string]interface{}
if raw, err = c.Response(ctx, httpClient, req); err != nil {
return
}
user = &oauth.User{
ID: raw["id"].(string),
Raw: raw,
Updated: &now,
}
if v, ok := raw["family_name"].(string); ok {
user.FamilyName = v
}
if v, ok := raw["given_name"].(string); ok {
user.GivenName = v
}
if v, ok := raw["name"].(string); ok {
user.Name = v
}
if v, ok := raw["picture"].(string); ok {
user.Avatar = v
}
if v, ok := raw["locale"].(string); ok {
user.Locale = oauth.FormatLocale(v)
}
if v, ok := raw["gender"].(string); ok {
user.Gender = v
}
if v, ok := raw["link"].(string); ok {
user.Link = v
}
if v, ok := raw["email"].(string); ok && v != "" {
verified, _ := raw["verified_email"].(bool)
if user.Auths == nil {
user.Auths = make([]*oauth.Auth, 0)
}
user.Auths = append(user.Auths, &oauth.Auth{
Type: "email",
Value: v,
Verified: verified,
})
}
return
}
|
package DAO
import (
_ "github.com/go-sql-driver/mysql"
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/mysql"
"Work_5/object"
)
func DataBaseInit() (*gorm.DB, object.ErrMessage) {
DB , err := gorm.Open("mysql","root:@(127.0.0.1:3306)/go?charset=utf8mb4&parseTime=True&loc=Local")
return DB , object.ErrMessage{Error: err}
}
|
package client
import (
"context"
"crypto/tls"
"crypto/x509"
"io"
"io/ioutil"
"time"
"github.com/tsaikd/KDGoLib/errutil"
"github.com/tsaikd/go-grpc-echo/logger"
pb "github.com/tsaikd/go-grpc-echo/pb"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
)
// Ping send Ping message to grpc server
func Ping(ctx context.Context, url string, message string, certPath string, insecureSkipVerify bool, headerMap metadata.MD) (err error) {
opts := []grpc.DialOption{}
var tlsConfig *tls.Config
if certPath != "" {
certFile, err := ioutil.ReadFile(certPath)
if err != nil {
return err
}
certPool := x509.NewCertPool()
if certPool.AppendCertsFromPEM(certFile) {
tlsConfig = &tls.Config{RootCAs: certPool, InsecureSkipVerify: insecureSkipVerify}
}
}
if insecureSkipVerify && tlsConfig == nil {
tlsConfig = &tls.Config{InsecureSkipVerify: insecureSkipVerify}
}
if tlsConfig != nil {
opts = append(opts, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)))
} else {
opts = append(opts, grpc.WithInsecure())
}
conn, err := grpc.Dial(url, opts...)
if err != nil {
return
}
defer func() {
errutil.Trace(conn.Close())
}()
ctx = metadata.NewOutgoingContext(ctx, headerMap)
msg := &pb.Ping{Message: message}
client := pb.NewEchoClient(conn)
pong, err := client.Send(ctx, msg)
if err != nil {
return
}
logger.TrottlePrintf("Send %+q to %q (tls: %v), received %+q", msg, url, tlsConfig != nil, pong)
return
}
// Subscribe stream from grpc server
func Subscribe(ctx context.Context, url string, message string, duration time.Duration) (err error) {
conn, err := grpc.Dial(url, grpc.WithInsecure())
if err != nil {
return
}
defer func() {
errutil.Trace(conn.Close())
}()
msg := &pb.Ping{Message: message}
client := pb.NewEchoClient(conn)
sub, err := client.Subscribe(ctx, msg)
if err != nil {
return
}
defer func() {
errutil.Trace(sub.CloseSend())
}()
timer := time.NewTimer(duration)
for {
select {
case <-ctx.Done():
return
case <-sub.Context().Done():
return
case <-timer.C:
return
default:
}
pong, err := sub.Recv()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
logger.TrottlePrintf("Send %+q to %q , received %+q", msg, url, pong)
}
}
|
/*
Tencent is pleased to support the open source community by making Basic Service Configuration Platform 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 service
import (
"context"
"errors"
"fmt"
"strings"
"bscp.io/pkg/dal/table"
"bscp.io/pkg/kit"
"bscp.io/pkg/logs"
pbbase "bscp.io/pkg/protocol/core/base"
pbtemplate "bscp.io/pkg/protocol/core/template"
pbds "bscp.io/pkg/protocol/data-service"
"bscp.io/pkg/search"
"bscp.io/pkg/tools"
"bscp.io/pkg/types"
)
// CreateTemplate create template.
func (s *Service) CreateTemplate(ctx context.Context, req *pbds.CreateTemplateReq) (*pbds.CreateResp, error) {
kt := kit.FromGrpcContext(ctx)
if _, err := s.dao.Template().GetByUniqueKey(kt, req.Attachment.BizId, req.Attachment.TemplateSpaceId,
req.Spec.Name, req.Spec.Path); err == nil {
return nil, fmt.Errorf("config item's same name %s and path %s already exists", req.Spec.Name, req.Spec.Path)
}
if len(req.TemplateSetIds) > 0 {
if err := s.dao.Validator().ValidateTemplateSetsExist(kt, req.TemplateSetIds); err != nil {
return nil, err
}
}
tx := s.dao.GenQuery().Begin()
// 1. create template
template := &table.Template{
Spec: req.Spec.TemplateSpec(),
Attachment: req.Attachment.TemplateAttachment(),
Revision: &table.Revision{
Creator: kt.User,
Reviser: kt.User,
},
}
id, err := s.dao.Template().CreateWithTx(kt, tx, template)
if err != nil {
logs.Errorf("create template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
// 2. create template revision
spec := req.TrSpec.TemplateRevisionSpec()
spec.RevisionName = generateRevisionName()
templateRevision := &table.TemplateRevision{
Spec: spec,
Attachment: &table.TemplateRevisionAttachment{
BizID: template.Attachment.BizID,
TemplateSpaceID: template.Attachment.TemplateSpaceID,
TemplateID: id,
},
Revision: &table.CreatedRevision{
Creator: kt.User,
},
}
if _, err = s.dao.TemplateRevision().CreateWithTx(kt, tx, templateRevision); err != nil {
logs.Errorf("create template revision failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
// 3. add current template to template sets if necessary
if len(req.TemplateSetIds) > 0 {
if err = s.dao.TemplateSet().AddTemplateToTemplateSetsWithTx(kt, tx, id, req.TemplateSetIds); err != nil {
logs.Errorf("add current template to template sets failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
}
tx.Commit()
resp := &pbds.CreateResp{Id: id}
return resp, nil
}
// ListTemplates list templates.
func (s *Service) ListTemplates(ctx context.Context, req *pbds.ListTemplatesReq) (*pbds.ListTemplatesResp, error) {
kt := kit.FromGrpcContext(ctx)
opt := &types.BasePage{Start: req.Start, Limit: uint(req.Limit), All: req.All}
if err := opt.Validate(types.DefaultPageOption); err != nil {
return nil, err
}
searcher, err := search.NewSearcher(req.SearchFields, req.SearchValue, search.Template)
if err != nil {
return nil, err
}
details, count, err := s.dao.Template().List(kt, req.BizId, req.TemplateSpaceId, searcher, opt)
if err != nil {
logs.Errorf("list templates failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
resp := &pbds.ListTemplatesResp{
Count: uint32(count),
Details: pbtemplate.PbTemplates(details),
}
return resp, nil
}
// UpdateTemplate update template.
func (s *Service) UpdateTemplate(ctx context.Context, req *pbds.UpdateTemplateReq) (*pbbase.EmptyResp, error) {
kt := kit.FromGrpcContext(ctx)
template := &table.Template{
ID: req.Id,
Spec: req.Spec.TemplateSpec(),
Attachment: req.Attachment.TemplateAttachment(),
Revision: &table.Revision{
Reviser: kt.User,
},
}
if err := s.dao.Template().Update(kt, template); err != nil {
logs.Errorf("update template failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
return new(pbbase.EmptyResp), nil
}
// DeleteTemplate delete template.
func (s *Service) DeleteTemplate(ctx context.Context, req *pbds.DeleteTemplateReq) (*pbbase.EmptyResp, error) {
kt := kit.FromGrpcContext(ctx)
r := &pbds.ListTemplateBoundCountsReq{
BizId: req.Attachment.BizId,
TemplateSpaceId: req.Attachment.TemplateSpaceId,
TemplateIds: []uint32{req.Id},
}
boundCnt, err := s.ListTemplateBoundCounts(ctx, r)
if err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
var hasTmplSet, hasUnnamedApp bool
if len(boundCnt.Details) > 0 {
if boundCnt.Details[0].BoundTemplateSetCount > 0 && boundCnt.Details[0].BoundUnnamedAppCount > 0 {
hasTmplSet, hasUnnamedApp = true, true
if !req.Force {
return nil, errors.New("template is bound to template set and unnamed app, please unbind first")
}
} else if boundCnt.Details[0].BoundTemplateSetCount > 0 {
hasTmplSet = true
if !req.Force {
return nil, errors.New("template is bound to template set, please unbind first")
}
} else if boundCnt.Details[0].BoundUnnamedAppCount > 0 {
hasUnnamedApp = true
if !req.Force {
return nil, errors.New("template is bound to unnamed app, please unbind first")
}
}
}
tx := s.dao.GenQuery().Begin()
// 1. delete template
template := &table.Template{
ID: req.Id,
Attachment: req.Attachment.TemplateAttachment(),
}
if err = s.dao.Template().DeleteWithTx(kt, tx, template); err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
// 2. delete template revisions of current template
if err = s.dao.TemplateRevision().DeleteForTmplWithTx(kt, tx, req.Attachment.BizId, req.Id); err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
// 3. delete bound template set if exists
if hasTmplSet {
if err = s.dao.TemplateSet().DeleteTmplFromAllTmplSetsWithTx(kt, tx, req.Attachment.BizId, req.Id); err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
}
// 4. delete bound unnamed app if exists
if hasUnnamedApp {
if err = s.dao.TemplateBindingRelation().DeleteTmplWithTx(kt, tx, req.Attachment.BizId, req.Id); err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
}
tx.Commit()
return new(pbbase.EmptyResp), nil
}
// BatchDeleteTemplate delete template in batch.
func (s *Service) BatchDeleteTemplate(ctx context.Context, req *pbds.BatchDeleteTemplateReq) (*pbbase.EmptyResp,
error) {
kt := kit.FromGrpcContext(ctx)
r := &pbds.ListTemplateBoundCountsReq{
BizId: req.Attachment.BizId,
TemplateSpaceId: req.Attachment.TemplateSpaceId,
TemplateIds: req.Ids,
}
boundCnt, err := s.ListTemplateBoundCounts(ctx, r)
if err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
hasTmplSets, hasUnnamedApps := make(map[uint32]bool), make(map[uint32]bool)
for _, detail := range boundCnt.Details {
if detail.BoundTemplateSetCount > 0 && detail.BoundUnnamedAppCount > 0 {
hasTmplSets[detail.TemplateId] = true
hasUnnamedApps[detail.TemplateId] = true
if !req.Force {
return nil, fmt.Errorf("template id %d is bound to template set and unnamed app, please unbind first",
detail.TemplateId)
}
} else if detail.BoundTemplateSetCount > 0 {
hasTmplSets[detail.TemplateId] = true
if !req.Force {
return nil, fmt.Errorf("template id %d is bound to template set, please unbind first",
detail.TemplateId)
}
} else if detail.BoundUnnamedAppCount > 0 {
hasUnnamedApps[detail.TemplateId] = true
if !req.Force {
return nil, fmt.Errorf("template id %d is bound to unnamed app, please unbind first", detail.TemplateId)
}
}
}
tx := s.dao.GenQuery().Begin()
// NOTE: if consider to optimize it with batch interface, consider how to add audit record as the same time
for _, templateID := range req.Ids {
// 1. delete template
template := &table.Template{
ID: templateID,
Attachment: req.Attachment.TemplateAttachment(),
}
if err = s.dao.Template().DeleteWithTx(kt, tx, template); err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
// 2. delete template revisions of current template
if err = s.dao.TemplateRevision().DeleteForTmplWithTx(kt, tx, req.Attachment.BizId, templateID); err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
// 3. delete bound template set if exists
if hasTmplSets[templateID] {
if err = s.dao.TemplateSet().DeleteTmplFromAllTmplSetsWithTx(kt, tx, req.Attachment.BizId, templateID); err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
}
// 4. delete bound unnamed app if exists
if hasUnnamedApps[templateID] {
if err = s.dao.TemplateBindingRelation().DeleteTmplWithTx(kt, tx, req.Attachment.BizId, templateID); err != nil {
logs.Errorf("delete template failed, err: %v, rid: %s", err, kt.Rid)
tx.Rollback()
return nil, err
}
}
}
tx.Commit()
return new(pbbase.EmptyResp), nil
}
// AddTemplatesToTemplateSets add templates to template sets.
func (s *Service) AddTemplatesToTemplateSets(ctx context.Context, req *pbds.AddTemplatesToTemplateSetsReq) (
*pbbase.EmptyResp, error) {
kt := kit.FromGrpcContext(ctx)
if err := s.dao.Validator().ValidateTemplatesExist(kt, req.TemplateIds); err != nil {
return nil, err
}
if err := s.dao.Validator().ValidateTemplateSetsExist(kt, req.TemplateSetIds); err != nil {
return nil, err
}
if err := s.dao.TemplateSet().AddTemplatesToTemplateSets(kt, req.TemplateIds, req.TemplateSetIds); err != nil {
logs.Errorf(" add template to template sets failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
return new(pbbase.EmptyResp), nil
}
// DeleteTemplatesFromTemplateSets delete templates from template sets.
func (s *Service) DeleteTemplatesFromTemplateSets(ctx context.Context, req *pbds.DeleteTemplatesFromTemplateSetsReq) (
*pbbase.EmptyResp, error) {
kt := kit.FromGrpcContext(ctx)
if err := s.dao.Validator().ValidateTemplatesExist(kt, req.TemplateIds); err != nil {
return nil, err
}
if err := s.dao.Validator().ValidateTemplateSetsExist(kt, req.TemplateSetIds); err != nil {
return nil, err
}
if err := s.dao.TemplateSet().DeleteTemplatesFromTemplateSets(kt, req.TemplateIds, req.TemplateSetIds); err != nil {
logs.Errorf(" delete template from template sets failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
return new(pbbase.EmptyResp), nil
}
// ListTemplatesByIDs list templates by ids.
func (s *Service) ListTemplatesByIDs(ctx context.Context, req *pbds.ListTemplatesByIDsReq) (
*pbds.ListTemplatesByIDsResp, error) {
kt := kit.FromGrpcContext(ctx)
if err := s.dao.Validator().ValidateTemplatesExist(kt, req.Ids); err != nil {
return nil, err
}
details, err := s.dao.Template().ListByIDs(kt, req.Ids)
if err != nil {
logs.Errorf("list template failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
resp := &pbds.ListTemplatesByIDsResp{
Details: pbtemplate.PbTemplates(details),
}
return resp, nil
}
// ListTemplatesNotBound list templates not bound.
// 先获取所有模版ID列表，再获取该空间下所有套餐的template_ids字段进行合并，做差集得到目标ID列表，根据这批ID获取对应的详情，做逻辑分页和搜索
func (s *Service) ListTemplatesNotBound(ctx context.Context, req *pbds.ListTemplatesNotBoundReq) (
*pbds.ListTemplatesNotBoundResp, error) {
kt := kit.FromGrpcContext(ctx)
// validate the page params
opt := &types.BasePage{Start: req.Start, Limit: uint(req.Limit), All: req.All}
if err := opt.Validate(types.DefaultPageOption); err != nil {
return nil, err
}
idsAll, err := s.dao.Template().ListAllIDs(kt, req.BizId, req.TemplateSpaceId)
if err != nil {
logs.Errorf("list templates not bound failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
idsBound, err := s.dao.TemplateSet().ListAllTemplateIDs(kt, req.BizId, req.TemplateSpaceId)
if err != nil {
logs.Errorf("list templates not bound failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
ids := tools.SliceDiff(idsAll, idsBound)
templates, err := s.dao.Template().ListByIDs(kt, ids)
details := pbtemplate.PbTemplates(templates)
// search by logic
if req.SearchValue != "" {
searcher, err := search.NewSearcher(req.SearchFields, req.SearchValue, search.Template)
if err != nil {
return nil, err
}
fields := searcher.SearchFields()
fieldsMap := make(map[string]bool)
for _, f := range fields {
fieldsMap[f] = true
}
newDetails := make([]*pbtemplate.Template, 0)
for _, detail := range details {
if (fieldsMap["name"] && strings.Contains(detail.Spec.Name, req.SearchValue)) ||
(fieldsMap["path"] && strings.Contains(detail.Spec.Path, req.SearchValue)) ||
(fieldsMap["memo"] && strings.Contains(detail.Spec.Memo, req.SearchValue)) ||
(fieldsMap["creator"] && strings.Contains(detail.Revision.Creator, req.SearchValue)) ||
(fieldsMap["reviser"] && strings.Contains(detail.Revision.Reviser, req.SearchValue)) {
newDetails = append(newDetails, detail)
}
}
details = newDetails
}
// totalCnt is all data count
totalCnt := uint32(len(details))
if req.All {
// return all data
return &pbds.ListTemplatesNotBoundResp{
Count: totalCnt,
Details: details,
}, nil
}
// page by logic
if req.Start >= uint32(len(details)) {
details = details[:0]
} else if req.Start+req.Limit > uint32(len(details)) {
details = details[req.Start:]
} else {
details = details[req.Start : req.Start+req.Limit]
}
return &pbds.ListTemplatesNotBoundResp{
Count: totalCnt,
Details: details,
}, nil
}
// ListTemplatesOfTemplateSet list templates of template set.
// 获取到该套餐的template_ids字段，根据这批ID获取对应的详情，做逻辑分页和搜索
func (s *Service) ListTemplatesOfTemplateSet(ctx context.Context, req *pbds.ListTemplatesOfTemplateSetReq) (
*pbds.ListTemplatesOfTemplateSetResp, error) {
kt := kit.FromGrpcContext(ctx)
// validate the page params
opt := &types.BasePage{Start: req.Start, Limit: uint(req.Limit), All: req.All}
if err := opt.Validate(types.DefaultPageOption); err != nil {
return nil, err
}
if err := s.dao.Validator().ValidateTemplateSetExist(kt, req.TemplateSetId); err != nil {
return nil, err
}
templateSets, err := s.dao.TemplateSet().ListByIDs(kt, []uint32{req.TemplateSetId})
if err != nil {
logs.Errorf("list templates of template set failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
templates, err := s.dao.Template().ListByIDs(kt, templateSets[0].Spec.TemplateIDs)
if err != nil {
logs.Errorf("list templates of template set failed, err: %v, rid: %s", err, kt.Rid)
return nil, err
}
details := pbtemplate.PbTemplates(templates)
// search by logic
if req.SearchValue != "" {
searcher, err := search.NewSearcher(req.SearchFields, req.SearchValue, search.Template)
if err != nil {
return nil, err
}
fields := searcher.SearchFields()
fieldsMap := make(map[string]bool)
for _, f := range fields {
fieldsMap[f] = true
}
newDetails := make([]*pbtemplate.Template, 0)
for _, detail := range details {
if (fieldsMap["name"] && strings.Contains(detail.Spec.Name, req.SearchValue)) ||
(fieldsMap["path"] && strings.Contains(detail.Spec.Path, req.SearchValue)) ||
(fieldsMap["memo"] && strings.Contains(detail.Spec.Memo, req.SearchValue)) ||
(fieldsMap["creator"] && strings.Contains(detail.Revision.Creator, req.SearchValue)) ||
(fieldsMap["reviser"] && strings.Contains(detail.Revision.Reviser, req.SearchValue)) {
newDetails = append(newDetails, detail)
}
}
details = newDetails
}
// totalCnt is all data count
totalCnt := uint32(len(details))
if req.All {
// return all data
return &pbds.ListTemplatesOfTemplateSetResp{
Count: totalCnt,
Details: details,
}, nil
}
// page by logic
if req.Start >= uint32(len(details)) {
details = details[:0]
} else if req.Start+req.Limit > uint32(len(details)) {
details = details[req.Start:]
} else {
details = details[req.Start : req.Start+req.Limit]
}
return &pbds.ListTemplatesOfTemplateSetResp{
Count: totalCnt,
Details: details,
}, nil
}
|
package yousign
import (
"bytes"
"io"
"net/http"
"testing"
"github.com/bxcodec/faker/v3"
"github.com/stretchr/testify/assert"
)
var (
client = NewClientStaging("STAGING-KEY")
)
func fatal(t *testing.T, err error, resp *http.Response) {
var b bytes.Buffer
io.Copy(&b, resp.Body)
t.Fatalf("error %v : %s", err, b.String())
}
func TestCorrectStagingSigningURL(t *testing.T) {
assert := assert.New(t)
apiKey := faker.UUIDHyphenated()
client := NewClientStaging(apiKey)
memberID := faker.UUIDHyphenated()
signURL := client.SignURL(memberID)
expectedURL := "https://staging-app.yousign.com/procedure/sign?members=" + memberID
assert.Equal(expectedURL, signURL)
}
func TestCorrectProductionSigningURL(t *testing.T) {
assert := assert.New(t)
apiKey := faker.UUIDHyphenated()
client := NewClient(apiKey)
memberID := faker.UUIDHyphenated()
signURL := client.SignURL(memberID)
expectedURL := "https://webapp.yousign.com/procedure/sign?members=" + memberID
assert.Equal(expectedURL, signURL)
}
|
package controller
import (
"model"
"net"
proto "github.com/golang/protobuf/proto"
)
/****************************************** req handler ****************************************/
func PingReq(conn *net.Conn, data []byte, n int, reqBasic ReqBasic) error {
return model.Ping(conn, reqBasic.UserID)
}
func SetUserLocEQReq(conn *net.Conn, data []byte, n int, reqBasic ReqBasic) (err error) {
reqPB := new(model.SetUserLocEQReq)
err = proto.Unmarshal(data[:n], reqPB)
if err != nil {
return
}
userID := reqBasic.UserID
loc := reqPB.GetLoc()
err = model.SetRedisUserLocEQ(userID, loc.GetLongitude(), loc.GetLatitude(), reqPB.GetEQ())
return
}
func GetUserLocEQReq(conn *net.Conn, data []byte, n int, reqBasic ReqBasic) (err error) {
reqPB := new(model.GetUserLocEQReq)
err = proto.Unmarshal(data[:n], reqPB)
if err != nil {
return
}
userID := reqPB.GetUserID()
location, eq, err := model.GetRedisUserLocEQ(userID)
resPB := &model.GetUserLocEQRes{
Header: &model.ResHeader{
ResMethod: MethodGetUserLocEQ,
},
Loc: &location,
EQ: int32(eq),
}
out, err := proto.Marshal(resPB)
if err != nil {
return
}
(*conn).Write(out)
return
}
func GetMsgQueneReq(conn *net.Conn, data []byte, n int, reqBasic ReqBasic) (err error) {
resData, err := model.GetRedisMsgQuene(reqBasic.UserID)
resPB := &model.GetMsgQueneRes{
Header: &model.ResHeader{
ResMethod: MethodGetMsgQuene,
},
Data: resData,
}
out, err := proto.Marshal(resPB)
if err != nil {
return
}
(*conn).Write(out)
return
}
|
package main
import (
"fmt"
"runtime"
"sync"
)
func main() {
runtime.GOMAXPROCS(1)
var wg sync.WaitGroup
wg.Add(1)
go func(){
defer wg.Done()
fmt.Println("ok")
}()
wg.Wait()
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.