text stringlengths 11 4.05M |
|---|
package main
func main() {
//keyboardExample()
//miceExample()
//touchPadExample()
//touchScreenExample()
}
|
package main
// atomic counters - accessed by multiple go routines
import "fmt"
import "time"
import "sync/atomic"
func main() {
var ops uint64 // unsigned int to represent always positive counter
for i := 0; i < 50; i++ { // start 50 go routines
go func() {
for {
atomic.AddUint64(&ops, 1) // add via memory address
// atomically increment counter
time.Sleep(time.Millisecond) // wait between increments
}
}()
}
time.Sleep(time.Second) // wait to allow ops to accumulate
// to safely use counter while being updated - extract copy of the current value via LoadUint64 - via memory address
opsFinal := atomic.LoadUint64(&ops)
fmt.Println("ops:", opsFinal)
}
|
package main
import (
"bytes"
"testing"
)
func TestEncodeUTF32BE(t *testing.T) {
res := EncodeUTF32BE([]uint32{
0x0068, // Latin Small Letter H
0x0065, // Latin Small Letter E
0x0079, // Latin Small Letter Y
0x1F64C, // Person Raising Both Hands In Celebration Emoji
})
expected := []byte{
0x00, 0x00, 0xFE, 0xFF, // BOM
0x00, 0x00, 0x00, 0x68, // h
0x00, 0x00, 0x00, 0x65, // e
0x00, 0x00, 0x00, 0x79, // y
0x00, 0x01, 0xF6, 0x4C, // emoji
}
if !bytes.Equal(res, expected) {
t.Errorf("encoding error")
}
}
func TestEncodeUTF16BE(t *testing.T) {
res := EncodeUTF16BE([]uint32{
0x0068, // Latin Small Letter H
0x0065, // Latin Small Letter E
0x0079, // Latin Small Letter Y
0x1F64C, // Person Raising Both Hands In Celebration Emoji
})
expected := []byte{
0xFE, 0xFF, // BOM
0x00, 0x68, // h
0x00, 0x65, // e
0x00, 0x79, // y
0x3D, 0x4C, // emoji
}
if !bytes.Equal(res, expected) {
t.Errorf("encoding error")
}
}
func TestEncodeUTF8(t *testing.T) {
res := EncodeUTF8([]uint32{
0x0068, // Latin Small Letter H
0x0065, // Latin Small Letter E
0x0079, // Latin Small Letter Y
0x1F64C, // Person Raising Both Hands In Celebration Emoji
})
expected := []byte{
0x68, // h
0x65, // e
0x79, // y
0xF0, 0x9F, 0x99, 0x8C, // emoji
}
if !bytes.Equal(res, expected) {
t.Errorf("encoding error")
}
}
|
package controllers
import (
"encoding/json"
"ss-backend/models"
"github.com/astaxie/beego"
)
type (
// PemesananController ...
PemesananController struct {
beego.Controller
}
)
// Get all data product
func (c *PemesananController) Get() {
var resp RespData
var order models.Pemesanan
var reqDt = models.RequestGet{
FromDate: c.Ctx.Input.Query("fromDate"),
ToDate: c.Ctx.Input.Query("toDate"),
Query: c.Ctx.Input.Query("query"),
}
beego.Debug(reqDt)
res, errGet := order.GetAll(reqDt)
if errGet != nil {
resp.Error = errGet
} else {
resp.Body = res
}
err := c.Ctx.Output.JSON(resp, false, false)
if err != nil {
panic("ERROR OUTPUT JSON LEVEL MIDDLEWARE")
}
// c.TplName = "index.tpl"
}
// Post add new order
func (c *PemesananController) Post() {
var resp RespData
var order models.Pemesanan
err := json.Unmarshal(c.Ctx.Input.RequestBody, &order)
if err != nil {
beego.Warning("unmarshall req body failed")
}
errAdd := order.AddPemesanan()
if errAdd != nil {
resp.Error = errAdd
} else {
resp.Body = order
}
err = c.Ctx.Output.JSON(resp, false, false)
if err != nil {
beego.Warning("failed giving output", err)
}
// c.TplName = "index.tpl"
}
// Put to update existing order
func (c *PemesananController) Put() {
var resp RespData
var order models.Pemesanan
var req models.RequestUpdate
err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
if err != nil {
beego.Warning("unmarshall req body failed")
}
errAdd := order.UpdatePesanan(req)
if errAdd != nil {
resp.Error = errAdd
} else {
resp.Body = order
}
err = c.Ctx.Output.JSON(resp, false, false)
if err != nil {
beego.Warning("failed giving output", err)
}
// c.TplName = "index.tpl"
}
|
package utils
import (
"lili_style_test/sheets"
)
func SearchUserDataByMail(mail string) []string {
formData := sheets.GetAll()
for _, d := range formData {
if d[1] == mail {
user := convertInterfaceToString(d)
return user
}
}
return nil
}
func SearchUserDataBySlash(mail string) []string {
formData := sheets.GetAll()
for _, d := range formData {
converted := convertInterfaceToString(d)
if converted[1] + "/" == mail {
return converted
}
}
return nil
}
func convertInterfaceToString(iData []interface{}) []string{
var converted []string
for _, i := range iData {
converted = append(converted, i.(string))
}
return converted
}
func ParsedRate(answers []int, questionCount int) int {
point := 0
for _, a := range answers{
point = point + a
}
var coefficient float64
coefficient = float64(questionCount) / float64(10) //問題数が10の何倍かを求める
coefficient = 1 / coefficient //求めた結果で1を割り、係数にする
result := float64(point) * coefficient //係数を合計にかけて最大値を10に近くする。
return int(result)
}
func ParsedAnswerYesAdd(answers []string) []int{
var intAnswers []int
for _, a := range answers {
switch a {
case "はい":
intAnswers = append(intAnswers, 1)
case "いいえ":
intAnswers = append(intAnswers, 0)
}
}
return intAnswers
}
func ParsedAnswerNoAdd(answers []string) []int {
var intAnswers []int
for _, a := range answers {
switch a {
case "はい":
intAnswers = append(intAnswers, 0)
case "いいえ":
intAnswers = append(intAnswers, 1)
}
}
return intAnswers
}
func ParsedAnswerPersonality(answers []string) []int {
var intAnswers []int
for _, a := range answers {
switch a{
case "はい":
intAnswers = append(intAnswers, 2)
case "どちらでもない":
intAnswers = append(intAnswers, 1)
case "いいえ":
intAnswers = append(intAnswers, 0)
}
}
return intAnswers
}
func SearchUserDataByCorporateID(corporateID string) [][]string {
formData := sheets.GetAll()
var users [][]string
for _, d := range formData {
if d[2] == corporateID {
user := convertInterfaceToString(d)
users = append(users, user)
}
}
return users
}
|
// Copyright (c) 2014 Conformal Systems LLC.
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package main
import (
"io/ioutil"
"log"
"os"
"os/exec"
"time"
rpc "github.com/conformal/btcrpcclient"
"github.com/conformal/btcutil"
"github.com/conformal/btcwire"
)
// Miner holds all the core features required to register, run, control,
// and kill a cpu-mining btcd instance.
type Miner struct {
cmd *exec.Cmd
client *rpc.Client
datadir string
logdir string
}
// NewMiner starts a cpu-mining enabled btcd instane and returns an rpc client
// to control it.
func NewMiner(addressTable []btcutil.Address, stop chan struct{}) (*Miner, error) {
datadir, err := ioutil.TempDir("", "minerData")
if err != nil {
return nil, err
}
logdir, err := ioutil.TempDir("", "minerLogs")
if err != nil {
return nil, err
}
miner := &Miner{
datadir: datadir,
logdir: logdir,
}
// blocksConnected defines how many blocks have to connect to the blockchain
// before the simulation normally stop.
const blocksConnected int32 = 20000
minerArgs := []string{
"--simnet",
"-u" + defaultChainServer.user,
"-P" + defaultChainServer.pass,
"--datadir=" + miner.datadir,
"--logdir=" + miner.logdir,
"--rpccert=" + defaultChainServer.certPath,
"--rpckey=" + defaultChainServer.keyPath,
"--listen=:18550",
"--rpclisten=:18551",
"--generate",
}
for _, addr := range addressTable {
minerArgs = append(minerArgs, "--miningaddr="+addr.EncodeAddress())
}
miner.cmd = exec.Command("btcd", minerArgs...)
if err := miner.cmd.Start(); err != nil {
log.Printf("%s: Cannot start mining: %v", defaultChainServer.connect, err)
return nil, err
}
// RPC mining client initialization.
rpcConf := rpc.ConnConfig{
Host: "localhost:18551",
Endpoint: "ws",
User: defaultChainServer.user,
Pass: defaultChainServer.pass,
Certificates: defaultChainServer.cert,
}
ntfnHandlers := rpc.NotificationHandlers{
OnTxAccepted: func(hash *btcwire.ShaHash, amount btcutil.Amount) {
log.Printf("Transaction accepted: Hash: %v, Amount: %v", hash, amount)
},
// When a block higher than blocksConnected connects to the chain,
// send a signal to stop actors. This is used so main can break from
// select and call actor.Stop to stop actors.
OnBlockConnected: func(hash *btcwire.ShaHash, height int32) {
log.Printf("Block connected: Hash: %v, Height: %v", hash, height)
if height > blocksConnected {
stop <- struct{}{}
}
},
}
var client *rpc.Client
for i := 0; i < connRetry; i++ {
if client, err = rpc.New(&rpcConf, &ntfnHandlers); err != nil {
time.Sleep(time.Duration(i) * 50 * time.Millisecond)
continue
}
miner.client = client
break
}
if miner.client == nil {
log.Printf("Cannot start mining rpc client: %v", err)
return miner, err
}
// Use just one core for mining.
miner.client.SetGenerate(true, 1)
// Register for block and NewTransaction notifications.
if err := miner.client.NotifyBlocks(); err != nil {
log.Printf("Cannot register for block notifications: %v", err)
return miner, err
}
if err := miner.client.NotifyNewTransactions(false); err != nil {
log.Printf("Cannot register for NewTransaction notifications: %v", err)
return miner, err
}
log.Println("CPU mining started")
return miner, nil
}
// Shutdown kills the mining btcd process and removes its data and
// log directories.
func (m *Miner) Shutdown() {
if err := m.cmd.Process.Kill(); err != nil {
log.Printf("Cannot kill mining btcd process: %v", err)
return
}
m.cmd.Wait()
if err := os.RemoveAll(m.datadir); err != nil {
log.Printf("Cannot remove mining btcd datadir: %v", err)
return
}
if err := os.RemoveAll(m.logdir); err != nil {
log.Printf("Cannot remove mining btcd logdir: %v", err)
return
}
log.Println("Miner shutdown successfully")
}
|
package tritondb
import (
"database/sql"
"errors"
"fmt"
"github.com/tada3/triton/weather/model"
)
const (
selectPreferredCitySQL = "SELECT id from preferred_city WHERE name = ? ORDER BY priority DESC"
selectCityListSQL = "SELECT id from city_list WHERE name = ?"
removeShiSQL = "UPDATE city_list SET name = TRIM(TRAILING '-shi' FROM name) WHERE country = 'JP' AND name LIKE '%-shi'"
selectPreferredCitySQL2 = "SELECT id from preferred_city WHERE name=? AND country=? ORDER BY priority DESC"
selectPreferredCityNoCountrySQL = "SELECT id, country from preferred_city WHERE name=? ORDER BY priority DESC"
selectCityListSQL2 = "SELECT id from city_list WHERE name=? AND country=?"
selectCityListNoCountrySQL = "SELECT id, country from city_list WHERE name=?"
)
var (
stmtP *sql.Stmt
stmtC *sql.Stmt
stmtP2 *sql.Stmt
stmtP2NC *sql.Stmt
stmtC2 *sql.Stmt
stmtC2NC *sql.Stmt
)
func GetCityIDFromPreferredCity(cityName, countryCode string) (int64, bool) {
var err error
if stmtP2 == nil {
stmtP2, err = getDbClient().PrepareStmt(selectPreferredCitySQL2)
if err != nil {
fmt.Printf("ERROR! Prepare failed: %s, stmt=%v\n", err.Error(), selectPreferredCitySQL2)
return -1, false
}
}
var id int64
err = stmtP2.QueryRow(cityName, countryCode).Scan(&id)
if err != nil {
if err != sql.ErrNoRows {
// Error
fmt.Printf("ERROR! Query failed: %s, stmt=%v\n", err.Error(), stmtP2)
stmtP2.Close()
stmtP2 = nil
}
return 0, false
}
return id, true
}
func GetCityIDFromPreferredCityNoCountry(cityName string) (int64, string, bool) {
var err error
if stmtP2NC == nil {
stmtP2NC, err = getDbClient().PrepareStmt(selectPreferredCityNoCountrySQL)
if err != nil {
fmt.Printf("ERROR! Prepare failed: %s, stmt=%v\n", err.Error(), selectPreferredCityNoCountrySQL)
return 0, "", false
}
}
var id int64
var code string
err = stmtP2NC.QueryRow(cityName).Scan(&id, &code)
if err != nil {
if err != sql.ErrNoRows {
// Error
fmt.Printf("ERROR! Query failed: %s, stmt=%v\n", err.Error(), stmtP2NC)
stmtP2NC.Close()
stmtP = nil
}
return 0, "", false
}
return id, code, true
}
func getCityIDFromCityList(cityName, countryCode string) (int64, bool) {
var err error
if stmtC2 == nil {
stmtC2, err = getDbClient().PrepareStmt(selectCityListSQL2)
if err != nil {
fmt.Printf("ERROR! Prepare failed: %s, stmt=%v\n", err.Error(), selectCityListSQL2)
return 0, false
}
}
var id int64
err = stmtC2.QueryRow(cityName, countryCode).Scan(&id)
if err != nil {
if err != sql.ErrNoRows {
// Error
fmt.Printf("ERROR! Query failed: %s, stmt=%v\n", err.Error(), stmtC2)
stmtC2.Close()
stmtC2 = nil
}
return 0, false
}
return id, true
}
func getCityIDFromCityListNoCountry(cityName string) (int64, string, bool) {
var err error
if stmtC2NC == nil {
stmtC2NC, err = getDbClient().PrepareStmt(selectCityListNoCountrySQL)
if err != nil {
fmt.Printf("ERROR! Prepare failed: %s, stmt=%v\n", err.Error(), selectCityListNoCountrySQL)
return 0, "", false
}
}
var id int64
var code string
err = stmtC2NC.QueryRow(cityName).Scan(&id, &code)
if err != nil {
if err != sql.ErrNoRows {
// Error
fmt.Printf("ERROR! Query failed: %s, stmt=%v\n", err.Error(), stmtC2NC)
stmtC2NC.Close()
stmtC2NC = nil
}
return 0, "", false
}
return id, code, true
}
// Do not need to return countryCode?
func GetCityID(city *model.CityInfo) (int64, string, bool) {
if city.CountryCode != "" {
// By cityName and countryCode
id, found := GetCityIDFromPreferredCity(city.CityNameEN, city.CountryCode)
if found {
return id, city.CountryCode, true
}
id, found = getCityIDFromCityList(city.CityNameEN, city.CountryCode)
if found {
return id, city.CountryCode, true
}
} else {
// By cityName only
id, code, found := GetCityIDFromPreferredCityNoCountry(city.CityNameEN)
if found {
return id, code, true
}
id, code, found = getCityIDFromCityListNoCountry(city.CityNameEN)
if found {
return id, code, true
}
}
return 0, "", false
}
// RemoveShiFromJPCities removes '-shi' from names of JP cities.
// It is easier to match city names without it.
func RemoveShiFromJPCities() (count int64, err error) {
dbc := getDbClient()
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered in RemoveShiFromJPCities()!", r)
dbc.RollbackTx()
count = 0
err = errors.New("unexpected error")
}
}()
err = dbc.BeginTx()
if err != nil {
return handleTxError(err, dbc)
}
result, err := dbc.ExecTx(removeShiSQL)
if err != nil {
return handleTxError(err, dbc)
}
count, _ = result.RowsAffected()
err = dbc.CommitTx()
if err != nil {
return handleTxError(err, dbc)
}
return count, nil
}
func handleTxError(err error, dbc *TritonDbClient) (int64, error) {
fmt.Printf("Error occurred during transaction: %s\n", err.Error())
dbc.RollbackTx()
return 0, err
}
|
package bot
import(
"os"
"sync"
api "gopkg.in/telegram-bot-api.v4"
"github.com/deepdeeppink/tgbot/errs"
"github.com/deepdeeppink/tgbot/users"
"github.com/deepdeeppink/tgbot/cfg"
)
const (
BC_CONFIRM = "Отправить"
BC_DECLINE = "Отмена"
)
var (
E = errs.E()
userlist = users.Get()
config = cfg.GetConfig()
token = os.Getenv("TGBTOKEN")
instance *Bot
once sync.Once
kbd = api.ReplyKeyboardMarkup{
OneTimeKeyboard: false,
ResizeKeyboard: true,
Keyboard: [][]api.KeyboardButton{
[]api.KeyboardButton{
api.KeyboardButton{Text: "ПИК"},
api.KeyboardButton{Text: "Мортон"},
api.KeyboardButton{Text: "Все"},
},
},
}
yesno = api.ReplyKeyboardMarkup{
OneTimeKeyboard: true,
ResizeKeyboard: true,
Keyboard: [][]api.KeyboardButton{
[]api.KeyboardButton{
api.KeyboardButton{Text: BC_CONFIRM},
api.KeyboardButton{Text: BC_DECLINE},
},
},
}
)
type Msg struct {
ChatId int64
MessageId int
UserId int
}
type Bot struct {
api.BotAPI
}
func U() <-chan api.Update {
u := api.NewUpdate(0)
u.Timeout = config.BotPoolTimeout
updchan, err := instance.GetUpdatesChan(u); E <- err
return updchan
}
func Get() *Bot {
once.Do(func() {
instance = newBot()
instance.Debug = false
})
return instance
}
func newBot() *Bot {
bot, err := api.NewBotAPI(token); E <- err
return &Bot{*bot}
}
func GetMsg(Message *api.Message) *Msg {
return &Msg{
ChatId: Message.Chat.ID,
MessageId: Message.MessageID,
UserId: Message.From.ID,
}
}
func Broadcast(text string, lvl users.Level) {
for uid, l := range *userlist {
if l > lvl {
continue
}
pkg := api.NewMessage(uid, text)
pkg.ParseMode = "Markdown"
pkg.DisableNotification = false
pkg.ReplyMarkup = kbd
_, err := instance.Send(pkg); E <- err
}
}
func (m *Msg) ReplNoKb(text string) *Msg{
pkg := api.NewMessage(int64(m.UserId), text)
pkg.ParseMode = "Markdown"
pkg.DisableNotification = false
pkg.ReplyToMessageID = m.MessageId
sent, err := instance.Send(pkg); E <- err
return &Msg{
ChatId: m.ChatId,
MessageId: sent.MessageID,
UserId: m.UserId,
}
}
func (m *Msg) Repl(text string) *Msg{
pkg := api.NewMessage(int64(m.UserId), text)
pkg.ParseMode = "Markdown"
pkg.DisableNotification = false
pkg.ReplyToMessageID = m.MessageId
pkg.ReplyMarkup = kbd
sent, err := instance.Send(pkg); E <- err
return &Msg{
ChatId: m.ChatId,
MessageId: sent.MessageID,
UserId: m.UserId,
}
}
// TODO: По какой-то причине это не работает
func (m *Msg) Update(text string) {
ec := api.NewEditMessageText(m.ChatId, m.MessageId, text)
ec.ParseMode = "Markdown"
// ec.ReplyMarkup = kbd
_, err := instance.Send(ec); E <- err
}
func (m *Msg) ReplFile(path string) {
pkg := api.NewDocumentUpload(m.ChatId, path)
pkg.DisableNotification = true
pkg.ReplyToMessageID = m.MessageId
_, err := instance.Send(pkg); E <- err
}
func (m *Msg) Confirm(text string) {
pkg := api.NewMessage(int64(m.UserId), text)
pkg.ParseMode = "Markdown"
pkg.DisableNotification = false
pkg.ReplyMarkup = yesno
_, err := instance.Send(pkg); E <- err
}
|
package main
import (
"net/http"
"log"
"github.com/99designs/gqlgen/handler"
"github.com/go-chi/chi"
grap "github.com/siulfe/gql"
DDBB "github.com/siulfe/gql/Database"
)
const defaultPort = "8080"
func main() {
resp,err := DDBB.LeerArchivo()
log.Println("Respuesta: ",resp)
if err != nil{
panic(err)
}
port := resp["port"]
if port == "" {
port = defaultPort
}
err = DDBB.ConnectDatabase(resp)
if err != nil{
panic(err)
}
router := chi.NewRouter()
router.Use(grap.Middleware())
router.Handle("/", handler.Playground("GraphQL playground", "/query"))
router.Handle("/query", handler.GraphQL(grap.NewExecutableSchema(grap.Config{Resolvers: &grap.Resolver{}})))
log.Printf("connect to http://localhost:%s/ for GraphQL playground", port)
log.Fatal(http.ListenAndServe(":"+port, router))
go grap.DesLoged()
}
|
package health
import (
"context"
"time"
"github.com/jmoiron/sqlx"
"github.com/movieManagement/gen/models"
"github.com/movieManagement/gen/restapi/operations/health"
)
// Service handles async log of audit event
type Service interface {
HealthCheck(ctx context.Context, in *health.GetHealthParams) (*models.Health, error)
}
type service struct {
hcdb *sqlx.DB
gitHash string
buildStamp string
}
// New is a simple helper function to create a service instance
func New(hcdb *sqlx.DB, GitHash, BuildStamp string) Service {
return &service{
hcdb: hcdb,
gitHash: GitHash,
buildStamp: BuildStamp,
}
}
func dbCheck(db *sqlx.DB) error {
//var pong string
//return db.Get(&pong, "select 'pong'")
return nil
}
func (s service) HealthCheck(ctx context.Context, in *health.GetHealthParams) (*models.Health, error) {
t := time.Now()
dbErr := dbCheck(s.hcdb)
duration := time.Since(t)
hs := models.HealthStatus{TimeStamp: time.Now().String(), Healthy: true, Name: "HCDB", Duration: duration.String()}
if dbErr != nil {
hs.Healthy = false
hs.Error = dbErr.Error()
}
response := models.Health{
Status: "healthy",
TimeStamp: time.Now().String(),
Githash: s.gitHash,
BuildTimeStamp: s.buildStamp,
Healths: []*models.HealthStatus{&hs}}
return &response, nil
}
|
package fare
import (
"context"
"github.com/stamm/wheely/apis/distance/types"
faretypes "github.com/stamm/wheely/apis/fare/types"
)
type IFareService interface {
Calculate(ctx context.Context, start, end types.Point) (faretypes.Result, error)
}
|
package main
import "fmt"
import "math/rand"
import "time"
import "sync/atomic"
func main() {
thread_count := 4
var in int64 = 0
var total int64 = 0
lim := 2147483647
seed := rand.NewSource(time.Now().UnixNano())
random := rand.New(seed)
ch := make(chan int)
for i := 0; i < thread_count; i++{
go func(){
ch <- 1
for i := 0; i < lim/thread_count; i++ {
x := random.Float64()
y := random.Float64()
if x*x + y*y <= 1 {
atomic.AddInt64(&in, 1)
}
atomic.AddInt64(&total, 1)
}
}()
}
for i := 0; i < thread_count; i++{
<-ch
}
countf := float64(in)
totalf := float64(total)
pi := (4.0 * countf/totalf)
fmt.Println(pi)
}
|
package util
import (
"fmt"
"math/rand"
"time"
)
func init() {
rand.Seed(time.Now().UnixNano())
}
func GenerateID() string {
hi := rand.Uint64()
lo := rand.Uint32()
return fmt.Sprintf("%x%x", hi, lo)
}
|
package firewall
import (
"testing"
. "github.com/smartystreets/goconvey/convey"
)
func Test_iptablesCommand(t *testing.T) {
successCmd := func() *MockExecer {
e := &MockExecer{}
e.On("Exec").Return([]byte("output"), nil)
return e
}
Convey("Given an iptablesCommand", t, func() {
execFactory := &MockExecFactory{}
ic := &iptablesCommand{
ExecFactory: execFactory,
}
Convey("When prepending a rule", func() {
cmd := successCmd()
execFactory.On(
"NewCmd",
"/sbin/iptables",
[]string{"-I", "Firewall-INPUT", "1", "-m", "conntrack", "--ctstate", "NEW", "-p", "tcp", "--dport", "80", "-j", "ACCEPT"},
).Return(cmd)
err := ic.PrependRule(80)
Convey("Then it adds the rule without an error", func() {
So(err, ShouldBeNil)
cmd.AssertExpectations(t)
})
})
Convey("When removing a rule", func() {
cmd := successCmd()
execFactory.On(
"NewCmd",
"/sbin/iptables",
[]string{"-D", "Firewall-INPUT", "1"},
).Return(cmd)
err := ic.RemoveRule(1)
Convey("Then it removes the rule without an error", func() {
So(err, ShouldBeNil)
cmd.AssertExpectations(t)
})
})
Convey("When listing rules", func() {
cmd := successCmd()
execFactory.On(
"NewCmd",
"/sbin/iptables",
[]string{"-nL", "Firewall-INPUT", "--line-numbers"},
).Return(cmd)
output, err := ic.ListRules()
Convey("It returns no error", func() {
So(err, ShouldBeNil)
})
Convey("It returns the command output", func() {
So(string(output), ShouldResemble, "output")
})
})
})
}
func TestLiveExecer(t *testing.T) {
Convey("Given a LiveExecFactory", t, func() {
factory := &LiveExecFactory{}
Convey("When creating a command", func() {
cmd := factory.NewCmd("id")
output, err := cmd.Exec()
Convey("It returns no error", func() {
So(err, ShouldBeNil)
})
Convey("It returns the command output", func() {
So(string(output), ShouldStartWith, "uid=")
})
})
})
}
|
// Copyright 2017 Vector Creations Ltd
//
// 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 writers
import (
"net/http"
"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
"github.com/matrix-org/dendrite/clientapi/auth/storage/accounts"
"github.com/matrix-org/dendrite/clientapi/events"
"github.com/matrix-org/dendrite/clientapi/httputil"
"github.com/matrix-org/dendrite/clientapi/jsonerror"
"github.com/matrix-org/dendrite/clientapi/producers"
"github.com/matrix-org/dendrite/common"
"github.com/matrix-org/dendrite/common/config"
"github.com/matrix-org/dendrite/roomserver/api"
"github.com/matrix-org/gomatrixserverlib"
"github.com/matrix-org/util"
)
// SendMembership implements PUT /rooms/{roomID}/(join|kick|ban|unban|leave|invite)
// by building a m.room.member event then sending it to the room server
func SendMembership(
req *http.Request, accountDB *accounts.Database, device *authtypes.Device,
roomID string, membership string, cfg config.Dendrite,
queryAPI api.RoomserverQueryAPI, producer *producers.RoomserverProducer,
) util.JSONResponse {
stateKey, reason, reqErr := getMembershipStateKey(req, device, membership)
if reqErr != nil {
return *reqErr
}
localpart, serverName, err := gomatrixserverlib.SplitID('@', stateKey)
if err != nil {
return httputil.LogThenError(req, err)
}
var profile *authtypes.Profile
if serverName == cfg.Matrix.ServerName {
profile, err = accountDB.GetProfileByLocalpart(localpart)
if err != nil {
return httputil.LogThenError(req, err)
}
} else {
profile = &authtypes.Profile{}
}
builder := gomatrixserverlib.EventBuilder{
Sender: device.UserID,
RoomID: roomID,
Type: "m.room.member",
StateKey: &stateKey,
}
// "unban" or "kick" isn't a valid membership value, change it to "leave"
if membership == "unban" || membership == "kick" {
membership = "leave"
}
content := common.MemberContent{
Membership: membership,
DisplayName: profile.DisplayName,
AvatarURL: profile.AvatarURL,
Reason: reason,
}
if err = builder.SetContent(content); err != nil {
return httputil.LogThenError(req, err)
}
event, err := events.BuildEvent(&builder, cfg, queryAPI, nil)
if err == events.ErrRoomNoExists {
return util.JSONResponse{
Code: 404,
JSON: jsonerror.NotFound(err.Error()),
}
} else if err != nil {
return httputil.LogThenError(req, err)
}
if err := producer.SendEvents([]gomatrixserverlib.Event{*event}, cfg.Matrix.ServerName); err != nil {
return httputil.LogThenError(req, err)
}
return util.JSONResponse{
Code: 200,
JSON: struct{}{},
}
}
// getMembershipStateKey extracts the target user ID of a membership change.
// For "join" and "leave" this will be the ID of the user making the change.
// For "ban", "unban", "kick" and "invite" the target user ID will be in the JSON request body.
// In the latter case, if there was an issue retrieving the user ID from the request body,
// returns a JSONResponse with a corresponding error code and message.
func getMembershipStateKey(
req *http.Request, device *authtypes.Device, membership string,
) (stateKey string, reason string, response *util.JSONResponse) {
if membership == "ban" || membership == "unban" || membership == "kick" || membership == "invite" {
// If we're in this case, the state key is contained in the request body,
// possibly along with a reason (for "kick" and "ban") so we need to parse
// it
var requestBody struct {
UserID string `json:"user_id"`
Reason string `json:"reason"`
}
if reqErr := httputil.UnmarshalJSONRequest(req, &requestBody); reqErr != nil {
response = reqErr
return
}
if requestBody.UserID == "" {
response = &util.JSONResponse{
Code: 400,
JSON: jsonerror.BadJSON("'user_id' must be supplied."),
}
return
}
stateKey = requestBody.UserID
reason = requestBody.Reason
} else {
stateKey = device.UserID
}
return
}
|
package factoryreset
import (
"os"
"path/filepath"
"github.com/rancher-sandbox/rancher-desktop/src/go/rdctl/pkg/autostart"
"github.com/rancher-sandbox/rancher-desktop/src/go/rdctl/pkg/paths"
"github.com/sirupsen/logrus"
)
func DeleteData(paths paths.Paths, removeKubernetesCache bool) error {
if err := autostart.EnsureAutostart(false); err != nil {
logrus.Errorf("Failed to remove autostart configuration: %s", err)
}
homeDir, err := os.UserHomeDir()
if err != nil {
logrus.Errorf("Error getting home directory: %s", err)
}
pathList := []string{
paths.AltAppHome,
paths.Config,
paths.Logs,
filepath.Join(homeDir, ".local", "state", "rancher-desktop"),
}
// Electron stores things in ~/.config/Rancher Desktop. This is difficult
// to change. We should still clean up the directory on factory reset.
configPath, err := os.UserConfigDir()
if err != nil {
logrus.Errorf("Error getting config directory: %s", err)
} else {
pathList = append(pathList, filepath.Join(configPath, "Rancher Desktop"))
}
if removeKubernetesCache {
pathList = append(pathList, paths.Cache)
} else {
pathList = append(pathList, filepath.Join(paths.Cache, "updater-longhorn.json"))
}
appHomeDirs := addAppHomeWithoutSnapshots(filepath.Dir(paths.Lima))
pathList = append(pathList, appHomeDirs...)
return deleteUnixLikeData(paths, pathList)
}
|
package Problem0115
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
func Test_Problem0115(t *testing.T) {
ast := assert.New(t)
// tcs is testcase slice
tcs := []struct {
s string
t string
ans int
}{
{
"aaaaaa",
"",
1,
},
{
"aaaaaa",
"aa",
15,
},
{
"bbb",
"bb",
3,
},
{
"abbabc",
"abc",
4,
},
{
"abbabcc",
"abc",
8,
},
{
"abcabcabc",
"abc",
10,
},
{
"adbdadeecadeadeccaeaabdabdbcdabddddabcaaadbabaaedeeddeaeebcdeabcaaaeeaeeabcddcebddebeebedaecccbdcbcedbdaeaedcdebeecdaaedaacadbdccabddaddacdddc",
"bcddceeeebecbc",
700531452,
},
{
"",
"a",
0,
},
{
"rabbbit",
"rabbit",
3,
},
// 可以多个 testcase
}
for _, tc := range tcs {
fmt.Printf("~~%v~~\n", tc)
ast.Equal(tc.ans, numDistinct(tc.s, tc.t), "输入:%v", tc)
}
}
|
package main
import (
"finrgo/exhanges"
"finrgo/exhanges/bittrex"
"finrgo/exhanges/polo"
"fmt"
"github.com/davecgh/go-spew/spew"
)
const (
BittrexExchange string = "bittrex"
PoloniexExchange string = "poloniex"
)
func main() {
exchanges := exhanges.InitExhanges()
exchanges.AddExhange(BittrexExchange, &bittrex.Bittrex{})
exchanges.AddExhange(PoloniexExchange, &polo.Poloniex{})
//bittrexVal := exchanges.GetInstanceExchange(BittrexExchange)
//balBit, err := bittrexVal.GetBalance()
//if err != nil {
// spew.Dump(balBit)
//} else {
// spew.Dump(err)
//}
poloniexVal := exchanges.GetInstanceExchange(PoloniexExchange)
balPolo, err := poloniexVal.GetBalance()
if err != nil {
fmt.Println(balPolo)
return
}
fmt.Println("ERR:", err)
}
func zero() {
spew.Dump(1)
}
|
package philifence
type PolyRing struct {
Coordinates []Coordinate
Box Box
}
func MakePolyRing(length int) *PolyRing {
return &PolyRing{
Coordinates: make([]Coordinate, length),
}
}
func NewPolyRing(coords ...Coordinate) *PolyRing {
return &PolyRing{
Coordinates: coords,
}
}
func (pr *PolyRing) Len() int {
return len(pr.Coordinates)
}
func (pr *PolyRing) Add(c ...Coordinate) {
pr.Coordinates = append(pr.Coordinates, c...)
}
func (pr *PolyRing) reverse() {
for i, j := 0, len(pr.Coordinates)-1; i < j; i, j = i+1, j-1 {
pr.Coordinates[i], pr.Coordinates[j] = pr.Coordinates[j], pr.Coordinates[i]
}
}
// we'll stick to winding number algorithm
func (pr *PolyRing) Contains(c Coordinate) bool {
return pr.computeWindingNumber(c) != 0
}
// Raycast shows an implementation of the ray casting point-in-polygon
// (PNPoly) algorithm for testing if a point is inside a closed polygon.
// Also known as the crossing number or the even-odd rule algorithm.
//
// https://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
func (pr *PolyRing) inside(pt Coordinate) bool {
if len(pr.Coordinates) < 3 {
return false
}
in := rayIntersectsSegment(pt, pr.Coordinates[len(pr.Coordinates)-1], pr.Coordinates[0])
for i := 1; i < len(pr.Coordinates); i++ {
if rayIntersectsSegment(pt, pr.Coordinates[i-1], pr.Coordinates[i]) {
in = !in
}
}
return in
}
func rayIntersectsSegment(p, a, b Coordinate) bool {
return (a.lat > p.lat) != (b.lat > p.lat) &&
p.lon < (b.lon-a.lon)*(p.lat-a.lat)/(b.lat-a.lat)+a.lon
}
// The Winding Number method which counts the number of times the polygon winds around the point P.
// The point is outside only when this "winding number" wn = 0; otherwise, the point is inside.
//
// http://geomalgorithms.com/a03-_inclusion.html
func (pr *PolyRing) computeWindingNumber(q Coordinate) (wn int) {
for i := range pr.Coordinates[:pr.Len()-1] {
if pr.Coordinates[i].lat <= q.lat {
if pr.Coordinates[i+1].lat > q.lat {
if isLeft(pr.Coordinates[i], pr.Coordinates[i+1], q) > 0 {
wn++
}
}
} else {
if pr.Coordinates[i+1].lat <= q.lat {
if isLeft(pr.Coordinates[i], pr.Coordinates[i+1], q) < 0 {
wn--
}
}
}
}
return
}
func isLeft(h, t, q Coordinate) float64 {
return ((t.lon - h.lon) * (q.lat - h.lat)) - ((q.lon - h.lon) * (t.lat - h.lat))
}
func (pr *PolyRing) computeBox() Box {
var min, max Coordinate
for i := 0; i < len(pr.Coordinates); i++ {
if i == 0 {
min, max = pr.Coordinates[0], pr.Coordinates[0]
} else {
c := pr.Coordinates[i]
if c.lat < min.lat {
min.lat = c.lat
}
if c.lat > max.lat {
max.lat = c.lat
}
if c.lon < min.lon {
min.lon = c.lon
}
if c.lon > max.lon {
max.lon = c.lon
}
}
}
box, err := NewBox(min, max)
check(err)
return box
}
func (pr *PolyRing) isClockwise() bool {
coords := pr.Coordinates
sum := 0.0
for i, coord := range coords[:len(coords)-1] {
next := coords[i+1]
sum += (next.lon - coord.lon) * (next.lat + coord.lat)
}
return sum >= 0
}
type Polygon struct {
Exterior *PolyRing
Holes []*PolyRing
}
func MakePoly(length int) *Polygon {
return &Polygon{Exterior: MakePolyRing(length)}
}
func NewPoly(coords ...Coordinate) *Polygon {
return &Polygon{Exterior: NewPolyRing(coords...)}
}
func (poly *Polygon) Add(c ...Coordinate) {
poly.Exterior.Add(c...)
}
func (poly *Polygon) Contains(c Coordinate) (ok bool) {
ok = poly.Exterior.computeWindingNumber(c) != 0
if ok {
for _, hole := range poly.Holes {
if hole.computeWindingNumber(c) != 0 {
ok = false
break
}
}
}
return
}
func (poly *Polygon) Len() int {
return poly.Exterior.Len()
}
func (poly *Polygon) computeBox() Box {
return poly.Exterior.computeBox()
}
// rectangle wrapper for polygon
type Box struct {
min, max Coordinate
}
func NewBox(min, max Coordinate) (box Box, err error) {
if min.lat > max.lat || min.lon > max.lon {
err = errorf("Min %v > Max %v", min, max)
return
}
box = Box{min: min, max: max}
return
} |
package yadisk
import (
"net/http"
"net/url"
"strconv"
"strings"
)
// Get meta-information about a public file or directory.
func (yad *yandexDisk) GetPublicResource(publicKey string, fields []string, limit int, offset int, path string, previewCrop bool, previewSize string, sort string) (r *PublicResource, e error) {
values := url.Values{}
values.Add("public_key", publicKey)
values.Add("fields", strings.Join(fields, ","))
values.Add("limit", strconv.Itoa(limit))
values.Add("offset", strconv.Itoa(offset))
values.Add("path", path)
values.Add("preview_crop", strconv.FormatBool(previewCrop))
values.Add("preview_size", previewSize)
values.Add("sort", sort)
req, e := yad.client.request(http.MethodGet, "/disk/public/resources?"+values.Encode(), nil)
if e != nil {
return nil, e
}
r = new(PublicResource)
_, e = yad.client.getResponse(req, &r)
if e != nil {
return nil, e
}
return
}
// Get a link to download a public resource.
func (yad *yandexDisk) GetPublicResourceDownloadLink(publicKey string, fields []string, path string) (l *Link, e error) {
values := url.Values{}
values.Add("public_key", publicKey)
values.Add("fields", strings.Join(fields, ","))
values.Add("path", path)
req, e := yad.client.request(http.MethodGet, "/disk/public/resources/download?"+values.Encode(), nil)
if e != nil {
return nil, e
}
l = new(Link)
_, e = yad.client.getResponse(req, &l)
if e != nil {
return nil, e
}
return
}
// Save the public resource to the Downloads folder.
//
// If saving occurs asynchronously, it will return a response with code 202 and a link to the asynchronous operation.
// Otherwise, it will return a response with code 201 and a link to the created resource.
func (yad *yandexDisk) SaveToDiskPublicResource(publicKey string, fields []string, forceAsync bool, name string, path string, savePath string) (l *Link, e error) {
values := url.Values{}
values.Add("public_key", publicKey)
values.Add("fields", strings.Join(fields, ","))
values.Add("force_async", strconv.FormatBool(forceAsync))
values.Add("name", name)
values.Add("path", path)
values.Add("save_path", savePath)
req, e := yad.client.request(http.MethodPost, "/disk/public/resources/save-to-disk?"+values.Encode(), nil)
if e != nil {
return nil, e
}
l = new(Link)
_, e = yad.client.getResponse(req, &l)
if e != nil {
return nil, e
}
return
}
|
package installer
import (
"airdb/helpers"
"fmt"
"os"
)
func serverInstaller() {
fmt.Println("Configuring airdb server using supervisor.d ....")
fmt.Print("Enter your desired server port where airdb is going to run: ")
var port string
_, err := fmt.Scanf("%s\n", &port)
if err != nil {
fmt.Println("Error " + err.Error())
os.Exit(103)
}
err = helpers.Setenv("port", port)
if err != nil {
fmt.Println("Exception occured while setting server port error " + err.Error())
os.Exit(103)
}
if port == "" {
fmt.Println("Enter a valid server port ")
os.Exit(103)
}
fmt.Print("Enter supervisorctl conf path:")
var confPath string
_, err = fmt.Scanf("%s\n", &confPath)
if err != nil {
fmt.Println("Error capturing conf path" + err.Error())
os.Exit(103)
}
if confPath == "" {
fmt.Println("Enter supervisorctl conf path to continue.")
os.Exit(103)
}
c := confPath[len(confPath)-1:]
if c == "/" {
confPath = confPath[:len(confPath)-1]
}
path := confPath + "/airdb.conf"
err = createConfFile(path)
if err != nil {
fmt.Println("Failed to create and write supervisorctl conf file error: " + err.Error())
os.Exit(103)
} else {
fmt.Println("Airdb configured successfully")
os.Exit(103)
}
}
func createConfFile(path string) error {
var _, err = os.Stat(path)
if os.IsNotExist(err) {
var file, err = os.Create(path)
if err != nil {
return err
}
err = writeConfiguration(path)
if err != nil {
fmt.Println("Failed to write configuration in conf file error: " + err.Error())
os.Exit(103)
}
defer file.Close()
}
return nil
}
func writeConfiguration(path string) error {
appPath, err := os.Getwd()
if err != nil {
return err
}
file, err := os.OpenFile(path, os.O_RDWR, 0644)
if err != nil {
return err
}
defer file.Close()
_, err = file.WriteString("[program:airdb] \ncommand=" + appPath + "/airdb \ndirectory=" + appPath + "\nuser=root \nautostart=true \nautorestart=true \nredirect_stderr=true\n")
if err != nil {
return err
}
err = file.Sync()
if err != nil {
return err
}
return nil
}
|
package main
import (
"flag"
"fmt"
"io/ioutil"
"log"
"os"
"path"
"github.com/russross/blackfriday"
)
func usage() {
fmt.Fprintf(os.Stderr, "Usage: %s [options] input output\n", path.Base(os.Args[0]))
fmt.Fprintf(os.Stderr, "https://foosoft.net/projects/md2vim/\n\n")
fmt.Fprintf(os.Stderr, "Parameters:\n")
flag.PrintDefaults()
}
func main() {
cols := flag.Int("cols", defNumCols, "number of columns to use for layout")
tabs := flag.Int("tabs", defTabSize, "tab width specified in number of spaces")
notoc := flag.Bool("notoc", false, "do not generate table of contents for headings")
norules := flag.Bool("norules", false, "do not generate horizontal rules above headings")
pascal := flag.Bool("pascal", false, "use PascalCase for abbreviating tags")
desc := flag.String("desc", "", "short description of the help file")
flag.Usage = usage
flag.Parse()
args := flag.Args()
if len(args) < 2 {
flag.Usage()
os.Exit(2)
}
input, err := ioutil.ReadFile(args[0])
if err != nil {
log.Fatalf("unable to read from file: %s", args[0])
}
flags := 0
if *notoc {
flags |= flagNoToc
}
if *norules {
flags |= flagNoRules
}
if *pascal {
flags |= flagPascal
}
renderer := VimDocRenderer(args[1], *desc, *cols, *tabs, flags)
extensions := blackfriday.EXTENSION_FENCED_CODE | blackfriday.EXTENSION_NO_INTRA_EMPHASIS | blackfriday.EXTENSION_SPACE_HEADERS
output := blackfriday.Markdown(input, renderer, extensions)
file, err := os.Create(args[1])
if err != nil {
log.Fatalf("unable to write to file: %s", args[1])
}
defer file.Close()
if _, err := file.Write(output); err != nil {
log.Fatal("unable to write output")
}
}
|
// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you 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.
// Code generated from the elasticsearch-specification DO NOT EDIT.
// https://github.com/elastic/elasticsearch-specification/tree/33e8a1c9cad22a5946ac735c4fba31af2da2cec2
package types
import (
"bytes"
"encoding/json"
"errors"
"io"
)
// ExecutionResult type.
//
// https://github.com/elastic/elasticsearch-specification/blob/33e8a1c9cad22a5946ac735c4fba31af2da2cec2/specification/watcher/_types/Execution.ts#L60-L66
type ExecutionResult struct {
Actions []ExecutionResultAction `json:"actions"`
Condition ExecutionResultCondition `json:"condition"`
ExecutionDuration int64 `json:"execution_duration"`
ExecutionTime DateTime `json:"execution_time"`
Input ExecutionResultInput `json:"input"`
}
func (s *ExecutionResult) UnmarshalJSON(data []byte) error {
dec := json.NewDecoder(bytes.NewReader(data))
for {
t, err := dec.Token()
if err != nil {
if errors.Is(err, io.EOF) {
break
}
return err
}
switch t {
case "actions":
if err := dec.Decode(&s.Actions); err != nil {
return err
}
case "condition":
if err := dec.Decode(&s.Condition); err != nil {
return err
}
case "execution_duration":
if err := dec.Decode(&s.ExecutionDuration); err != nil {
return err
}
case "execution_time":
if err := dec.Decode(&s.ExecutionTime); err != nil {
return err
}
case "input":
if err := dec.Decode(&s.Input); err != nil {
return err
}
}
}
return nil
}
// NewExecutionResult returns a ExecutionResult.
func NewExecutionResult() *ExecutionResult {
r := &ExecutionResult{}
return r
}
|
package service
import (
"github.com/ankurs/Feed/Feed/service/store"
)
type Config struct {
Store store.Config
Worker WorkerConfig
}
type WorkerConfig struct {
Host string
Queue string
Username string
Password string
}
|
// Copyright 2018 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.
//go:build linux || darwin || freebsd || unix
package signal
import (
"log"
"os"
"os/signal"
"runtime"
"syscall"
"github.com/pingcap/tidb/util/logutil"
"go.uber.org/zap"
)
// SetupSignalHandler setup signal handler for TiDB Server
func SetupSignalHandler(shutdownFunc func()) {
usrDefSignalChan := make(chan os.Signal, 1)
signal.Notify(usrDefSignalChan, syscall.SIGUSR1)
go func() {
buf := make([]byte, 1<<16)
for {
sig := <-usrDefSignalChan
if sig == syscall.SIGUSR1 {
stackLen := runtime.Stack(buf, true)
log.Printf("\n=== Got signal [%s] to dump goroutine stack. ===\n%s\n=== Finished dumping goroutine stack. ===\n", sig, buf[:stackLen])
}
}
}()
closeSignalChan := make(chan os.Signal, 1)
signal.Notify(closeSignalChan,
syscall.SIGHUP,
syscall.SIGINT,
syscall.SIGTERM,
syscall.SIGQUIT)
go func() {
sig := <-closeSignalChan
logutil.BgLogger().Info("got signal to exit", zap.Stringer("signal", sig))
shutdownFunc()
}()
}
|
package teams
import (
"database/sql"
"errors"
)
type Team struct {
Name string `json:"teamname"`
Count_clicks int `json:"clicks"`
Number_of_members int `json:"member_count"`
}
const tableCreationQuery = `CREATE TABLE IF NOT EXSIST team(
teamname text PRIMARY KEY,
count_game_up_clicks int,
count_game_down_clicks int,
team_members_count int
);
)`
func (team *Team) GetTeam(db *sql.DB) error {
return db.QueryRow("SELECT * FROM team WHERE team_name=$1",
team.Name).Scan(&team.Count_clicks, &team.Number_of_members)
}
func (team *Team) UpdateTeam(db *sql.DB) error {
_, err :=
db.Exec("UPDATE team SET count_game_clicks = $1, team_members_count = $2 WHERE teamname=$3",
team.Count_clicks, team.Number_of_members, team.Name)
return err
}
func (team *Team) DeleteTeam(db *sql.DB) error {
_, err := db.Exec("DELETE FROM team WHERE team_name=$1", team.Name)
return err
}
func (team *Team) CreateTeam(db *sql.DB) error {
_, err := db.Exec(`INSERT INTO team (teamname, count_game_clicks, team_members_count)
VALUES ($1, $2, $3)`,
team.Name, team.Count_clicks, team.Number_of_members)
return err
}
func getTeams(db *sql.DB, start, count int) ([]Team, error) {
return nil, errors.New("Not implemented")
}
func (team *Team) Vote(db *sql.DB, vote string) error {
intVote := 0
if vote == "up" {
intVote = 1
} else {
intVote = -1
}
_, err :=
db.Exec("UPDATE team SET count_game_clicks = count_game_clicks + $1 WHERE teamname=$2",
intVote, team.Name)
return err
}
func (team *Team) AddMember(db *sql.DB) error {
_, err :=
db.Exec("UPDATE team SET team_members_count = team_members_count + $1 WHERE teamname=$2",
1, team.Name)
return err
}
func ClearTeams(db *sql.DB) error {
_, err := db.Exec("DELETE FROM team")
return err
}
|
package dbops
import (
"XianZhi/clog"
"fmt"
"testing"
)
func TestMain(m *testing.M) {
_ = clog.InitLogger("console",clog.Config{Log_level:"debug"})
//clearTables()
m.Run()
//clearTables ()
}
func clearTables() {
//清除数据库数据
//_,_ = dbConn.Exec("truncate table")
}
func TestRun(t *testing.T) {
t.Run("SelectAllCategory",testSelectAllCategory)
t.Run("SelectIndexGoods",testSelectIndexGoods)
t.Run("SelectCategoryGoods",testSelectCategoryGoods)
t.Run("SelectGoodsInfo",testSelectGoodsInfo)
t.Run("SelectHavebuyGoodsList",testSelectHavebuyGoodsList)
t.Run("SelectWantbuyGoodsList",testSelectWantbuyGoodsList)
t.Run("SelectPubGoodsList",testSelectPubGoodsList)
t.Run("SelectSoldGoodsList",testSelectSoldGoodsList)
t.Run("SelectActiveGoodsList",testSelectActiveGoodsList)
}
func testSelectAllCategory(t *testing.T) {
res,err := SelectAllCategory()
if err != nil {
t.Errorf("select category error ,err:%#v",err)
}
fmt.Printf("categorylist:%#v",res)
}
func testSelectIndexGoods(t *testing.T) {
res,err := SelectIndexGoods(10)
if err != nil {
t.Errorf("select category error ,err:%#v",err)
}
fmt.Printf("categorylist:%#v",res)
}
func testSelectCategoryGoods(t *testing.T) {
res,err := SelectCategoryGoods(10,10)
if err != nil {
t.Errorf("select category error ,err:%#v",err)
}
fmt.Printf("categorylist:%#v",res)
}
func testSelectGoodsInfo(t *testing.T) {
res,err := SelectGoodsInfo(10,18)
if err != nil {
t.Errorf("select goods info error,err:%v",err)
}
fmt.Printf("goods info:%#v",res)
}
func testSelectHavebuyGoodsList(t *testing.T) {
res,err := SelectHavebuyGoodsList(587,0)
if err != nil {
t.Errorf("select goods info error,err:%v",err)
}
fmt.Printf("goods info:%#v",res)
}
func testSelectWantbuyGoodsList(t *testing.T) {
res,err := SelectWantbuyGoodsList(775,1)
if err != nil {
t.Errorf("select wantbuy failed,err:%v",err)
}
fmt.Printf("goodsList:%#v",res)
}
func testSelectPubGoodsList(t *testing.T) {
res,err := SelectPubGoodsList(0,1)
if err != nil {
t.Errorf("select pubGoods failed,err:%v",err)
}
fmt.Printf("goodsList:%#v",res)
}
func testSelectSoldGoodsList(t *testing.T) {
res,err := SelectSoldGoodsList(2,1)
if err != nil {
t.Errorf("select soldGoods failed,err:%v",err)
}
fmt.Printf("goodsList:%#v",res)
}
func testSelectActiveGoodsList(t *testing.T) {
res,err := SelectActiveGoodsList("gd",0)
if err != nil {
t.Errorf("select activeGoods failed,err:%v",err)
}
fmt.Printf("goodsList:%#v",res)
} |
package bucket
import (
"context"
"io/ioutil"
"os"
"strings"
"testing"
"time"
"github.com/fishy/fsdb"
)
func TestMock(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode")
}
ctx := context.Background()
delay := time.Millisecond * 50
total := delay * 2
shorter := time.Millisecond * 30
longer := time.Millisecond * 60
key := "foo"
data := "bar"
mockDelay := MockOperationDelay{
Before: delay,
After: delay,
}
root, err := ioutil.TempDir("", "bucket_")
if err != nil {
t.Fatalf("failed to get tmp dir: %v", err)
}
defer os.RemoveAll(root)
mock := MockBucket(root)
db := mock.db
mock.WriteDelay = mockDelay
mock.DeleteDelay = mockDelay
// Make sure it's empty
keys := scanKeys(t, db)
if len(keys) > 0 {
t.Fatalf("mock fsdb not empty: %v", keys)
}
// Write test
started := time.Now()
go func() {
time.Sleep(shorter)
keys := scanKeys(t, db)
if len(keys) > 0 {
t.Errorf(
"write operation should delay %v, but already got data after %v: %v",
delay,
time.Now().Sub(started),
keys,
)
}
}()
go func() {
time.Sleep(longer)
keys := scanKeys(t, db)
if len(keys) != 1 || !keys[0].Equals(fsdb.Key(key)) {
t.Errorf(
"write operation should finished after %v, expected key %v, got %v",
time.Now().Sub(started),
key,
keys,
)
}
}()
if err := mock.Write(ctx, key, strings.NewReader(data)); err != nil {
t.Errorf("write failed: %v", err)
}
elapsed := time.Now().Sub(started)
if elapsed <= total {
t.Errorf(
"write function should return after %v, actual time %v",
total,
elapsed,
)
}
// Delete test
started = time.Now()
go func() {
time.Sleep(shorter)
keys := scanKeys(t, db)
if len(keys) != 1 || !keys[0].Equals(fsdb.Key(key)) {
t.Errorf(
"delete operation should delay %v, but got %v after %v, expected %v",
delay,
keys,
time.Now().Sub(started),
key,
)
}
}()
go func() {
time.Sleep(longer)
keys := scanKeys(t, db)
if len(keys) > 0 {
t.Errorf(
"delete operation should finished after %v, but got keys %v",
time.Now().Sub(started),
keys,
)
}
}()
if err := mock.Delete(ctx, key); err != nil {
t.Errorf("delete failed: %v", err)
}
elapsed = time.Now().Sub(started)
if elapsed <= total {
t.Errorf(
"delete function should return after %v, actual time %v",
total,
elapsed,
)
}
}
func TestTotal(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode")
}
ctx := context.Background()
total := time.Millisecond * 50
shorter := time.Millisecond * 30
key := "foo"
data := "bar"
root, err := ioutil.TempDir("", "bucket_")
if err != nil {
t.Fatalf("failed to get tmp dir: %v", err)
}
defer os.RemoveAll(root)
mock := MockBucket(root)
db := mock.db
mock.WriteDelay = MockOperationDelay{
Before: shorter,
Total: total,
}
mock.ReadDelay = MockOperationDelay{
Before: shorter,
After: shorter,
Total: total,
}
// Make sure it's empty
keys := scanKeys(t, db)
if len(keys) > 0 {
t.Fatalf("mock fsdb not empty: %v", keys)
}
// Write test
started := time.Now()
if err := mock.Write(ctx, key, strings.NewReader(data)); err != nil {
t.Errorf("write failed: %v", err)
}
elapsed := time.Now().Sub(started)
if elapsed <= total {
t.Errorf(
"write function should return after %v, actual time %v",
total,
elapsed,
)
}
// Delete test
started = time.Now()
closer, err := mock.Read(ctx, key)
if err != nil {
t.Fatalf("read failed: %v", err)
}
defer closer.Close()
elapsed = time.Now().Sub(started)
if elapsed <= total {
t.Errorf(
"delete function should return after %v, actual time %v",
total,
elapsed,
)
}
if elapsed <= shorter*2 {
t.Errorf(
"delete function should return after %v, actual time %v",
shorter*2,
elapsed,
)
}
}
func scanKeys(t *testing.T, db fsdb.Local) []fsdb.Key {
t.Helper()
ctx := context.Background()
keys := make([]fsdb.Key, 0)
keyFunc := func(key fsdb.Key) bool {
keys = append(keys, key)
return true
}
if err := db.ScanKeys(ctx, keyFunc, fsdb.IgnoreAll); err != nil {
t.Fatalf("ScanKeys returned error: %v", err)
}
return keys
}
|
package syncInterface
import (
syncComm "github.com/HNB-ECO/HNB-Blockchain/HNB/sync/common"
)
type SyncServiceInf interface {
SyncToTarget(chainID string, beginCursor uint64, endCursor uint64, peerId uint64, isBlocked bool, version uint32, ntyCunc syncComm.NotifyFunc) error
GetSyncState(chainID string) (uint8, error)
GetSyncInfo(chainID string) (*syncComm.SyncInfo, error)
SyncExit(chainID string) error
}
|
package machine
import (
"fmt"
"math/rand"
"os"
"testing"
"time"
"github.com/google/go-cmp/cmp"
)
// TestRead reads several config files and verifies the output.
func TestRead(t *testing.T) {
const correctCount = 3
const incorrectCount = 7
for i := 1; i <= correctCount; i++ {
_, err := Read(fmt.Sprintf("../../test-data/config-%d.json", i))
if err != nil {
t.Errorf("correct %d: produced error %w", i, err)
}
}
for i := 1; i <= incorrectCount; i++ {
_, err := Read(fmt.Sprintf("../../test-data/wrong-config-%d.json", i))
if err == nil {
t.Errorf("incorrect %d: didn't produce error", i)
}
}
}
// TestWrite tests writing a machine to a file.
func TestWrite(t *testing.T) {
rand.Seed(time.Now().UnixNano())
err := os.MkdirAll("../../test-data/generate", os.ModePerm)
if err != nil {
t.Fatal("failed to create test-data/generate")
}
for i := 0; i < 10; i++ {
count := rand.Intn(100) + 3
err := Write(Generate(count), "../../test-data/generate/generated.json")
if err != nil {
t.Errorf("test %d: failed to write: %w", i, err)
}
_, err = os.Open("../../test-data/generate/generated.json")
if err != nil {
t.Errorf("test %d: written machine doesn't exist", i)
}
}
}
// TestReadAndWrite tests Read and Write by generating a machine, writing it
// to a file, reading the file, and comparing written and read.
func TestReadAndWrite(t *testing.T) {
rand.Seed(time.Now().UnixNano())
err := os.MkdirAll("../../test-data/generate", os.ModePerm)
if err != nil {
t.Fatal("failed to create test-data/generate")
}
unexported := cmp.AllowUnexported(
Machine{},
Rotors{},
Rotor{},
Plugboard{},
Reflector{},
)
for i := 0; i < 10; i++ {
m := Generate(rand.Intn(100) + 3)
err := Write(m, "../../test-data/generate/generated.json")
if err != nil {
t.Errorf("failed to write: %w", err)
}
r, err := Read("../../test-data/generate/generated.json")
if err != nil {
t.Errorf("failed to read: %w", err)
}
if diff := cmp.Diff(*m, *r, unexported); diff != "" {
t.Errorf("test %d: mismatch (-want +got):\n%s", i, diff)
}
}
}
|
package reader
import (
"encoding/json"
"io"
"io/ioutil"
)
type jsonReader struct {
input io.Reader
}
func (j jsonReader) Unmarshal(object interface{}) error {
return json.NewDecoder(j.input).Decode(object)
}
func (j jsonReader) Valid() bool {
var test map[string]interface{}
return j.Unmarshal(&test) == nil
}
func (j jsonReader) Reader() (io.Reader, error) {
return j.input, nil
}
func (j jsonReader) Bytes() ([]byte, error) {
reader, _ := j.Reader()
return ioutil.ReadAll(reader)
}
func (j jsonReader) ToString() (*string, error) {
result, err := j.Bytes()
if err != nil {
return nil, err
}
stringResult := string(result)
return &stringResult, nil
}
func (j jsonReader) ContentType() string {
return "application/json"
}
|
/*
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"
"fmt"
"path"
"reflect"
"time"
"bscp.io/pkg/dal/gen"
"bscp.io/pkg/dal/table"
"bscp.io/pkg/kit"
"bscp.io/pkg/logs"
pbbase "bscp.io/pkg/protocol/core/base"
pbci "bscp.io/pkg/protocol/core/config-item"
pbrci "bscp.io/pkg/protocol/core/released-ci"
pbds "bscp.io/pkg/protocol/data-service"
"bscp.io/pkg/types"
)
// CreateConfigItem create config item.
func (s *Service) CreateConfigItem(ctx context.Context, req *pbds.CreateConfigItemReq) (*pbds.CreateResp, error) {
grpcKit := kit.FromGrpcContext(ctx)
// validates unique key name+path both in table app_template_bindings and config_items
// validate in table app_template_bindings
if err := s.ValidateAppTemplateBindingUniqueKey(grpcKit, req.ConfigItemAttachment.BizId,
req.ConfigItemAttachment.AppId, req.ConfigItemSpec.Name, req.ConfigItemSpec.Path); err != nil {
return nil, err
}
// validate in table config_items
if _, err := s.dao.ConfigItem().GetByUniqueKey(grpcKit, req.ConfigItemAttachment.BizId,
req.ConfigItemAttachment.AppId, req.ConfigItemSpec.Name, req.ConfigItemSpec.Path); err == nil {
return nil, fmt.Errorf("config item's same name %s and path %s already exists",
req.ConfigItemSpec.Name, req.ConfigItemSpec.Path)
}
tx := s.dao.GenQuery().Begin()
// 1. create config item.
ci := &table.ConfigItem{
Spec: req.ConfigItemSpec.ConfigItemSpec(),
Attachment: req.ConfigItemAttachment.ConfigItemAttachment(),
Revision: &table.Revision{
Creator: grpcKit.User,
Reviser: grpcKit.User,
},
}
ciID, err := s.dao.ConfigItem().CreateWithTx(grpcKit, tx, ci)
if err != nil {
logs.Errorf("create config item failed, err: %v, rid: %s", err, grpcKit.Rid)
tx.Rollback()
return nil, err
}
// validate config items count.
if err := s.dao.ConfigItem().ValidateAppCINumber(grpcKit, tx, req.ConfigItemAttachment.BizId,
req.ConfigItemAttachment.AppId); err != nil {
logs.Errorf("validate config items count failed, err: %v, rid: %s", err, grpcKit.Rid)
tx.Rollback()
return nil, err
}
// 2. create content.
content := &table.Content{
Spec: req.ContentSpec.ContentSpec(),
Attachment: &table.ContentAttachment{
BizID: req.ConfigItemAttachment.BizId,
AppID: req.ConfigItemAttachment.AppId,
ConfigItemID: ciID,
},
Revision: &table.CreatedRevision{
Creator: grpcKit.User,
},
}
contentID, err := s.dao.Content().CreateWithTx(grpcKit, tx, content)
if err != nil {
logs.Errorf("create content failed, err: %v, rid: %s", err, grpcKit.Rid)
tx.Rollback()
return nil, err
}
// 3. create commit.
commit := &table.Commit{
Spec: &table.CommitSpec{
ContentID: contentID,
Content: content.Spec,
},
Attachment: &table.CommitAttachment{
BizID: req.ConfigItemAttachment.BizId,
AppID: req.ConfigItemAttachment.AppId,
ConfigItemID: ciID,
},
Revision: &table.CreatedRevision{
Creator: grpcKit.User,
},
}
_, err = s.dao.Commit().CreateWithTx(grpcKit, tx, commit)
if err != nil {
logs.Errorf("create commit failed, err: %v, rid: %s", err, grpcKit.Rid)
tx.Rollback()
return nil, err
}
if err := tx.Commit(); err != nil {
logs.Errorf("commit transaction failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
resp := &pbds.CreateResp{Id: ciID}
return resp, nil
}
// BatchUpsertConfigItems batch upsert config items.
func (s *Service) BatchUpsertConfigItems(ctx context.Context, req *pbds.BatchUpsertConfigItemsReq) (
*pbbase.EmptyResp, error) {
grpcKit := kit.FromGrpcContext(ctx)
// 1. list all editing config items.
cis, err := s.dao.ConfigItem().ListAllByAppID(grpcKit, req.AppId, req.BizId)
if err != nil {
logs.Errorf("list editing config items failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
editingCIMap := make(map[string]*table.ConfigItem)
newCIMap := make(map[string]*pbds.BatchUpsertConfigItemsReq_ConfigItem)
for _, ci := range cis {
editingCIMap[path.Join(ci.Spec.Path, ci.Spec.Name)] = ci
}
for _, item := range req.Items {
newCIMap[path.Join(item.ConfigItemSpec.Path, item.ConfigItemSpec.Name)] = item
}
// 2. check if config item is already exists in editing config items list.
toCreate, toUpdateSpec, toUpdateContent, toDelete, err := s.checkConfigItems(grpcKit, req, editingCIMap, newCIMap)
if err != nil {
logs.Errorf("check and compare config items failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
now := time.Now().UTC()
tx := s.dao.GenQuery().Begin()
if err := s.doBatchCreateConfigItems(grpcKit, tx, toCreate, now, req.BizId, req.AppId); err != nil {
tx.Rollback()
return nil, err
}
if err := s.doBatchUpdateConfigItemSpec(grpcKit, tx, toUpdateSpec, now,
req.BizId, req.AppId, editingCIMap); err != nil {
tx.Rollback()
return nil, err
}
if err := s.doBatchUpdateConfigItemContent(grpcKit, tx, toUpdateContent, now,
req.BizId, req.AppId, editingCIMap); err != nil {
tx.Rollback()
return nil, err
}
if req.ReplaceAll {
// if replace all,delete config items not in batch upsert request.
if err := s.doBatchDeleteConfigItems(grpcKit, tx, toDelete, req.BizId, req.AppId); err != nil {
tx.Rollback()
return nil, err
}
}
// validate config items count.
if err := s.dao.ConfigItem().ValidateAppCINumber(grpcKit, tx, req.BizId, req.AppId); err != nil {
logs.Errorf("validate config items count failed, err: %v, rid: %s", err, grpcKit.Rid)
tx.Rollback()
return nil, err
}
if err := tx.Commit(); err != nil {
logs.Errorf("commit transaction failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
return new(pbbase.EmptyResp), nil
}
func (s *Service) checkConfigItems(kt *kit.Kit, req *pbds.BatchUpsertConfigItemsReq,
editingCIMap map[string]*table.ConfigItem, newCIMap map[string]*pbds.BatchUpsertConfigItemsReq_ConfigItem) (
toCreate []*pbds.BatchUpsertConfigItemsReq_ConfigItem, toUpdateSpec []*pbds.BatchUpsertConfigItemsReq_ConfigItem,
toUpdateContent []*pbds.BatchUpsertConfigItemsReq_ConfigItem, toDelete []uint32, err error) {
// 1. list all config items' latest commit.
ids := make([]uint32, 0, len(editingCIMap))
for _, ci := range editingCIMap {
ids = append(ids, ci.ID)
}
commits, err := s.dao.Commit().BatchListLatestCommits(kt, req.BizId, req.AppId, ids)
commitMap := make(map[uint32]*table.Commit)
for _, commit := range commits {
commitMap[commit.Attachment.ConfigItemID] = commit
}
if err != nil {
logs.Errorf("list latest commits failed, err: %v, rid: %s", err, kt.Rid)
return nil, nil, nil, nil, err
}
for _, item := range req.Items {
if editing, exists := editingCIMap[path.Join(item.ConfigItemSpec.Path, item.ConfigItemSpec.Name)]; exists {
// 2.1 if config item already exists, need compare and update.
specDiff, contentDiff, cErr := s.compareConfigItem(kt, item, editing, commitMap)
if cErr != nil {
logs.Errorf("compare config item failed, err: %v, rid: %s", err, kt.Rid)
return nil, nil, nil, nil, cErr
}
if specDiff || contentDiff {
toUpdateSpec = append(toUpdateSpec, item)
}
if contentDiff {
toUpdateContent = append(toUpdateContent, item)
}
} else {
// 2.2 if not exists, create new config item.
toCreate = append(toCreate, item)
}
}
// 3. delete config items not in batch upsert request.
for _, ci := range editingCIMap {
if newCIMap[path.Join(ci.Spec.Path, ci.Spec.Name)] == nil {
// if config item not in batch upsert request, delete it.
toDelete = append(toDelete, ci.ID)
}
}
return // nolint
}
func (s *Service) doBatchCreateConfigItems(kt *kit.Kit, tx *gen.QueryTx,
toCreate []*pbds.BatchUpsertConfigItemsReq_ConfigItem, now time.Time, bizID, appID uint32) error {
toCreateConfigItems := []*table.ConfigItem{}
for _, item := range toCreate {
ci := &table.ConfigItem{
Spec: item.ConfigItemSpec.ConfigItemSpec(),
Attachment: item.ConfigItemAttachment.ConfigItemAttachment(),
Revision: &table.Revision{
Creator: kt.User,
Reviser: kt.User,
CreatedAt: now,
UpdatedAt: now,
},
}
toCreateConfigItems = append(toCreateConfigItems, ci)
}
if err := s.dao.ConfigItem().BatchCreateWithTx(kt, tx, bizID, appID, toCreateConfigItems); err != nil {
logs.Errorf("batch create config items failed, err: %v, rid: %s", err, kt.Rid)
return err
}
toCreateContent := []*table.Content{}
for i, item := range toCreate {
toCreateContent = append(toCreateContent, &table.Content{
Spec: item.ContentSpec.ContentSpec(),
Attachment: &table.ContentAttachment{
BizID: bizID,
AppID: appID,
ConfigItemID: toCreateConfigItems[i].ID,
},
Revision: &table.CreatedRevision{
Creator: kt.User,
},
})
}
if err := s.dao.Content().BatchCreateWithTx(kt, tx, toCreateContent); err != nil {
logs.Errorf("batch create config items failed, err: %v, rid: %s", err, kt.Rid)
return err
}
toCreateCommit := []*table.Commit{}
for i := range toCreateContent {
toCreateCommit = append(toCreateCommit, &table.Commit{
Spec: &table.CommitSpec{
ContentID: toCreateContent[i].ID,
Content: toCreateContent[i].Spec,
},
Attachment: &table.CommitAttachment{
BizID: bizID,
AppID: appID,
ConfigItemID: toCreateConfigItems[i].ID,
},
Revision: &table.CreatedRevision{
Creator: kt.User,
},
})
}
if err := s.dao.Commit().BatchCreateWithTx(kt, tx, toCreateCommit); err != nil {
logs.Errorf("batch create commits failed, err: %v, rid: %s", err, kt.Rid)
return err
}
return nil
}
func (s *Service) doBatchUpdateConfigItemSpec(kt *kit.Kit, tx *gen.QueryTx,
toUpdate []*pbds.BatchUpsertConfigItemsReq_ConfigItem, now time.Time,
bizID, appID uint32, ciMap map[string]*table.ConfigItem) error {
configItems := []*table.ConfigItem{}
for _, item := range toUpdate {
ci := &table.ConfigItem{
ID: ciMap[path.Join(item.ConfigItemSpec.Path, item.ConfigItemSpec.Name)].ID,
Spec: item.ConfigItemSpec.ConfigItemSpec(),
Attachment: item.ConfigItemAttachment.ConfigItemAttachment(),
Revision: &table.Revision{
Creator: ciMap[path.Join(item.ConfigItemSpec.Path, item.ConfigItemSpec.Name)].Revision.Creator,
Reviser: kt.User,
CreatedAt: ciMap[path.Join(item.ConfigItemSpec.Path, item.ConfigItemSpec.Name)].Revision.CreatedAt,
UpdatedAt: now,
},
}
configItems = append(configItems, ci)
}
if err := s.dao.ConfigItem().BatchUpdateWithTx(kt, tx, configItems); err != nil {
logs.Errorf("batch update config items failed, err: %v, rid: %s", err, kt.Rid)
return err
}
return nil
}
func (s *Service) doBatchUpdateConfigItemContent(kt *kit.Kit, tx *gen.QueryTx,
toUpdate []*pbds.BatchUpsertConfigItemsReq_ConfigItem, now time.Time,
bizID, appID uint32, ciMap map[string]*table.ConfigItem) error {
toCreateContents := []*table.Content{}
for _, item := range toUpdate {
content := &table.Content{
Spec: item.ContentSpec.ContentSpec(),
Attachment: &table.ContentAttachment{
BizID: bizID,
AppID: appID,
ConfigItemID: ciMap[path.Join(item.ConfigItemSpec.Path, item.ConfigItemSpec.Name)].ID,
},
Revision: &table.CreatedRevision{
Creator: kt.User,
CreatedAt: now,
},
}
toCreateContents = append(toCreateContents, content)
}
if err := s.dao.Content().BatchCreateWithTx(kt, tx, toCreateContents); err != nil {
logs.Errorf("batch create contents failed, err: %v, rid: %s", err, kt.Rid)
return err
}
toCreateCommits := []*table.Commit{}
for i, item := range toUpdate {
commit := &table.Commit{
Spec: &table.CommitSpec{
ContentID: toCreateContents[i].ID,
Content: item.ContentSpec.ContentSpec(),
},
Attachment: &table.CommitAttachment{
BizID: bizID,
AppID: appID,
ConfigItemID: ciMap[path.Join(item.ConfigItemSpec.Path, item.ConfigItemSpec.Name)].ID,
},
Revision: &table.CreatedRevision{
Creator: kt.User,
CreatedAt: now,
},
}
toCreateCommits = append(toCreateCommits, commit)
}
if err := s.dao.Commit().BatchCreateWithTx(kt, tx, toCreateCommits); err != nil {
logs.Errorf("batch create commits failed, err: %v, rid: %s", err, kt.Rid)
return err
}
return nil
}
func (s *Service) doBatchDeleteConfigItems(kt *kit.Kit, tx *gen.QueryTx, toDelete []uint32, bizID, appID uint32) error {
if err := s.dao.ConfigItem().BatchDeleteWithTx(kt, tx, toDelete, bizID, appID); err != nil {
logs.Errorf("batch create contents failed, err: %v, rid: %s", err, kt.Rid)
return err
}
return nil
}
func (s *Service) createNewConfigItem(kt *kit.Kit, tx *gen.QueryTx, bizID, appID uint32,
now time.Time, item *pbds.BatchUpsertConfigItemsReq_ConfigItem) error {
// 1. create config item.
ci := &table.ConfigItem{
Spec: item.ConfigItemSpec.ConfigItemSpec(),
Attachment: item.ConfigItemAttachment.ConfigItemAttachment(),
Revision: &table.Revision{
Creator: kt.User,
Reviser: kt.User,
CreatedAt: now,
UpdatedAt: now,
},
}
ciID, err := s.dao.ConfigItem().CreateWithTx(kt, tx, ci)
if err != nil {
logs.Errorf("create config item failed, err: %v, rid: %s", err, kt.Rid)
return err
}
// 2. create content.
content := &table.Content{
Spec: item.ContentSpec.ContentSpec(),
Attachment: &table.ContentAttachment{
BizID: bizID,
AppID: appID,
ConfigItemID: ciID,
},
Revision: &table.CreatedRevision{
Creator: kt.User,
},
}
contentID, err := s.dao.Content().CreateWithTx(kt, tx, content)
if err != nil {
logs.Errorf("create content failed, err: %v, rid: %s", err, kt.Rid)
return err
}
// 3. create commit.
commit := &table.Commit{
Spec: &table.CommitSpec{
ContentID: contentID,
Content: content.Spec,
},
Attachment: &table.CommitAttachment{
BizID: bizID,
AppID: appID,
ConfigItemID: ciID,
},
Revision: &table.CreatedRevision{
Creator: kt.User,
},
}
_, err = s.dao.Commit().CreateWithTx(kt, tx, commit)
if err != nil {
logs.Errorf("create commit failed, err: %v, rid: %s", err, kt.Rid)
return err
}
return nil
}
// compareConfigItem compare config item
// return specDiff, contentDiff, error
func (s *Service) compareConfigItem(kt *kit.Kit, new *pbds.BatchUpsertConfigItemsReq_ConfigItem,
editing *table.ConfigItem, commitMap map[uint32]*table.Commit) (specDiff bool, contentDiff bool, err error) {
// 1. compare config item spec.
if !reflect.DeepEqual(new.ConfigItemSpec.ConfigItemSpec(), editing.Spec) {
specDiff = true
}
// 2. compare content.
// 2.1 get latest commit.
commit, exists := commitMap[editing.ID]
if !exists {
// ! config item should have at least one commit.
logs.Errorf("[SHOULD-NOT-HAPPEN] latest commit for config item %d not found", editing.ID)
return false, false, fmt.Errorf("[SHOULD-NOT-HAPPEN] latest commit for config item %d not found", editing.ID)
}
// 2.2 compare content spec.
if new.ContentSpec.Signature != commit.Spec.Content.Signature {
contentDiff = true
}
return // nolint
}
// UpdateConfigItem update config item.
func (s *Service) UpdateConfigItem(ctx context.Context, req *pbds.UpdateConfigItemReq) (
*pbbase.EmptyResp, error) {
grpcKit := kit.FromGrpcContext(ctx)
ci := &table.ConfigItem{
ID: req.Id,
Spec: req.Spec.ConfigItemSpec(),
Attachment: req.Attachment.ConfigItemAttachment(),
Revision: &table.Revision{
Reviser: grpcKit.User,
},
}
if err := s.dao.ConfigItem().Update(grpcKit, ci); err != nil {
logs.Errorf("update config item failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
return new(pbbase.EmptyResp), nil
}
// DeleteConfigItem delete config item.
func (s *Service) DeleteConfigItem(ctx context.Context, req *pbds.DeleteConfigItemReq) (*pbbase.EmptyResp, error) {
grpcKit := kit.FromGrpcContext(ctx)
ci := &table.ConfigItem{
ID: req.Id,
Attachment: req.Attachment.ConfigItemAttachment(),
}
if err := s.dao.ConfigItem().Delete(grpcKit, ci); err != nil {
logs.Errorf("delete config item failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
return new(pbbase.EmptyResp), nil
}
// GetConfigItem get config item detail
func (s *Service) GetConfigItem(ctx context.Context, req *pbds.GetConfigItemReq) (*pbci.ConfigItem, error) {
grpcKit := kit.FromGrpcContext(ctx)
configItem, err := s.dao.ConfigItem().Get(grpcKit, req.Id, req.BizId)
if err != nil {
logs.Errorf("get config item failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
resp := pbci.PbConfigItem(configItem, "")
return resp, nil
}
// ListConfigItems list config items by query condition.
func (s *Service) ListConfigItems(ctx context.Context, req *pbds.ListConfigItemsReq) (*pbds.ListConfigItemsResp,
error) {
grpcKit := kit.FromGrpcContext(ctx)
if req.ReleaseId == 0 {
// search all editing config items
details, err := s.dao.ConfigItem().SearchAll(grpcKit, req.SearchKey, req.AppId, req.BizId)
if err != nil {
logs.Errorf("list editing config items failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
fileReleased, err := s.dao.ReleasedCI().GetReleasedLately(grpcKit, req.AppId, req.BizId, req.SearchKey)
if err != nil {
logs.Errorf("get released failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
configItems := pbrci.PbConfigItemState(details, fileReleased)
var start, end uint32 = 0, uint32(len(configItems))
if !req.All {
if req.Start < uint32(len(configItems)) {
start = req.Start
}
if req.Start+req.Limit < uint32(len(configItems)) {
end = req.Start + req.Limit
} else {
end = uint32(len(configItems))
}
}
resp := &pbds.ListConfigItemsResp{
Count: uint32(len(configItems)),
Details: configItems[start:end],
}
return resp, nil
}
// list released config items
query := &types.ListReleasedCIsOption{
BizID: req.BizId,
ReleaseID: req.ReleaseId,
SearchKey: req.SearchKey,
Page: &types.BasePage{
Start: req.Start,
Limit: uint(req.Limit),
},
}
if req.All {
query.Page.Start = 0
query.Page.Limit = 0
}
details, err := s.dao.ReleasedCI().List(grpcKit, query)
if err != nil {
logs.Errorf("list released config items failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
resp := &pbds.ListConfigItemsResp{
Count: details.Count,
Details: pbrci.PbConfigItems(details.Details),
}
return resp, nil
}
// ListConfigItemCount list config items count.
func (s *Service) ListConfigItemCount(ctx context.Context, req *pbds.ListConfigItemCountReq) (
*pbds.ListConfigItemCountResp, error) {
grpcKit := kit.FromGrpcContext(ctx)
details, err := s.dao.ConfigItem().GetCount(grpcKit, req.BizId, req.AppId)
if err != nil {
logs.Errorf("list editing config items failed, err: %v, rid: %s", err, grpcKit.Rid)
return nil, err
}
resp := &pbds.ListConfigItemCountResp{
Details: pbci.PbConfigItemCounts(details, req.AppId),
}
return resp, nil
}
|
package spider
type Novel struct {
NovelId int `json:"novel_id"`
NovelHash string `json:"novel_hash"`
DownloadUrl string `json:"download_url"`
VoteUrl string `json:"vote_url"`
NovelType string `json:"novel_type"`
Size int `json:"size"`
Title string `json:"title"`
Detail string `json:"detail"`
XianCao int `json:"xian_cao"`
LiangCao int `json:"liang_cao"`
GanCao int `json:"gan_cao"`
KuCao int `json:"ku_cao"`
DuCao int `json:"du_cao"`
Time int64 `json:"time"`
} |
package pagination
import (
"bytes"
"testing"
"github.com/PuerkitoBio/goquery"
)
func assertHasHTMLElements(t *testing.T, html *goquery.Document, selector string, num int) {
got := html.Find(selector)
if got.Length() != num {
t.Errorf("Expected to find %d html elements (%s) but found %d", num, selector, got.Length())
}
}
func Test_Render(t *testing.T) {
p := NewHTML(28, 25, 5)
output := string(p.Render())
doc, err := goquery.NewDocumentFromReader(bytes.NewBufferString(output))
if err != nil {
t.Fatal(err)
}
assertHasHTMLElements(t, doc, ".pagination-list", 1)
assertHasHTMLElements(t, doc, ".pagination-item-special", 2)
assertHasHTMLElements(t, doc, ".pagination-link", 2+2) // Previous and next + 2 pages (1 and 2)
assertHasHTMLElements(t, doc, ".pagination-current", 1)
}
func Test_RenderNothing(t *testing.T) {
p := NewHTML(1, 25, 1)
output := string(p.Render())
doc, err := goquery.NewDocumentFromReader(bytes.NewBufferString(output))
if err != nil {
t.Fatal(err)
}
assertHasHTMLElements(t, doc, ".pagination-list", 0)
assertHasHTMLElements(t, doc, ".pagination-item-special", 0)
assertHasHTMLElements(t, doc, ".pagination-link", 0)
assertHasHTMLElements(t, doc, ".pagination-current", 0)
}
|
package cache
import (
"bytes"
"encoding/hex"
"errors"
"fmt"
"os"
"path/filepath"
"sort"
"sync"
"time"
)
// Internal structure to track old files, sort them by age and delete "sets"
// of them.
type fsCacheEntry struct {
ns string
uuidAndHash []byte
size int64
time time.Time
}
type fsCacheEntries []fsCacheEntry
// Implement sort.Interface
func (f fsCacheEntries) Len() int { return len(f) }
func (f fsCacheEntries) Less(i, j int) bool {
// Fiddle a bit with zero-times, so they always come out last
if f[i].time.IsZero() {
return false
}
if f[j].time.IsZero() {
return true
}
return f[i].time.Before(f[j].time)
}
func (f fsCacheEntries) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
// Parses the uuidAndHash from a base filename, such as the one made by
// `generateFilename()`.
func parseFilename(baseFilename string) ([]byte, error) {
if len(baseFilename) < 65 {
return []byte{}, fmt.Errorf("Filename too short")
}
// Parse out uuidAndHash
// TODO(deal with errors);
first, err := hex.DecodeString(baseFilename[0:32])
if err != nil {
return []byte{}, err
}
second, err := hex.DecodeString(baseFilename[33:65]) // off-by-one to skip dash in the middle
if err != nil {
return []byte{}, err
}
return append(first, second...), nil
}
// Find an approximate set of oldest files.
//
// Currently, it does a single pass over all sub-direcotries and picks the
// oldest file from each
func findApproximateOldFiles(basepath string) (int64, fsCacheEntries, error) {
// Find all namespaces
dir, err := os.Open(basepath)
// If the path doesn't exist, we're done GC'ing
if errors.Is(err, os.ErrNotExist) {
return 0, fsCacheEntries{}, nil
} else if err != nil {
return 0, fsCacheEntries{}, fmt.Errorf("GC Error: %w", err)
}
defer dir.Close()
entries, err := dir.Readdir(0)
if err != nil {
return 0, fsCacheEntries{}, err
}
// Each namespace has 256 subdirectories
old := make(fsCacheEntries, 256*len(entries))
sizes := make([]int64, len(entries))
allDone := sync.WaitGroup{}
for nsIndex, ns := range entries {
if !ns.IsDir() {
continue
}
allDone.Add(1)
go func(ns string, nsIndex int) {
defer allDone.Done()
// There be 256 folders - let's find the oldest one + it's size
// TODO: Split into ~256 go-routines for speed?
for i := 0; i < 256; i += 1 {
dirname := filepath.Join(basepath, ns, fmt.Sprintf("%02x", i))
dir, err := os.Open(dirname)
if err != nil {
continue
}
entries, err := dir.Readdir(0)
if err != nil {
continue
}
oldIndex := i + 256*nsIndex
for _, entry := range entries {
if entry.IsDir() {
continue
}
// Count up sizes of everything
//fs.Size += entry.Size()
sizes[nsIndex] += entry.Size()
// Check if it's the oldest thing we've found in this directory
t := fileinfo_atime(entry)
uuidAndHash, err := parseFilename(entry.Name())
if err != nil {
continue
}
// Same resource, just different kind.
// FIXME: We're not guaranteed that the items will come in
// alphabetical order (which would make this optimization
// 100% foolproof), but I think we're pretty close with all
// files of the same uuidAndHash having roughly same
// timestamp, so we'll ignore all the others...
if bytes.Equal(old[oldIndex].uuidAndHash, uuidAndHash) {
old[oldIndex].size += entry.Size()
if old[oldIndex].time.Before(t) {
old[oldIndex].time = t
}
}
if len(old[oldIndex].uuidAndHash) == 0 || t.Before(old[oldIndex].time) {
old[oldIndex].ns = ns
old[oldIndex].uuidAndHash = uuidAndHash
old[oldIndex].size = entry.Size()
old[oldIndex].time = t
}
}
dir.Close()
}
fs_size.WithLabelValues(ns).Set(float64(sizes[nsIndex]))
}(ns.Name(), nsIndex)
}
dir.Close()
allDone.Wait()
// Add up sizes
var totalSize int64 = 0
for _, size := range sizes {
totalSize += size
}
// Return only non-empty objecs
sort.Sort(old)
// TODO: We could do this bookkeeping in the main loop...
found_elements := 0
for i, elem := range old {
if elem.time.IsZero() {
found_elements = i
break
}
}
return totalSize, old[0:found_elements], nil
}
|
package server
import (
"bufio"
"context"
"encoding/json"
"fmt"
"go-bca"
"io/ioutil"
"log"
"net/http"
"net/url"
"os"
"os/signal"
"strings"
"sync"
"syscall"
"time"
"github.com/gomodule/redigo/redis"
"github.com/pkg/errors"
"github.com/julienschmidt/httprouter"
"golang.org/x/sync/singleflight"
)
var (
router *httprouter.Router
requestGroup singleflight.Group
transIdMutex sync.RWMutex
transIdScript *redis.Script
Whitelist bool
)
func init() {
transIdScript = redis.NewScript(0, `
local n = redis.call('INCR', 'bca:transid')
if n > 99999998 then
redis.call('SET', 'bca:transid', '0')
end
return n
`)
}
type Server struct {
Listen string
SSLCertFile string
SSLKeyFile string
Origin string
BaseUrl string
ApiKey string
ApiSecret string
ClientId string
ClientSecret string
CorporateId string
ChannelId string
CredentialId string
Debug bool
}
type serverVersion struct {
Version string `json:"Version"`
}
type serverError struct {
Error string `json:"Error"`
}
type serverSuccess struct {
Success string `json:"Success"`
}
func (s *Server) Start() {
redisPool = &redis.Pool{
MaxIdle: 3,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
redisHost := os.Getenv("REDIS_HOST")
if redisHost == "" {
redisHost = ":6379"
}
conn, err := redis.Dial("tcp", redisHost)
if err != nil {
log.Printf("redis connection error %v", err)
}
return conn, err
},
}
defer redisPool.Close()
bca.Debug = s.Debug
bca.Origin = s.Origin
bca.BaseUrl = s.BaseUrl
bca.ApiKey = s.ApiKey
bca.ApiSecret = s.ApiSecret
bca.ClientId = s.ClientId
bca.ClientSecret = s.ClientSecret
bca.CorporateId = s.CorporateId
bca.ChannelId = s.ChannelId
bca.CredentialId = s.CredentialId
router = httprouter.New()
router.GET("/", index)
router.GET("/balance/:accnum", tokenAuth(balance))
router.GET("/statement/:accnum", tokenAuth(statement))
router.GET("/validate", tokenAuth(validate))
router.POST("/transfer", tokenAuth(fundTransfer))
router.POST("/domestic-transfer", tokenAuth(domesticFundTransfer))
if Whitelist {
router.POST("/whitelist-import", basicAuth(whitelistImport))
router.POST("/whitelist-delete", basicAuth(whitelistDelete))
router.GET("/whitelist-export", basicAuth(whitelistExport))
}
srv := http.Server{
Addr: s.Listen,
Handler: router,
}
idleConnClosed := make(chan struct{})
go func() {
sigint := make(chan os.Signal, 1)
signal.Notify(sigint, os.Interrupt)
signal.Notify(sigint, syscall.SIGTERM)
signal.Notify(sigint, syscall.SIGKILL)
<-sigint
if err := srv.Shutdown(context.Background()); err != nil {
log.Println(err)
}
close(idleConnClosed)
}()
var err error
if len(s.SSLCertFile) > 1 && len(s.SSLKeyFile) > 1 {
log.Printf("ServerTLS listening on %s", s.Listen)
err = srv.ListenAndServeTLS(s.SSLCertFile, s.SSLKeyFile)
} else {
log.Printf("Server listening on %s", s.Listen)
err = srv.ListenAndServe()
}
if err == http.ErrServerClosed {
log.Println("Server shutdown gracefully")
} else {
log.Printf("Server shutdown error: %v", err)
}
<-idleConnClosed
}
func whitelistExport(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
c := redisPool.Get()
defer c.Close()
w.Header().Set("Content-Type", "text/plain; charset=UTF-8")
w.WriteHeader(http.StatusOK)
pattern := "bca:whitelist:*"
iter := 0
for {
arr, err := redis.Values(c.Do("SCAN", iter, "MATCH", pattern))
if err != nil {
log.Printf("redis scan error %v", err)
break
}
iter, _ = redis.Int(arr[0], nil)
keys, _ := redis.Strings(arr[1], nil)
for _, k := range keys {
name, _ := redis.String(c.Do("HGET", k, "name"))
fmt.Fprintf(w, "%s %s\n", name, strings.Replace(k, "bca:whitelist:", "", -1))
}
if iter == 0 {
break
}
}
}
func whitelistImport(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
c := redisPool.Get()
defer c.Close()
list := r.FormValue("whitelist")
scanner := bufio.NewScanner(strings.NewReader(list))
for scanner.Scan() {
line := scanner.Text()
pos := strings.LastIndex(line, " ")
name := strings.TrimSpace(line[0:pos])
number := strings.TrimSpace(line[pos+1:])
c.Do("HSET", "bca:whitelist:"+number, "name", name)
}
err := scanner.Err()
if err != nil {
errResponse(w, err.Error(), http.StatusInternalServerError)
return
}
response(w, &serverSuccess{Success: "Ok"}, http.StatusOK)
}
func whitelistDelete(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
c := redisPool.Get()
defer c.Close()
list := r.FormValue("whitelist")
scanner := bufio.NewScanner(strings.NewReader(list))
for scanner.Scan() {
line := scanner.Text()
pos := strings.LastIndex(line, " ")
// name := strings.TrimSpace(line[0:pos])
number := strings.TrimSpace(line[pos+1:])
c.Do("DEL", "bca:whitelist:"+number)
}
err := scanner.Err()
if err != nil {
errResponse(w, err.Error(), http.StatusInternalServerError)
return
}
response(w, &serverSuccess{Success: "Ok"}, http.StatusOK)
}
func index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
logRequest(r)
response(w, &serverVersion{Version: "1.0"}, http.StatusOK)
}
func balance(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
var c redis.Conn
var err error
var req bca.BalanceInformationRequest
var resp bca.BalanceInformation
c = redisPool.Get()
defer func() {
var result string
if err != nil {
statIncr(c, "bca:stats", "error")
result = err.Error()
} else {
statIncr(c, "bca:stats", "success")
result = "OK"
}
log.Printf("bca balance information %s (%s)", req.AccountNumbers, result)
c.Close()
}()
token, _ := redis.String(c.Do("GET", "bca:accesstoken"))
req = bca.BalanceInformationRequest{
AccountNumbers: p.ByName("accnum"),
}
resp, err = req.Get(token)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
response(w, resp, http.StatusOK)
}
func statement(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
var c redis.Conn
var err error
var req bca.AccountStatementRequest
var resp bca.AccountStatement
c = redisPool.Get()
defer func() {
var result string
if err != nil {
statIncr(c, "bca:stats", "error")
result = err.Error()
} else {
statIncr(c, "bca:stats", "success")
result = "OK"
}
log.Printf("bca account statement %s %s %s (%s)", req.AccountNumber, req.StartDate, req.EndDate, result)
c.Close()
}()
q := r.URL.Query()
token, _ := redis.String(c.Do("GET", "bca:accesstoken"))
req = bca.AccountStatementRequest{
AccountNumber: p.ByName("accnum"),
StartDate: q.Get("StartDate"),
EndDate: q.Get("EndDate"),
}
resp, err = req.Get(token)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
response(w, resp, http.StatusOK)
}
func validate(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
var c redis.Conn
var err error
var token string
var req bca.ValidationRequest
var resp bool
var q url.Values
c = redisPool.Get()
defer func() {
var result string
if err != nil {
result = err.Error()
} else {
result = fmt.Sprintf("%v", resp)
}
statIncr(c, "bca:stats", "success")
log.Printf("bca validate account %s %s (%s)", req.Number, req.Name, result)
c.Close()
}()
q = r.URL.Query()
token, _ = redis.String(c.Do("GET", "bca:accesstoken"))
req = bca.ValidationRequest{
Name: q.Get("Name"),
Number: q.Get("Number"),
}
resp, err = req.Validate(token)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
response(w, &serverSuccess{Success: "Ok"}, http.StatusOK)
}
func whitelistCheck(c redis.Conn, token string, number string) error {
key := "bca:whitelist:" + number
name, _ := redis.String(c.Do("HGET", key, "name"))
if name == "" {
return errors.Errorf("beneficiary account %s not whitelisted", number)
}
valid, _ := redis.Int(c.Do("HEXISTS", key, "valid"))
if valid < 1 {
req := &bca.ValidationRequest{
Name: name,
Number: number,
}
_, err := req.Validate(token)
statIncr(c, "bca:stats", "success")
if err != nil {
c.Do("HDEL", key, "name", "valid")
return errors.Wrapf(err, "invalid beneficiary account %s %s", number, name)
}
c.Do("HSET", key, "valid", "ok")
}
return nil
}
func transactionId(c redis.Conn) (string, error) {
n, err := redis.Int(transIdScript.Do(c))
if err != nil {
return "", errors.Wrapf(err, "failed to get transaction id increment")
}
return fmt.Sprintf("%08d", n), nil
}
func fundTransfer(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
var c redis.Conn
var err error
var transId, token string
var req bca.FundTransfer
var resp bca.FundTransferReceipt
var body []byte
body, err = ioutil.ReadAll(r.Body)
defer r.Body.Close()
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
err = json.Unmarshal(body, &req)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
c = redisPool.Get()
defer func() {
var result string
if err != nil {
statIncr(c, "bca:stats", "error")
result = err.Error()
} else {
statIncr(c, "bca:stats", "success")
result = fmt.Sprintf("transaction id %s, %s", resp.TransactionID, resp.Status)
}
log.Printf("bca transfer %s -> %s amount %s %s (%s)",
req.SourceAccountNumber, req.BeneficiaryAccountNumber, req.CurrencyCode, req.Amount, result)
c.Close()
}()
token, _ = redis.String(c.Do("GET", "bca:accesstoken"))
if Whitelist {
err = whitelistCheck(c, token, req.BeneficiaryAccountNumber)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
}
if len(req.TransactionID) < 1 {
transId, err = transactionId(c)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
req.TransactionID = transId
}
if len(req.ReferenceID) < 1 {
req.ReferenceID = transId
}
if len(req.CorporateID) < 1 {
req.CorporateID = bca.CorporateId
}
req.CurrencyCode = bca.DefaultCurrencyCode
resp, err = req.Get(token)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
response(w, resp, http.StatusOK)
}
func domesticFundTransfer(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
var c redis.Conn
var err error
var transId, token string
var req bca.DomesticFundTransfer
var resp bca.DomesticFundTransferReceipt
var body []byte
body, err = ioutil.ReadAll(r.Body)
defer r.Body.Close()
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
err = json.Unmarshal(body, &req)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
c = redisPool.Get()
defer func() {
var result string
if err != nil {
statIncr(c, "bca:stats", "error")
result = err.Error()
} else {
statIncr(c, "bca:stats", "success")
result = fmt.Sprintf("transaction id %s, ppu %s", resp.TransactionID, resp.PPUNumber)
}
log.Printf("bca domestic transfer %s -> %s amount %s %s (%s)",
req.SourceAccountNumber, req.BeneficiaryAccountNumber, req.CurrencyCode, req.Amount, result)
c.Close()
}()
token, _ = redis.String(c.Do("GET", "bca:accesstoken"))
if Whitelist {
err = whitelistCheck(c, token, req.BeneficiaryAccountNumber)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
}
if len(req.TransactionID) < 1 {
transId, err = transactionId(c)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
req.TransactionID = transId
}
if len(req.ReferenceID) < 1 {
req.ReferenceID = transId
}
req.CurrencyCode = bca.DefaultCurrencyCode
resp, err = req.Get(token)
if err != nil {
errResponse(w, err.Error(), http.StatusBadRequest)
return
}
response(w, resp, http.StatusOK)
}
|
package bmdb
import (
"errors"
"github.com/missionMeteora/bmdb/mdb"
)
const registryMapCap = 128
const (
// MaxNameLength is the maximum length of a bucket name, in bytes.
MaxNameLength = 64
// MaxKeySize is the maximum length of a key, in bytes.
MaxKeySize = 32768
// MaxValueSize is the maximum length of a value, in bytes.
MaxValueSize = 4294967295
)
var DefaultBucketName = []byte("default")
var (
ErrKeyTooLarge = errors.New("key is too large")
ErrValueTooLarge = errors.New("value is too large")
ErrBucketExists = errors.New("bucket already exists")
ErrNameTooLong = errors.New("bucket name is too long")
ErrNoBucketName = errors.New("no bucket name provided")
ErrBucketNotFound = errors.New("bucket not found")
ErrKeyRequired = errors.New("key is required")
ErrTxManaged = errors.New("this transaction is managed")
ErrTxDone = errors.New("this transaction is done")
ErrDatabaseNotOpen = errors.New("database not open")
ErrTxNotWritable = errors.New("read-only transaction")
)
type EnvFlag uint
const (
FIXEDMAP EnvFlag = mdb.FIXEDMAP // mmap at a fixed address (experimental)
NOSUBDIR EnvFlag = mdb.NOSUBDIR // no environment directory
NOSYNC EnvFlag = mdb.NOSYNC // don't fsync after commit
RDONLY EnvFlag = mdb.RDONLY // read only
NOMETASYNC EnvFlag = mdb.NOMETASYNC // don't fsync metapage after commit
WRITEMAP EnvFlag = mdb.WRITEMAP // use writable mmap
MAPASYNC EnvFlag = mdb.MAPASYNC // use asynchronous msync when MDB_WRITEMAP is use
NOTLS EnvFlag = mdb.NOTLS // tie reader locktable slots to Txn objects instead of threads
//
REVERSEKEY EnvFlag = mdb.REVERSEKEY // use reverse string keys
DUPSORT EnvFlag = mdb.DUPSORT // use sorted duplicates
INTEGERKEY EnvFlag = mdb.INTEGERKEY // numeric keys in native byte order. The keys must all be of the same size.
DUPFIXED EnvFlag = mdb.DUPFIXED // with DUPSORT, sorted dup items have fixed size
INTEGERDUP EnvFlag = mdb.INTEGERDUP // with DUPSORT, dups are numeric in native byte order
REVERSEDUP EnvFlag = mdb.REVERSEDUP // with DUPSORT, use reverse string dups
CREATE EnvFlag = mdb.CREATE // create DB if not already existing
)
|
package model
type Document struct {
Id string `json:"id"`
Name string `json:"name"`
Type string `json:"type"`
}
type Documents []Document
func (d Documents) Len() int {
return len(d)
}
func (d Documents) Swap(i, j int) {
d[i], d[j] = d[j], d[i]
}
func (d Documents) Less(i, j int) bool {
if d[i].Id < d[j].Id {
return true
}
if d[i].Id > d[j].Id {
return false
}
if d[i].Name < d[j].Name {
return true
}
if d[i].Name > d[j].Name {
return false
}
return true
}
|
package main
import "fmt"
func main() {
fmt.Println(len("hello this is i love the len function"))
fmt.Println("Something with a \n new line"[10]) // returns the byte representation of the value
fmt.Println("hello"[0]) // returns the byte representation of the value
fmt.Println("hhllo"[1]) // returns the byte representation of the value
}
// integer types uint8, uint16, uint32, uint64, int8, int16, int32 and int64
// float types float32 and float64, complex64, complex128
|
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
package kubernetes
import (
log "github.com/sirupsen/logrus"
appsv1 "k8s.io/api/apps/v1"
v1 "k8s.io/api/core/v1"
rbacv1 "k8s.io/api/rbac/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// TODO These interfaces do not follow best practices
// https://github.com/golang/go/wiki/CodeReviewComments#interfaces
// Client interface models client for interacting with kubernetes api server
type Client interface {
// ListPods returns Pods running on the passed in node.
ListPods(node *v1.Node) (*v1.PodList, error)
// ListPods returns all Pods running
ListAllPods() (*v1.PodList, error)
// ListNodes returns a list of Nodes registered in the api server.
ListNodes() (*v1.NodeList, error)
// ListNodesByOptions returns a list of Nodes registered in the api server.
ListNodesByOptions(opts metav1.ListOptions) (*v1.NodeList, error)
// ListServiceAccounts returns a list of Service Accounts in a namespace
ListServiceAccounts(namespace string) (*v1.ServiceAccountList, error)
// GetDaemonSet returns details about DaemonSet with passed in name.
GetDaemonSet(namespace, name string) (*appsv1.DaemonSet, error)
// GetDeployment returns a given deployment in a namespace.
GetDeployment(namespace, name string) (*appsv1.Deployment, error)
// GetNode returns details about node with passed in name.
GetNode(name string) (*v1.Node, error)
// UpdateNode updates the node in the api server with the passed in info.
UpdateNode(node *v1.Node) (*v1.Node, error)
// DeleteNode deregisters node in the api server.
DeleteNode(name string) error
// SupportEviction queries the api server to discover if it supports eviction, and returns supported type if it is supported.
SupportEviction() (string, error)
// DeleteClusterRole deletes the passed in ClusterRole.
DeleteClusterRole(role *rbacv1.ClusterRole) error
// DeleteDaemonSet deletes the passed in DaemonSet.
DeleteDaemonSet(ds *appsv1.DaemonSet) error
// DeleteDeployment deletes the passed in Deployment.
DeleteDeployment(ds *appsv1.Deployment) error
// DeletePod deletes the passed in pod.
DeletePod(pod *v1.Pod) error
// DeleteServiceAccount deletes the passed in service account.
DeleteServiceAccount(sa *v1.ServiceAccount) error
// EvictPod evicts the passed in pod using the passed in api version.
EvictPod(pod *v1.Pod, policyGroupVersion string) error
// WaitForDelete waits until all pods are deleted. Returns all pods not deleted and an error on failure.
WaitForDelete(logger *log.Entry, pods []v1.Pod, usingEviction bool) ([]v1.Pod, error)
// UpdateDeployment updates a deployment to match the given specification.
UpdateDeployment(namespace string, deployment *appsv1.Deployment) (*appsv1.Deployment, error)
}
// NodeLister is an interface implemented by Kubernetes clients
// that are able to list cluster nodes
type NodeLister interface {
ListNodes() (*v1.NodeList, error)
}
|
package main
import (
"golang.org/x/net/html"
"io"
"net/http"
"fmt"
"strings"
)
// Represents a DOM-Query
// Also represents recursively the whole query-chain
type Query struct {
tokenizer *html.Tokenizer //Contains the tokenized HTML DOM
hasPrevQuery bool
hasNextQuery bool // Has next query?
prevQuery *Query
nextQuery *Query // Next query object
match map[string]string //from the mapper some value(s)
result [][]html.Token // Contains token results from the matches, based on these the nextQuery will be executed
}
// Processing the search-term then launching the Document or Token search
func (q *Query) Find(term string) [][]html.Token {
q.ProcessSearchTerm(term)
return q.Search()
}
// Takes the decision weither to use RootSearch (DOM) or TokenSearch (List of elements)
// This method also takes care to return the results of the last (sub-)query
func (q *Query) Search() [][]html.Token {
var result [][]html.Token
if q.hasPrevQuery {
result = q.TokenSearch(q.prevQuery.result)
} else {
result = q.RootSearch()
}
if q.hasNextQuery {
result = q.nextQuery.Search()
}
return result
}
// Root search represents the search's entrypoint via the DOM
// Delegations for different search methods are made upon here
//
// Root search is only executed for the first query in the query-chain
// All subsequent searches are based on a array of previous resulted tokens
func (q *Query) RootSearch() [][]html.Token {
var finalTokens [][]html.Token
for {
// true by default
success := true
tokenType := q.tokenizer.Next()
if tokenType == html.ErrorToken {
break
}
token := q.tokenizer.Token()
success = q.Match(token, token.Type)
if success == true {
tokenChain := q.GetTokenChainFromTokenizer(token)
finalTokens = append(finalTokens, tokenChain)
}
}
q.result = finalTokens
return finalTokens
}
func (q *Query) TokenSearch(tokens [][]html.Token) [][]html.Token {
var finalTokens [][]html.Token
for _, tokenChain := range tokens {
for _, token := range tokenChain {
success := q.Match(token, token.Type)
if success == true {
//tokenChain := q.GetTokenChain(token, tokenChain)
finalTokens = append(finalTokens, tokenChain)
}
}
}
return finalTokens
}
// Checks for matches from the parsed search-terms for the given Query object
func (q *Query) Match(token html.Token, tokenType html.TokenType) bool {
success := true
for domType, domValue := range q.match {
switch {
case tokenType == html.ErrorToken:
return false
case tokenType == html.StartTagToken:
hasAttr := q.HasAttr(token, domType, domValue)
if !hasAttr {
// Attribute does not match
success = false
}
default:
success = false
}
}
return success
}
// Checks weither a (HTML) token has requested attribute matching specified value
func (q *Query) HasAttr(token html.Token, attrType string, searchValue string) bool {
for _, attr := range token.Attr {
if attr.Key == attrType && attr.Val == searchValue {
return true
}
}
return false
}
// Makes a snapshot of the whole token-chain (depth) until reaching the root again
// It takes actually the object wide tokenizer object. So each "Next()" has to be
// sended through "SearchTokens" again, in case another inner match may occure
func (q *Query) GetTokenChainFromTokenizer(rootToken html.Token) []html.Token {
var tokenChain []html.Token
depth := 1
// we expect rootToken to be a start-token, so that we can correctly measure the deepness
// of the result
if rootToken.Type != html.StartTagToken {
return nil
}
tokenChain = append(tokenChain, rootToken)
for {
tokenType := q.tokenizer.Next()
// just avoid errors
if tokenType == html.ErrorToken {
break
}
// we're digging one step deeper
if tokenType == html.StartTagToken {
depth++
}
// and one step out
if tokenType == html.EndTagToken {
depth--
}
// push new item to our chain
tokenChain = append(tokenChain, q.tokenizer.Token())
// by verifiying against smaller than zero we ensure that the loop
// makes one more turn to get the rootElements EndTagToken too
// a correct loop will always end in minus one
//
// TODO: this may cause errors by requesting self closing tags later on
if depth < 0 {
break
}
}
return tokenChain
}
// Splits the searchterm in a consecutive chain of search queries using search-maps
func (q *Query) ProcessSearchTerm(term string) {
var (
queries []string
subQuery *Query
)
// Only split into 2 args, because the next query has to handle its
// own subqueries by itself (recursion)
queries = strings.SplitN(term, " ", 2)
q.CreateSearchMap(queries[0])
// we got subselects
if len(queries) > 1 {
subQuery = new(Query)
// this will chain the recursively for each consecutive sub-query
subQuery.CreateSearchMap(queries[1])
}
}
func (q *Query) CreateSearchMap(query string) {
if q.match == nil {
q.match = make(map[string]string)
}
if strings.HasPrefix(query, ".") {
q.match["class"] = strings.TrimPrefix(query, ".")
} else if strings.HasPrefix(query, "#") {
q.match["id"] = strings.TrimPrefix(query, "#")
}
}
// Loads the reader's input into tokenized HTML.
// It can be used to iterate through, finding / changing values.
func (q *Query) Load(reader io.Reader) {
q.tokenizer = html.NewTokenizer(reader);
}
func main() {
resp, err := http.Get("https://www.google.de/")
if err == nil {
q := new(Query)
q.Load(resp.Body)
result := q.Find(".gb1")
fmt.Println(result)
defer resp.Body.Close()
}
}
|
// Implementation of default update service.
//
// @author TSS
package service
import (
"os"
"path/filepath"
"github.com/mashmb/1pass/1pass-core/core/domain"
"github.com/mashmb/1pass/1pass-core/port/out"
)
type dfltUpdateService struct {
updater out.Updater
}
func NewDfltUpdateService(updater out.Updater) *dfltUpdateService {
return &dfltUpdateService{
updater: updater,
}
}
func (s *dfltUpdateService) CheckForUpdate(period, timeout int, force bool, configDir string) (*domain.UpdateInfo, error) {
if !force {
shouldCheck := s.updater.ShouldCheck(period, configDir)
if !shouldCheck {
return nil, domain.ErrNoUpdate
}
}
info, err := s.updater.CheckForUpdate(int64(timeout))
if err != nil {
return nil, err
}
if info == nil || !info.Newer {
s.updater.CheckTimestamp(configDir)
return nil, domain.ErrNoUpdate
}
s.updater.CheckTimestamp(configDir)
return info, nil
}
func (s *dfltUpdateService) Update(timeout int, stage func(int)) error {
info, err := s.updater.CheckForUpdate(int64(timeout))
if err != nil {
return err
}
if info == nil {
return domain.ErrNoUpdate
}
if !info.Newer {
return domain.ErrNoUpdate
} else {
stage(1)
if err := os.RemoveAll(domain.CacheDir); err != nil {
return err
}
if err := os.MkdirAll(domain.CacheDir, 0700); err != nil {
return err
}
archive := filepath.Join(domain.CacheDir, domain.Archive)
checksum := filepath.Join(domain.CacheDir, domain.Checksum)
stage(2)
if err := s.updater.DownloadFile(archive, info.ArchiveUrl, int64(timeout)); err != nil {
return err
}
stage(3)
if err := s.updater.DownloadFile(checksum, info.ChecksumUrl, int64(timeout)); err != nil {
return err
}
stage(4)
if err := s.updater.ExtractArchive(archive, domain.CacheDir); err != nil {
return err
}
binary := filepath.Join(domain.CacheDir, domain.AppName)
stage(5)
if err := s.updater.ValidateChecksum(binary, checksum); err != nil {
return err
}
stage(6)
if err := s.updater.ReplaceBinary(binary); err != nil {
return err
}
stage(7)
if err := os.RemoveAll(domain.CacheDir); err != nil {
return err
}
}
return nil
}
|
package beacon_test
import (
beacon "."
"github.com/pkg/errors"
"sync"
"testing"
"time"
)
// MockRuntime emulates a real Runtime implementation.
type MockRuntime struct {
Events chan *beacon.Event
}
// EmitEvents returns the MockRuntime.Events channel.
func (r *MockRuntime) EmitEvents() (<-chan *beacon.Event, error) {
return r.Events, nil
}
func NewRuntime() *MockRuntime {
return &MockRuntime{Events: make(chan *beacon.Event)}
}
// Close is a noop.
func (r *MockRuntime) Close() error {
close(r.Events)
return nil
}
// MockBackend emulates a real Backend implementation.
type MockBackend struct {
Events chan *beacon.Event
}
func NewBackend() *MockBackend {
return &MockBackend{Events: make(chan *beacon.Event)}
}
// ProcessEvent adds the event to the backend.
func (b *MockBackend) ProcessEvent(event *beacon.Event) error {
b.Events <- event
return nil
}
// Events waits up to `timeout` for `n` events and returns them. Return an
// error if the timeout occurs before recieving the requested number of events.
func (b *MockBackend) WaitForEvents(n int, timeout time.Duration) ([]*beacon.Event, error) {
wait := time.After(timeout)
events := make([]*beacon.Event, 0, n)
var err error
Loop:
for i := 0; i < n; i++ {
select {
case event := <-b.Events:
events = append(events, event)
case <-wait:
err = errors.New("timed out waiting for events")
break Loop
}
}
return events, err
}
// Close is a noop.
func (b *MockBackend) Close() error {
return nil
}
func ContainersEqual(a *beacon.Container, b *beacon.Container) error {
if a.ID != b.ID {
return errors.Errorf("container.ID inequal: %s != %s", a.ID, b.ID)
}
if a.Service != b.Service {
return errors.Errorf("container.Service inequal: %s != %s", a.Service, b.Service)
}
if len(a.Labels) != len(b.Labels) {
return errors.Errorf("container.Labels inequal length: %d != %d", len(a.Labels), len(b.Labels))
}
for k, v1 := range a.Labels {
if v2, ok := b.Labels[k]; !ok || v1 != v2 {
return errors.Errorf("container.Labels[%s] inequal: %s != %s", k, v1, v2)
}
}
if len(a.Bindings) != len(b.Bindings) {
return errors.Errorf("container.bindings have length: %d != %d", len(a.Bindings), len(b.Bindings))
}
for n, b1 := range a.Bindings {
b2 := b.Bindings[n]
if b1.HostPort != b2.HostPort || b1.ContainerPort != b2.ContainerPort || b1.Protocol != b2.Protocol {
return errors.Errorf("container.Bindings[%d] inequal: %+v != %+v", n, b1, b2)
}
}
return nil
}
func ContainerSetsEqual(a []*beacon.Container, b []*beacon.Container) error {
if len(a) != len(b) {
return errors.Errorf("container sets inequal length: %d != %d", len(a), len(b))
}
newSet := func(arr []*beacon.Container) map[string]*beacon.Container {
set := make(map[string]*beacon.Container, len(arr))
for _, cntr := range arr {
set[cntr.ID] = cntr
}
return set
}
aSet := newSet(a)
bSet := newSet(b)
for id, c1 := range aSet {
if c2, ok := bSet[id]; !ok {
return errors.Errorf("container[%s] not in both sets", id)
} else if err := ContainersEqual(c1, c2); err != nil {
return errors.Wrapf(err, "container[%s] inequal", id)
}
}
return nil
}
func EventsEqual(a *beacon.Event, b *beacon.Event) error {
if a.Action != b.Action {
return errors.Errorf("event.Action inequal: %s != %s", a.Action, b.Action)
}
if err := ContainersEqual(a.Container, b.Container); err != nil {
return errors.Wrap(err, "event.Container inequal")
}
return nil
}
func EventArraysEqual(a []*beacon.Event, b []*beacon.Event) error {
if len(a) != len(b) {
return errors.Errorf("event arrays have inequal length: %d != %d", len(a), len(b))
}
for n := range a {
if err := EventsEqual(a[n], b[n]); err != nil {
return errors.Wrapf(err, "events[%d] inequal", n)
}
}
return nil
}
// Test that beacon.New raises an error when provided invalid inputs.
func TestBeaconNewError(t *testing.T) {
t.Parallel()
if _, err := beacon.New(nil, []beacon.Route{}); err == nil {
t.Error("expected error for empty arguments")
}
if _, err := beacon.New(NewRuntime(), []beacon.Route{}); err == nil {
t.Error("expected error for empty route list")
}
filter := beacon.NewFilter(nil)
route := beacon.NewRoute(filter, NewBackend())
if _, err := beacon.New(nil, []beacon.Route{route}); err == nil {
t.Error("expected error for nil runtime")
}
}
func TestBeaconRunOneBackend(t *testing.T) {
t.Parallel()
runtime := NewRuntime()
backend := NewBackend()
route := beacon.NewRoute(nil, backend)
bcn, err := beacon.New(runtime, []beacon.Route{route})
if err != nil {
t.Fatal(err)
}
wg := &sync.WaitGroup{}
wg.Add(1)
go func() {
defer wg.Done()
if err := bcn.Run(); err != nil {
t.Fatal(err)
}
}()
queueEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "aye",
"b": "bee",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Update,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "eh",
"c": "see",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Stop,
Container: &beacon.Container{
ID: "123456",
},
},
}
wantEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "aye",
"b": "bee",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Update,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "eh",
"c": "see",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Stop,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "eh",
"c": "see",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
}
go func() {
for _, event := range queueEvents {
runtime.Events <- event
}
}()
haveEvents, err := backend.WaitForEvents(3, 5*time.Second)
if err != nil {
t.Error(err)
}
if err := EventArraysEqual(haveEvents, wantEvents); err != nil {
t.Error(err)
}
if err := bcn.Close(); err != nil {
t.Fatal(err)
}
wg.Wait()
}
func TestBeaconRunTwoBackends(t *testing.T) {
t.Parallel()
runtime := NewRuntime()
backend1 := NewBackend()
backend2 := NewBackend()
routes := []beacon.Route{
beacon.NewRoute(nil, backend1),
beacon.NewRoute(nil, backend2),
}
bcn, err := beacon.New(runtime, routes)
if err != nil {
t.Fatal(err)
}
runWait := &sync.WaitGroup{}
runWait.Add(1)
go func() {
defer runWait.Done()
if err := bcn.Run(); err != nil {
t.Fatal(err)
}
}()
queueEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "aye",
"b": "bee",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Update,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "eh",
"c": "see",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Stop,
Container: &beacon.Container{
ID: "123456",
},
},
}
wantEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "aye",
"b": "bee",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Update,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "eh",
"c": "see",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Stop,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "eh",
"c": "see",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
}
go func() {
for _, event := range queueEvents {
runtime.Events <- event
}
}()
eventWait := &sync.WaitGroup{}
checkEvents := func(backend *MockBackend, wantEvents []*beacon.Event) {
defer eventWait.Done()
haveEvents, err := backend.WaitForEvents(3, 5*time.Second)
if err != nil {
t.Error(err)
}
if err := EventArraysEqual(haveEvents, wantEvents); err != nil {
t.Error(err)
}
}
eventWait.Add(2)
go checkEvents(backend1, wantEvents)
go checkEvents(backend2, wantEvents)
eventWait.Wait()
if err := bcn.Close(); err != nil {
t.Fatal(err)
}
runWait.Wait()
}
func TestBeaconRunFilterBackends(t *testing.T) {
t.Parallel()
runtime := NewRuntime()
backend1 := NewBackend()
backend2 := NewBackend()
filter1, err := beacon.ParseFilter("color=blue")
if err != nil {
t.Fatal(err)
}
filter2, err := beacon.ParseFilter("color=green")
if err != nil {
t.Fatal(err)
}
routes := []beacon.Route{
beacon.NewRoute(filter1, backend1),
beacon.NewRoute(filter2, backend2),
}
bcn, err := beacon.New(runtime, routes)
if err != nil {
t.Fatal(err)
}
runWait := &sync.WaitGroup{}
runWait.Add(1)
go func() {
defer runWait.Done()
if err := bcn.Run(); err != nil {
t.Fatal(err)
}
}()
container1 := &beacon.Container{
ID: "1",
Service: "example",
Labels: map[string]string{
"color": "blue",
},
Bindings: []*beacon.Binding{},
}
container2 := &beacon.Container{
ID: "2",
Service: "example",
Labels: map[string]string{
"color": "green",
},
Bindings: []*beacon.Binding{},
}
queueEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: container1,
},
{
Action: beacon.Start,
Container: container2,
},
}
wantBlueEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: container1,
},
}
wantGreenEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: container2,
},
}
go func() {
for _, event := range queueEvents {
runtime.Events <- event
}
}()
eventWait := &sync.WaitGroup{}
checkEvents := func(backend *MockBackend, wantEvents []*beacon.Event) {
defer eventWait.Done()
haveEvents, err := backend.WaitForEvents(1, 5*time.Second)
if err != nil {
t.Error(err)
}
if err := EventArraysEqual(haveEvents, wantEvents); err != nil {
t.Error(err)
}
}
eventWait.Add(2)
go checkEvents(backend1, wantBlueEvents)
go checkEvents(backend2, wantGreenEvents)
eventWait.Wait()
if err := bcn.Close(); err != nil {
t.Fatal(err)
}
runWait.Wait()
}
func TestBeaconContainers(t *testing.T) {
t.Parallel()
runtime := NewRuntime()
backend := NewBackend()
routes := []beacon.Route{
beacon.NewRoute(nil, backend),
}
bcn, err := beacon.New(runtime, routes)
if err != nil {
t.Fatal(err)
}
wg := &sync.WaitGroup{}
wg.Add(1)
go func() {
defer wg.Done()
if err := bcn.Run(); err != nil {
t.Fatal(err)
}
}()
container1 := &beacon.Container{
ID: "1",
Service: "example",
Labels: map[string]string{
"color": "red",
},
Bindings: []*beacon.Binding{},
}
container2 := &beacon.Container{
ID: "2",
Service: "example",
Labels: map[string]string{
"color": "green",
},
Bindings: []*beacon.Binding{},
}
container3 := &beacon.Container{
ID: "3",
Service: "example",
Labels: map[string]string{
"color": "blue",
},
Bindings: []*beacon.Binding{},
}
go func() {
runtime.Events <- &beacon.Event{
Action: beacon.Start,
Container: container1,
}
runtime.Events <- &beacon.Event{
Action: beacon.Start,
Container: container2,
}
runtime.Events <- &beacon.Event{
Action: beacon.Start,
Container: container3,
}
}()
if _, err := backend.WaitForEvents(3, 5*time.Second); err != nil {
t.Fatal(err)
}
haveContainers := bcn.Containers(nil)
wantContainers := []*beacon.Container{
container1,
container2,
container3,
}
if err := ContainerSetsEqual(haveContainers, wantContainers); err != nil {
t.Error(err)
}
filter, err := beacon.ParseFilter("color=blue")
if err != nil {
t.Fatal(err)
}
haveContainers = bcn.Containers(filter)
wantContainers = []*beacon.Container{
container3,
}
if err := ContainerSetsEqual(haveContainers, wantContainers); err != nil {
t.Error(err)
}
if err := bcn.Close(); err != nil {
t.Fatal(err)
}
wg.Wait()
}
func TestBeaconRunOneStopTwice(t *testing.T) {
t.Parallel()
runtime := NewRuntime()
backend := NewBackend()
route := beacon.NewRoute(nil, backend)
bcn, err := beacon.New(runtime, []beacon.Route{route})
if err != nil {
t.Fatal(err)
}
runWait := &sync.WaitGroup{}
runWait.Add(1)
go func() {
defer runWait.Done()
if err := bcn.Run(); err != nil {
t.Fatal(err)
}
}()
queueEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "aye",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Stop,
Container: &beacon.Container{
ID: "123456",
},
},
{
Action: beacon.Stop,
Container: &beacon.Container{
ID: "123456",
},
},
}
wantEvents := []*beacon.Event{
{
Action: beacon.Start,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "aye",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
{
Action: beacon.Stop,
Container: &beacon.Container{
ID: "123456",
Service: "example",
Labels: map[string]string{
"a": "aye",
},
Bindings: []*beacon.Binding{
{
HostIP: "127.0.0.1",
HostPort: 56291,
ContainerPort: 80,
Protocol: beacon.TCP,
},
{
HostIP: "127.0.0.1",
HostPort: 56292,
ContainerPort: 443,
Protocol: beacon.TCP,
},
},
},
},
}
eventWait := &sync.WaitGroup{}
eventWait.Add(1)
go func() {
defer eventWait.Done()
for _, event := range queueEvents {
runtime.Events <- event
}
}()
haveEvents, err := backend.WaitForEvents(2, 5*time.Second)
if err != nil {
t.Fatal(err)
}
if err := EventArraysEqual(haveEvents, wantEvents); err != nil {
t.Fatal(err)
}
eventWait.Wait()
if err := bcn.Close(); err != nil {
t.Fatal(err)
}
runWait.Wait()
}
|
package service
import (
"heroku-backend-a-cocreate/dto"
"heroku-backend-a-cocreate/helper/bc"
"heroku-backend-a-cocreate/model"
"heroku-backend-a-cocreate/repository"
)
type AuthService interface {
VerifyCredential(email, password string) interface{}
CreateUser(user dto.RegisterDTO) model.User
IsDuplicateEmail(email string) bool
}
func VerifyCredential(email, password string) interface{} {
res := repository.VerifyCredential(email, password)
if val, ok := res.(model.User); ok {
comparePass := bc.ComparePass(val.Password, password)
if val.Email == email && comparePass {
return res
}
return false
}
return false
}
func CreateUser(user dto.RegisterDTO) model.Enrollment {
enrollmentUser := model.Enrollment{
NamaLengkap: user.Name,
Email: user.Email,
TopikDiminati: user.TopikDiminati,
}
userToCreate := model.User{
Name: user.Name,
Email: user.Email,
Password: user.Password,
RoleID: uint(user.RoleID),
}
res := repository.InsertUser(userToCreate, enrollmentUser)
return res
}
func IsDuplicateEmail(email string) bool {
err := repository.IsDuplicateEmail(email).Error
return err == nil
}
|
package ginplugin
import (
"crypto/rand"
"encoding/base32"
"io"
"strings"
"github.com/sirupsen/logrus"
)
var sessionUtilsLogger = logrus.New()
func NewSessionId() string {
k := make([]byte, 32)
if _, err := io.ReadFull(rand.Reader, k); err != nil {
sessionUtilsLogger.Errorf("generate session id failed:%s", err)
panic(err)
}
return strings.TrimRight(base32.StdEncoding.EncodeToString(k), "=")
}
|
package main
import (
"fmt"
"encoding/hex"
"github.com/lt/go-cryptopals/cryptopals"
)
func main() {
expected, _ := hex.DecodeString("0b3637272a2b2e63622c2e69692a23693a2a3c6324202d623d63343c2a26226324272765272a282b2f20430a652e2c652a3124333a653e2b2027630c692b20283165286326302e27282f")
input := []byte("Burning 'em, if you ain't quick and nimble\nI go crazy when I hear a cymbal")
actual := cryptopals.XorRepeatingBytes(input, []byte("ICE"))
fmt.Println("Expected:", hex.EncodeToString(expected))
fmt.Println("Actual: ", hex.EncodeToString(actual))
}
|
package rpc
import (
"context"
"fmt"
"github.com/benka-me/users/go-pkg/jwt"
"github.com/benka-me/users/go-pkg/users"
)
func (app *App) Auth(ctx context.Context, req *users.Token) (*users.IsAuth, error) {
err := jwt.CheckJwt(req.Val)
fmt.Println("auth err:", err, req.Val)
return &users.IsAuth{Val: err == nil}, nil
}
|
package honeycombio
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
)
func TestQueryAnnotations(t *testing.T) {
ctx := context.Background()
c := newTestClient(t)
dataset := testDataset(t)
var queryAnnotation *QueryAnnotation
var err error
query, err := c.Queries.Create(ctx, dataset, &QuerySpec{
Calculations: []CalculationSpec{
{
Op: "COUNT",
},
},
})
if err != nil {
t.Fatal(err)
}
t.Run("Create", func(t *testing.T) {
data := &QueryAnnotation{
Name: "Query created by a test",
Description: "This derived column is created by a test",
QueryID: *query.ID,
}
queryAnnotation, err = c.QueryAnnotations.Create(ctx, dataset, data)
if err != nil {
t.Fatal(err)
}
data.ID = queryAnnotation.ID
assert.Equal(t, data, queryAnnotation)
})
t.Run("List", func(t *testing.T) {
queryAnnotations, err := c.QueryAnnotations.List(ctx, dataset)
if err != nil {
t.Fatal(err)
}
assert.Contains(t, queryAnnotations, *queryAnnotation, "could not find QueryAnnotation with List")
})
t.Run("Get", func(t *testing.T) {
result, err := c.QueryAnnotations.Get(ctx, dataset, queryAnnotation.ID)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, *queryAnnotation, *result)
})
t.Run("Update", func(t *testing.T) {
// change all the fields to test
data := &QueryAnnotation{
ID: queryAnnotation.ID,
Name: "This is a new name for the query created by a test",
Description: "This is a new description",
QueryID: *query.ID,
}
queryAnnotation, err = c.QueryAnnotations.Update(ctx, dataset, data)
if err != nil {
t.Fatal(err)
}
data.ID = queryAnnotation.ID
assert.Equal(t, data, queryAnnotation)
})
t.Run("Delete", func(t *testing.T) {
err = c.QueryAnnotations.Delete(ctx, dataset, queryAnnotation.ID)
if err != nil {
t.Fatal(err)
}
})
t.Run("Get_notFound", func(t *testing.T) {
_, err := c.QueryAnnotations.Get(ctx, dataset, queryAnnotation.ID)
assert.Equal(t, ErrNotFound, err)
})
}
|
package main
import (
"math"
"strconv"
)
var columnID int = 1
var floorRequestButtonID int = 1
var floor int = 1
type Battery struct {
ID int
status string
columnsList []Column
floorRequestButtonsList []FloorRequestButton
}
func NewBattery(_id, _amountOfColumns, _amountOfFloors, _amountOfBasements, _amountOfElevatorPerColumn int) *Battery {
b := new(Battery)
b.ID = _id
b.status = "online"
if _amountOfBasements > 0 {
b.createBasementFloorRequestButtons(_amountOfBasements)
b.createBasmentColumn(_amountOfBasements, _amountOfElevatorPerColumn)
_amountOfColumns--
}
b.createFloorRequestButtons(_amountOfFloors)
b.createColumns(_amountOfColumns, _amountOfFloors, _amountOfElevatorPerColumn)
return b
}
func (b *Battery) createBasmentColumn(_amountOfBasements int, _amountOfElevatorPerColumn int) { // This will create the column for the basements
var servedFloors []int
floor = -1
for i := 0; i < _amountOfBasements; i++ {
servedFloors = append(servedFloors, floor)
floor--
}
column := NewColumn(strconv.Itoa(columnID), "online", _amountOfBasements, _amountOfElevatorPerColumn, servedFloors, true)
b.columnsList = append(b.columnsList, *column)
columnID++
}
func (b *Battery) createColumns(_amountOfColumns int, _amountOfFloors int, _amountOfElevatorPerColumn int) { // this will create the columns with thier floors
var amountOfFloorsPerColumn = int(math.Round(float64(_amountOfFloors / _amountOfColumns)))
floor = 1
for i := 0; i < _amountOfColumns; i++ {
var servedFloors []int
for j := 0; j < amountOfFloorsPerColumn; j++ {
if floor <= _amountOfFloors {
servedFloors = append(servedFloors, floor)
floor++
}
}
column := NewColumn(strconv.Itoa(columnID), "online", _amountOfFloors, _amountOfElevatorPerColumn, servedFloors, false)
b.columnsList = append(b.columnsList, *column)
columnID++
}
}
func (b *Battery) createFloorRequestButtons(_amountOfFloors int) {
var buttonFloor = 1
for i := 0; i < _amountOfFloors; i++ {
floorRequestButton := NewFloorRequestButton(floorRequestButtonID, "OFF", buttonFloor, "up")
b.floorRequestButtonsList = append(b.floorRequestButtonsList, *floorRequestButton)
buttonFloor++
floorRequestButtonID++
}
}
func (b *Battery) createBasementFloorRequestButtons(amountOfBasements int) {
var buttonFloor = -1
for i := 0; i < amountOfBasements; i++ {
basementFloorRequestButton := NewFloorRequestButton(floorRequestButtonID, "OFF", buttonFloor, "down")
b.floorRequestButtonsList = append(b.floorRequestButtonsList, *basementFloorRequestButton)
buttonFloor--
floorRequestButtonID++
}
}
func containsElement(requestedFloor int, servedFloorsList []int) bool {
for _, floor := range servedFloorsList {
if floor == requestedFloor {
return true
}
}
return false
}
func (b *Battery) findBestColumn(_requestedFloor int) *Column {
for _, column := range b.columnsList {
if containsElement(_requestedFloor, column.servedFloorsList) {
return &column
}
}
return nil
}
//Simulate when a user press a button at the lobby
func (b *Battery) assignElevator(_requestedFloor int, _direction string) (*Column, *Elevator) {
column := *b.findBestColumn(_requestedFloor)
elevator := column.findElevator(1, _direction)
elevator.addNewRequest(1)
elevator.move()
elevator.addNewRequest(_requestedFloor)
elevator.move()
return &column, elevator
}
|
package batcave
//import (
// "encoding/gob"
//)
const file = "/tmp/tasks.gob"
// TaskDatabase is an alias for a map, where the key is userID, and value is list of tasks
type TaskDatabase map[string][]string
// NewTaskDatabase creates an new object for this type
func NewTaskDatabase() TaskDatabase {
return make(map[string][]string)
}
// AddTaskForUser adds a new task for the specified user.
// Will create the user if it does not exist.
func (t TaskDatabase) AddTaskForUser(user string, task string) {
var tasks []string
if val, ok := t[user]; ok {
tasks = val
}
t[user] = append(tasks, task)
}
|
package main
/*
NOTE:
- $ go test //to run tests
UNIT TEST
- $ go test -cover //to check test coverage
- $ go tool cover -html=coverage.out //generate coverage.out file which is used to generate a HTML page which shows exactly what lines have been covered
BENCHMARK TEST
- $ go test -bench=. //runs all benchmarks within our package
- $ go test -run=Calculate -bench=. //runs all bench test with Calculate in test function name
TEST GENERATOR: https://github.com/cweill/gotests
*/
import (
"testing"
)
func Test_createDealFromScrapedText(t *testing.T) {
var deal = createDealFromScrapedText("") //simple tests
if deal.Name != "" { //check if name is still empty
t.Error("Expected empty Deal")
}
if deal.CurrentPrice != 0 { //check if name is still empty
t.Error("Expected empty Deal")
}
if deal.PreviousPrice != 0 { //check if name is still empty
t.Error("Expected empty Deal")
}
}
func TestCalculate(t *testing.T) {
if Calculate(2) != 4 {
t.Error("Expected 2 + 2 to equal 4")
}
}
func TestTableCalculate(t *testing.T) { //T is a type passed to Test functions to manage test state and support formatted test logs
var tests = []struct {
input int
expected int
}{
{2, 4},
{-1, 1},
{0, 2},
{-5, -3},
{99999, 100001},
}
for _, test := range tests {
if output := Calculate(test.input); output != test.expected {
t.Error("Test Failed: {} inputted, {} expected, recieved: {}", test.input, test.expected, output)
}
}
}
func benchmarkCalculate(input int, b *testing.B) { //B is a type passed to Benchmark functions to manage benchmark timing and to specify the number of iterations to run
for n := 0; n < b.N; n++ {
Calculate(input)
}
}
func BenchmarkCalculate100(b *testing.B) { benchmarkCalculate(100, b) }
func BenchmarkCalculateNegative100(b *testing.B) { benchmarkCalculate(-100, b) }
func BenchmarkCalculateNegative1(b *testing.B) { benchmarkCalculate(-1, b) }
|
package main
import (
"encoding/json"
"fmt"
"net"
"strconv"
"time"
)
const (
STEP_WAIT_MS = 75
)
type Room struct {
Connections []net.Conn
Name string
}
type Game struct {
Players []NetworkPlayer
Step int
}
type NetworkPlayer struct {
Connection net.Conn
Alive bool
Moves []Move
MoveChannel chan Move
Name string
Score int
}
func HandleRoom(room Room) {
game := NewGame(room.Connections)
for {
game.Play()
time.Sleep(time.Second * 1)
game.Reset()
}
}
func (g *Game) Reset() {
for i := range g.Players {
g.Players[i].Alive = true
g.Players[i].Moves = []Move{GetStartingSpot(i)}
}
}
func NewGame(connections []net.Conn) Game {
g := Game{}
g.Players = make([]NetworkPlayer, len(connections))
for i := range g.Players {
g.Players[i].Connection = connections[i]
g.Players[i].Alive = true
g.Players[i].MoveChannel = make(chan Move, 100)
g.Players[i].Moves = []Move{GetStartingSpot(i)}
g.Players[i].Name = "Player " + strconv.Itoa(i)
g.Players[i].Score = 0
go MoveListener(g.Players[i].Connection, g.Players[i].MoveChannel)
}
return g
}
func MoveListener(conn net.Conn, moveChannel chan Move) {
conn.SetDeadline(time.Time{})
dec := json.NewDecoder(conn)
for {
var m Move
err := dec.Decode(&m)
if err != nil {
panic(err)
}
moveChannel <- m
}
}
func (g *Game) GetState(step int) (s State) {
s.Step = step
players := make([]PlayerState, len(g.Players))
for i := range g.Players {
players[i].Alive = g.Players[i].Alive
players[i].Name = g.Players[i].Name
players[i].Score = g.Players[i].Score
//return last move, for dead this may be previous
if players[i].Alive {
players[i].Move = g.Players[i].Moves[step]
} else {
players[i].Move = g.Players[i].Moves[len(g.Players[i].Moves)-1]
}
}
s.Players = players
return s
}
func (g *Game) Winner() int {
alivePlayers := 0
lastAlive := -2
for i, player := range g.Players {
if player.Alive {
alivePlayers++
lastAlive = i
}
}
if alivePlayers >= 2 {
return -1
}
return lastAlive
}
func (g *Game) Play() {
g.Step = 1
for g.Winner() == -1 { // GameOver
prevState := g.GetState(g.Step - 1)
if SERVER_DEBUG {
fmt.Println("Prev State", prevState)
}
for i, player := range g.Players {
prevState.PlayerIndex = i
out := StateToJSON(prevState)
player.Connection.Write(out)
}
// wait for new moves
time.Sleep(STEP_WAIT_MS * time.Millisecond)
// guess next move
for i := range g.Players {
if g.Players[i].Alive {
g.Players[i].Moves = append(g.Players[i].Moves, UpdateMove(g.Players[i].Moves[g.Step-1].D, g.Players[i].Moves[g.Step-1]))
} else {
continue
}
exit := false
for {
select {
case move := <-g.Players[i].MoveChannel:
// Only take direction, incase of fowl play, CACAWWWW
move = UpdateMove(move.D, g.Players[i].Moves[g.Step-1])
g.Players[i].Moves[g.Step] = move
default:
exit = true
}
if exit {
break
}
}
}
g.ValidateLastStep()
g.Step++
}
winner := g.Winner()
if winner != -2 {
g.Players[winner].Score++
}
// Game over, send last state, with updated score
prevState := g.GetState(g.Step - 1)
for i, player := range g.Players {
prevState.PlayerIndex = i
out := StateToJSON(prevState)
player.Connection.Write(out)
}
}
func (g *Game) ValidateLastStep() {
for i, player := range g.Players {
if !player.Alive {
continue
}
lastMove := player.Moves[g.Step]
if lastMove.X <= 0 || lastMove.Y <= 0 || lastMove.X >= ARENA_WIDTH-1 || lastMove.Y >= ARENA_HEIGHT-1 {
g.Players[i].Alive = false
}
for otherPlayerIndex, otherPlayer := range g.Players {
for otherMoveIndex, otherMove := range otherPlayer.Moves {
if lastMove.X == otherMove.X && lastMove.Y == otherMove.Y && !(otherMoveIndex == g.Step && otherPlayerIndex == i) {
g.Players[i].Alive = false
}
}
}
}
}
|
package main
import (
"log"
"time"
"net/url"
cmc "github.com/coincircle/go-coinmarketcap"
"fmt"
"telegram-bot-api"
"strings"
)
func checkTransactions() {
t := time.Now().UTC().Format(time.RFC3339)
for {
time.Sleep(1 * time.Minute)
log.Print("Started checking")
rows, _ := db.Table("wallets").Rows()
for rows.Next() {
var wallet Wallet
db.ScanRows(rows, &wallet)
txs := getTransactions(wallet.Address, t)
if len(txs) > 0 {
go sendNotifications(txs, wallet)
}
}
t = time.Now().UTC().Format(time.RFC3339)
}
}
func checkTwitter() {
for {
v := url.Values{}
v.Add("exclude_replies", "true")
v.Add("include_rts", "false")
for _, val := range config.TwitterAccounts {
v.Add("screen_name", val)
since := int64ToString(sinceTwitter[val])
v.Add("since_id", since)
searchResult, err := twitter.GetUserTimeline(v)
if err != nil {
log.Print(err)
}
for _, val := range searchResult {
text := val.User.Name+"("+val.User.ScreenName+"):\n"+val.FullText
sendMessage(config.ChannelId, text, nil)
sendAllGroups(text)
}
if len(searchResult) > 0 {
sinceTwitter[val] = searchResult[0].Id
}
}
time.Sleep(1 * time.Minute)
}
}
func checkPrice() {
for {
var t TimeForSending
readJson(&t, "time.json")
if t.anyTime() {
var old Prices
readJson(&old, "prices.json")
coin, err := cmc.Ticker(&cmc.TickerOptions{
Symbol: "XRP",
Convert: "USD",
})
if err != nil {
log.Print(err)
}
var textTemplate string
if coin.Quotes["USD"].PercentChange24H >= 0 {
textTemplate = phrases[23]
} else {
textTemplate = phrases[24]
}
text := fmt.Sprintf(textTemplate,
float64WithSign(coin.Quotes["USD"].PercentChange24H),
float64ToStringPrec3(coin.Quotes["USD"].Price))
textForUrl := strings.Replace(
strings.Replace(text, "*", "", -1), " ", " $", 1) +
" (via @XRPwatch)" + phrases[20]
myUrl, err := url.Parse(config.TwitterShareURL)
if err != nil {
log.Print(err)
}
parameters := url.Values{}
parameters.Add("text", textForUrl)
myUrl.RawQuery = parameters.Encode()
urlStr := myUrl.String()
keyboard := checkPriceKeyboard
keyboard.InlineKeyboard[0][1].URL = &urlStr
if time.Now().After(t.ChannelTime) {
sendMessage(config.ChannelId, text, nil)
t.ChannelTime =
t.ChannelTime.Add(time.Duration(config.ChannelHours) * time.Hour)
}
if time.Now().After(t.GroupTime) {
sendAllGroups(text)
t.GroupTime =
t.GroupTime.Add(time.Duration(config.GroupHours) * time.Hour)
}
if time.Now().After(t.UsersTime) {
userText := fmt.Sprintf(textTemplate,
float64WithSign(coin.Quotes["USD"].PercentChange24H),
"%v")
userText = strings.Replace(userText, "%", "%%", 1)
go convertAndSendAllUsers(userText, coin.Quotes["USD"].Price, keyboard)
t.UsersTime =
t.UsersTime.Add(time.Duration(config.UsersHours) * time.Hour)
}
if time.Now().After(t.TwitterTime) {
text = strings.Replace(text, "*", "", -1)
text = strings.Replace(text, " ", " $", 1)
tweet(text)
t.TwitterTime =
t.TwitterTime.Add(time.Duration(config.TwitterHours) * time.Hour)
}
writeJson(&old, "prices.json")
writeJson(&t, "time.json")
}
time.Sleep(1 * time.Hour)
}
}
func checkPeriodsPrice() {
for {
var old Prices
readJson(&old, "prices.json")
price, err := cmc.Price(&cmc.PriceOptions{
Symbol: "XRP",
Convert: "USD",
})
if err != nil {
log.Print(err)
}
templateHigh := "🚀 XRP on a new *%v high* @ %v USD"
templateLow := "📉 XRP on a new *%v low* @ %v USD"
var textWOprice, textFinal string
//HIGHS CHECK
allTimeHigh := true
threeMonthsHigh := true
monthHigh := true
weekHigh := true
if old.Highs.AllTime > price {
allTimeHigh = false
}
if allTimeHigh == false {
for _, val := range old.Highs.ThreeMonths {
if val > price {
threeMonthsHigh = false
}
}
if threeMonthsHigh == false {
for _, val := range old.Highs.Month {
if val > price {
monthHigh = false
}
}
if monthHigh == false {
for _, val := range old.Highs.Week {
if val > price {
weekHigh = false
}
}
if weekHigh == true {
//post week
textWOprice = fmt.Sprintf(templateHigh, "7d", "%v")
}
} else {
//post month
textWOprice = fmt.Sprintf(templateHigh, "30d", "%v")
}
} else {
//post 3m
textWOprice = fmt.Sprintf(templateHigh, "3m", "%v")
}
} else {
//post allTime
textWOprice = fmt.Sprintf(templateHigh, "all-time", "%v")
}
textFinal = fmt.Sprintf(textWOprice, float64ToStringPrec3(price))
if !allTimeHigh && !threeMonthsHigh && !monthHigh && !weekHigh {
//LOWS CHECK
threeMonthsLow := true
monthLow := true
weekLow := true
for _, val := range old.Lows.ThreeMonths {
if val < price {
threeMonthsLow = false
}
}
if threeMonthsLow == false {
for _, val := range old.Lows.Month {
if val < price {
monthLow = false
}
}
if monthLow == false {
for _, val := range old.Lows.Week {
if val < price {
weekLow = false
}
}
if weekLow == true {
//post week
textWOprice = fmt.Sprintf(templateLow, "7d", "%v")
}
} else {
//post month
textWOprice = fmt.Sprintf(templateLow, "30d", "%v")
}
} else {
//post 3m
textWOprice = fmt.Sprintf(templateLow, "3m", "%v")
}
if weekLow == false {
textFinal = ""
} else {
textFinal = fmt.Sprintf(textWOprice, float64ToStringPrec3(price))
}
}
if textFinal != "" {
sendMessage(config.ChannelId, textFinal, nil)
sendAllGroups(textFinal)
convertAndSendAllUsers(textWOprice, price, nil)
textFinal = strings.Replace(textFinal, "*", "", -1)
textFinal = strings.Replace(textFinal, " ", " $", 1)
tweet(textFinal)
}
if old.Highs.AllTime < price {
old.Highs.AllTime = price
}
//if day changed
oldTime, err := time.Parse(time.RFC822, old.LastCheck)
if err != nil {
log.Print(err)
}
if oldTime.Day() != time.Now().Day() {
shiftArray(&old.Highs.ThreeMonths)
shiftArray(&old.Highs.Month)
shiftArray(&old.Highs.Week)
shiftArray(&old.Lows.ThreeMonths)
shiftArray(&old.Lows.Month)
shiftArray(&old.Lows.Week)
}
old.LastCheck = time.Now().Format(time.RFC822)
if old.Highs.ThreeMonths[len(old.Highs.ThreeMonths)-1] < price ||
old.Highs.ThreeMonths[len(old.Highs.ThreeMonths)-1] == 0 {
old.Highs.ThreeMonths[len(old.Highs.ThreeMonths)-1] = price
}
if old.Highs.Month[len(old.Highs.Month)-1] < price ||
old.Highs.Month[len(old.Highs.Month)-1] == 0 {
old.Highs.Month[len(old.Highs.Month)-1] = price
}
if old.Highs.Week[len(old.Highs.Week)-1] < price ||
old.Highs.Week[len(old.Highs.Week)-1] == 0 {
old.Highs.Week[len(old.Highs.Week)-1] = price
}
if old.Lows.ThreeMonths[len(old.Lows.ThreeMonths)-1] > price ||
old.Lows.ThreeMonths[len(old.Lows.ThreeMonths)-1] == 0 {
old.Lows.ThreeMonths[len(old.Lows.ThreeMonths)-1] = price
}
if old.Lows.Month[len(old.Lows.Month)-1] > price ||
old.Lows.Month[len(old.Lows.Month)-1] == 0 {
old.Lows.Month[len(old.Lows.Month)-1] = price
}
if old.Lows.Week[len(old.Lows.Week)-1] > price ||
old.Lows.Week[len(old.Lows.Week)-1] == 0 {
old.Lows.Week[len(old.Lows.Week)-1] = price
}
writeJson(&old, "prices.json")
time.Sleep(15 * time.Minute)
}
}
func weeklyRoundUp() {
for {
if time.Now().Weekday() == time.Sunday && time.Now().Hour() == 10 {
coin, err := cmc.Ticker(&cmc.TickerOptions{
Symbol: "XRP",
Convert: "USD",
})
if err != nil {
log.Print(err)
}
market, err := cmc.GlobalMarket(&cmc.GlobalMarketOptions{
Convert: "USD",
})
if err != nil {
log.Print(err)
}
text := "Weekly roundup:\nXRP's current price is %s USD with a total " +
"market cap of %sbn USD. XRP market share " +
"went to %s%% and BTC dominance to" +
"%s%%. 👉 Discuss @XRPchats"
share := coin.Quotes["USD"].MarketCap * 100 / market.Quotes["USD"].TotalMarketCap
text = fmt.Sprintf(text,
float64ToStringPrec3(coin.Quotes["USD"].Price),
float64ToString(coin.Quotes["USD"].MarketCap/1000000000),
float64ToString(share),
float64ToString(market.BitcoinPercentageOfMarketCap))
sendMessage(config.ChannelId, text, nil)
//sendMessage(config.ChatId, text, nil)
//sendAllUsers(tgbotapi.MessageConfig{Text: text})
}
time.Sleep(1 * time.Hour)
}
}
func checkPosts() {
for {
time.Sleep(1 * time.Minute)
var posts []PendingPost
readJson(&posts, "posts.json")
sent := false
for i, post := range posts {
t1 := time.Now().UTC()
t2 := post.PostTime.UTC()
d := t1.Sub(t2).Seconds()
if d > 0 {
sent = true
if post.Destination == 1 {
msg := parsePost(&posts[i], config.ChannelId)
bot.Send(msg)
} else if post.Destination == 2 {
sendAllGroupsMessageConfig(parsePost(&posts[i], 0).(tgbotapi.MessageConfig))
} else {
sendAllUsersMessageConfig(parsePost(&posts[i], 0).(tgbotapi.MessageConfig))
}
}
}
if sent {
writeJson(&posts, "posts.json")
}
}
}
func parsePost(p *PendingPost, id int64) tgbotapi.Chattable {
var msg tgbotapi.Chattable
if p.Message.Text != "" {
msg = tgbotapi.NewMessage(id, p.Message.Text)
} else if p.Message.Video != nil {
msg = tgbotapi.NewVideoShare(id, p.Message.Video.FileID)
msg2 := msg.(tgbotapi.VideoConfig)
msg2.Caption = p.Message.Caption
msg = msg2
} else if p.Message.Sticker != nil {
msg = tgbotapi.NewStickerShare(id, p.Message.Sticker.FileID)
} else if p.Message.Photo != nil {
msg = tgbotapi.NewPhotoShare(id, (*p.Message.Photo)[0].FileID)
msg2 := msg.(tgbotapi.PhotoConfig)
msg2.Caption = p.Message.Caption
msg = msg2
} else if p.Message.Document != nil {
msg = tgbotapi.NewDocumentShare(id, p.Message.Document.FileID)
msg2 := msg.(tgbotapi.DocumentConfig)
msg2.Caption = p.Message.Caption
msg = msg2
} else if p.Message.Audio != nil {
msg = tgbotapi.NewAudioShare(id, p.Message.Audio.FileID)
msg2 := msg.(tgbotapi.AudioConfig)
msg2.Caption = p.Message.Caption
msg = msg2
} else if p.Message.VideoNote != nil {
msg = tgbotapi.NewVideoNoteShare(id, p.Message.VideoNote.Length,
p.Message.VideoNote.FileID)
} else if p.Message.Voice != nil {
msg = tgbotapi.NewVoiceShare(id, p.Message.Voice.FileID)
}
p.PostTime = time.Now().Add(time.Duration(p.DelayHours) * time.Hour)
return msg
}
func updateRates(){
for{
time.Sleep(24*time.Hour)
log.Print("Updating rates")
rates = make(map[string]float64)
var symbols []string
for _, s := range currencies {
symbols = append(symbols, s)
}
fixer.Symbols(symbols...)
resp, err := fixer.GetRates()
if err != nil {
log.Print(err)
}
usdRate := float64(1/resp["USD"])
for k, v := range resp {
rates[k] = float64(v) * usdRate
}
rates["USD"] = 1
rates["EUR"] = usdRate
log.Print(rates)
}
} |
// Package sqlRequests
/*
Пакет для запросов к БД
В запросах участвуют структуры (Item, User, UsersItemsRows), через поля которых передаётся информация
*/
package sqlRequests
type Item struct {
Id *int `db:"item_id"`
Name *string `db:"item_name"`
UserId *int `db:"item_user_id"`
CreateAt *string `db:"item_create_at"`
UpdateAt *string `db:"item_update_at"`
}
type User struct {
Id *int `db:"user_id"`
Name *string `db:"user_name"`
Age *int32 `db:"user_age"`
Type *int `db:"user_type"`
CreateAt *string `db:"user_create_at"`
UpdateAt *string `db:"user_update_at"`
}
type UsersItemsRows struct {
User
Item
}
|
package main
import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/linkedlocked/webapp/models"
"strconv"
)
/*
Router Card Code
*/
func routeGetCardsByUser(c *gin.Context) {
objects := models.GetCardsByUser(int(GetPageVariables(c).User.ID))
c.JSON(200, objects)
}
func routeDeleteCard(c *gin.Context) {
id, err := strconv.Atoi(c.Param("id"))
if err == nil {
key := models.GetCard(id)
key.Delete()
c.JSON(200, gin.H{
"result": "done",
})
} else {
c.JSON(200, gin.H{
"result": err,
})
}
}
func routeProvisionCard(c *gin.Context) {
type NewCard struct {
Hash string
Description string
OK bool
Message string
}
var newCard NewCard
if c.BindJSON(&newCard) == nil {
if newCard.Hash == "1337" {
newCard.OK = true
newCard.Message = "Linking successful!"
userID := GetPageVariables(c).User.ID
fmt.Println("userID: ", userID)
fmt.Println("uint(getUserID(c)): ", uint(getUserID(c)))
key := models.Card{
UserID: userID,
Description: newCard.Description,
}
key.Create()
} else {
newCard.OK = false
newCard.Message = "This key could not be validated."
}
c.JSON(200, newCard)
} else {
c.String(500, "Something went wrong in binding (add)")
}
}
/*
End of Card Routes
*/
|
package skylarkutils
import (
"reflect"
"testing"
"github.com/google/skylark"
"github.com/kr/pretty"
)
// makes tests more compact
type str = skylark.String
type tup = skylark.Tuple
func TestListToGo(t *testing.T) {
tests := []struct {
name string
l *skylark.List
i interface{}
}{
{
name: "string",
l: skylark.NewList(tup{
str("x.txt"), str("y.txt"),
}),
i: []string{"x.txt", "y.txt"},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
s, _ := ListToGo(test.l)
if eqStringSlice(test.i, s) {
t.Logf("test != i\n%s", pretty.Diff(test.i, s))
t.Fail()
}
})
}
}
func eqStringSlice(ai, bi interface{}) bool {
a := reflect.ValueOf(ai)
b := reflect.ValueOf(bi)
if !a.IsValid() && !b.IsValid() {
return true
}
if a.Len() != b.Len() {
return false
}
for i := 0; i < a.Len(); i++ {
if a.Index(i) != b.Index(i) {
return false
}
}
return true
} |
package main
import (
"bitbucket.org/kardianos/table"
_ "code.google.com/p/odbc"
"database/sql"
"fmt"
"log"
"os"
"time"
)
func main() {
connStr := "driver=sql server;server=(local);database=tempdb;trusted_connection=yes"
if len(os.Args) > 1 && len(os.Args[1]) > 1 {
connStr = os.Args[1]
}
//log.Printf("Connecting with '%s'\n", connStr)
conn, err := sql.Open("odbc", connStr)
if err != nil {
fmt.Println("Connecting Error")
return
}
defer conn.Close()
connTbl := "sys.databases"
if len(os.Args) > 2 {
connTbl = os.Args[2]
}
table, err := table.Get(conn, "select * from "+connTbl)
if err != nil {
log.Fatal(err)
}
dumpTable(table)
fmt.Fprintf(os.Stderr, "\nFinished correctly\n")
return
}
func dumpTable(table *table.Buffer) {
// open the output file
file, err := os.Create("out.csv")
if err != nil {
panic(err)
}
// close file on exit and check for its returned error
defer func() {
if err := file.Close(); err != nil {
panic(err)
}
}()
// output header
for i, element := range table.ColumnName {
if i != 0 {
fmt.Fprintf(file, ",")
}
fmt.Fprintf(file, "\"%s\"", element)
}
fmt.Fprintf(file, "\n")
// output body
const layout = "01/02/2006 15:04:05.999"
for _, row := range table.Rows {
for i, colname := range table.ColumnName {
if i != 0 {
fmt.Fprintf(file, ",")
}
switch x := row.MustGet(colname).(type) {
case string: // x is a string
fmt.Fprintf(file, "\"%s\"", x)
case int: // now x is an int
fmt.Fprintf(file, "\"%d\"", x)
case int32: // now x is an int32
fmt.Fprintf(file, "\"%d\"", x)
case int64: // now x is an int64
fmt.Fprintf(file, "\"%d\"", x)
case float32: // now x is an float32
fmt.Fprintf(file, "\"%f\"", x)
case float64: // now x is an float64
fmt.Fprintf(file, "\"%f\"", x)
case time.Time: // now x is a time.Time
fmt.Fprintf(file, "\"%s\"", x.Format(layout))
default:
fmt.Fprintf(file, "\"%s\"", x)
}
}
fmt.Fprintf(file, "\n")
fmt.Fprintf(os.Stderr, ".")
}
fmt.Fprintf(os.Stderr, "\n")
}
|
package pool
import (
"context"
"github.com/mee6aas/kyle/internal/pkg/runtime"
)
var (
mngCtx context.Context
mngCancel context.CancelFunc
rConf runtime.Config
onFetched = make(chan struct{}, 1)
)
|
// +build !windows
package version_test
import (
"io/ioutil"
"os"
"github.com/cloudfoundry-incubator/ltc/version"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("FileSwapper", func() {
Describe("#SwapTempFile", func() {
var (
srcPath string
destPath string
appFileSwapper *version.AppFileSwapper
)
BeforeEach(func() {
srcFile, err := ioutil.TempFile("", "src")
Expect(err).NotTo(HaveOccurred())
_, err = srcFile.Write([]byte("sourcedata"))
Expect(err).NotTo(HaveOccurred())
srcFile.Close()
srcPath = srcFile.Name()
Expect(os.Chmod(srcPath, 0644)).To(Succeed())
destFile, err := ioutil.TempFile("", "dest")
Expect(err).NotTo(HaveOccurred())
_, err = destFile.Write([]byte("destdata"))
Expect(err).NotTo(HaveOccurred())
destFile.Close()
destPath = destFile.Name()
Expect(os.Chmod(destPath, 0755)).To(Succeed())
appFileSwapper = &version.AppFileSwapper{}
})
AfterEach(func() {
Expect(os.Remove(destPath)).To(Succeed())
})
It("writes the contents to the destination file", func() {
err := appFileSwapper.SwapTempFile(destPath, srcPath)
Expect(err).NotTo(HaveOccurred())
destFile, err := os.OpenFile(destPath, os.O_RDONLY, 0)
defer destFile.Close()
Expect(err).NotTo(HaveOccurred())
bytes, err := ioutil.ReadAll(destFile)
Expect(err).NotTo(HaveOccurred())
Expect(string(bytes)).To(Equal("sourcedata"))
})
It("removes the source file", func() {
err := appFileSwapper.SwapTempFile(destPath, srcPath)
Expect(err).NotTo(HaveOccurred())
_, err = os.Stat(srcPath)
Expect(os.IsExist(err)).To(BeFalse())
})
It("preserves the permissions of the destination file", func() {
err := appFileSwapper.SwapTempFile(destPath, srcPath)
Expect(err).NotTo(HaveOccurred())
info, err := os.Stat(destPath)
Expect(err).NotTo(HaveOccurred())
Expect(info.Mode() & os.ModePerm).To(Equal(os.FileMode(0755)))
})
Context("when there is an error getting dest file stats", func() {
It("returns an error", func() {
err := appFileSwapper.SwapTempFile("/this-does-not-exist", srcPath)
Expect(err).To(MatchError(HavePrefix("failed to stat dest file")))
})
})
Context("when there is an error renaming the file", func() {
It("returns an error", func() {
err := appFileSwapper.SwapTempFile(destPath, "/this-does-not-exist")
Expect(err).To(MatchError(HavePrefix("failed to rename file")))
})
})
})
})
|
package topic
type useCase struct {
repository Repository
}
type Repository interface {
Save(command *addTopicCommand) error
List(command *listTopicQuery) ([]topicModel, error)
}
func (u *useCase) add(command *addTopicCommand) error {
return u.repository.Save(command)
}
func (u *useCase) list(command *listTopicQuery) ([]topicModel, error) {
return u.repository.List(command)
}
|
// See LICENSE.txt for licensing information.
package simpleini
import (
"bytes"
"fmt"
"io"
"os"
"strings"
"testing"
)
func TestParsingCorrectInputs(t *testing.T) {
var input io.Reader
inputs := [...]string{
`[main]
string = this is a test
integer = 123
boolean = yes
[auxillary]
whatever = something
`,
`; some comment
; another
[main]
string = this is a test
integer = 0123
;integer = 9999
boolean = true
; boolean = false
;[auxillary]
[auxillary]
whatever = something
`,
}
for idx, i := range inputs {
idx++
input = strings.NewReader(i)
ini, err := Parse(input)
if err != nil {
t.Errorf("(%d) Parsing failed: %s", idx, err)
return
}
if len(ini.Sections()) != 2 {
t.Errorf("(%d) Wrong number of sections", idx)
}
ps, err := ini.Properties("main")
if err != nil {
t.Errorf("(%d) Couldn't get properties for main: %s", idx, err)
} else {
if len(ps) != 3 {
t.Errorf("(%d) Wrong number of properties", idx)
}
}
strVal, err := ini.GetString("main", "string")
if err != nil {
t.Errorf("(%d) Couldn't get main/string: %s", idx, err)
} else {
if strVal != "this is a test" {
t.Errorf("(%d) Wrong value for main/string", idx)
}
}
strVal, err = ini.GetString("auxillary", "whatever")
if err != nil {
t.Errorf("(%d) Couldn't get auxillary/whatever: %s", idx, err)
} else {
if strVal != "something" {
t.Errorf("(%d) Wrong value for auxillar/whatever", idx)
}
}
intVal, err := ini.GetInt("main", "integer")
if err != nil {
t.Errorf("(%d) Couldn't get main/integer: %s", idx, err)
} else {
if intVal != 123 {
t.Errorf("(%d) Wrong value for main/integer", idx)
}
}
boolVal, err := ini.GetBool("main", "boolean")
if err != nil {
t.Errorf("(%d) Couldn't get main/boolean: %s", idx, err)
} else {
if !boolVal {
t.Errorf("(%d) Wrong value for main/boolean", idx)
}
}
}
}
func TestKeyWithSpaces(t *testing.T) {
input := strings.NewReader(`
[ugly]
key with spaces = value with spaces too `)
ini, err := Parse(input)
if err != nil {
t.Errorf("Parsing failed: %s", err)
return
}
val, err := ini.GetString("ugly", "key with spaces")
if err != nil {
t.Errorf("Couldn't get ugly/key with spaces: %s", err)
} else {
if val != "value with spaces too" {
t.Errorf("Wrong value for ugly/key with spaces")
}
}
}
func TestBoolValues(t *testing.T) {
trueVals := [...]string{"true", "yes", "on"}
falseVals := [...]string{"false", "no", "off"}
for idx, val := range trueVals {
input := strings.NewReader("[bools]\nval = " + val)
ini, err := Parse(input)
if err != nil {
t.Errorf("(%d) Parsing failed: %s", idx, err)
return
}
boolVal, err := ini.GetBool("bools", "val")
if err != nil {
t.Errorf("(%d) Couldn't get bools/val: %s", idx, err)
} else {
if !boolVal {
t.Errorf("(%d) Value of bools/val should have been true", idx)
}
}
}
for idx, val := range falseVals {
input := strings.NewReader("[bools]\nval = " + val)
ini, err := Parse(input)
if err != nil {
t.Errorf("(%d) Parsing failed: %s", idx, err)
return
}
boolVal, err := ini.GetBool("bools", "val")
if err != nil {
t.Errorf("(%d) Couldn't get bools/val: %s", idx, err)
} else {
if boolVal {
t.Errorf("(%d) Value of bools/val should have been flase", idx)
}
}
}
}
func TestParsingMalformedSections(t *testing.T) {
inputs := [...]string{"[", "[aaa", "[]"}
for idx, i := range inputs {
idx++
input := strings.NewReader(i)
_, err := Parse(input)
if err == nil {
t.Errorf("(%d) Malformed section parsed", idx)
}
}
}
func TestParsingRedfinedSection(t *testing.T) {
input := strings.NewReader("[a]\nval=1\n\n[a]\nval=1\n")
_, err := Parse(input)
if err == nil {
t.Errorf("Redefined section parsed")
}
}
func TestParsingMalformedProperties(t *testing.T) {
inputs := [...]string{"whatever", "this = that", "[hello]\nthis", "something\n[section]"}
for idx, i := range inputs {
idx++
input := strings.NewReader(i)
_, err := Parse(input)
if err == nil {
t.Errorf("(%d) Malformed property parsed", idx)
}
}
}
func TestParsingRedfinedProperty(t *testing.T) {
input := strings.NewReader("[a]\nval=1\nval=2\n")
_, err := Parse(input)
if err == nil {
t.Errorf("Redefined property parsed")
}
}
func TestBadProperties(t *testing.T) {
input := strings.NewReader("[a]\nval=1")
ini, _ := Parse(input)
_, err := ini.Properties("b")
if err == nil {
t.Errorf("Not defined properties found")
}
}
func TestBadGetString(t *testing.T) {
input := strings.NewReader("[a]\nval=1")
ini, _ := Parse(input)
_, err := ini.GetString("b", "a")
if err == nil {
t.Errorf("Not defined section found")
}
_, err = ini.GetString("a", "non")
if err == nil {
t.Errorf("Not defined property found")
}
}
func TestBadGetInt(t *testing.T) {
input := strings.NewReader("[a]\nsval=foo")
ini, _ := Parse(input)
_, err := ini.GetInt("b", "a")
if err == nil {
t.Errorf("Not defined section found")
}
_, err = ini.GetInt("a", "non")
if err == nil {
t.Errorf("Not defined property found")
}
_, err = ini.GetInt("a", "sval")
if err == nil {
t.Errorf("Non-int property returned as int")
}
}
func TestBadGetBool(t *testing.T) {
input := strings.NewReader("[a]\nsval=foo")
ini, _ := Parse(input)
_, err := ini.GetBool("b", "a")
if err == nil {
t.Errorf("Not defined section found")
}
_, err = ini.GetBool("a", "non")
if err == nil {
t.Errorf("Not defined property found")
}
_, err = ini.GetBool("a", "sval")
if err == nil {
t.Errorf("Non-int property returned as bool")
}
}
func TestSetStringRedefine(t *testing.T) {
input := strings.NewReader("[a]\nval=1")
ini, _ := Parse(input)
val, _ := ini.GetString("a", "val")
if val != "1" {
t.Errorf("Bad inital value for a/val")
return
}
ini.SetString("a", "val", "2")
val, _ = ini.GetString("a", "val")
if val != "2" {
t.Errorf("Bad posterior value for a/val")
return
}
}
func TestSetString(t *testing.T) {
input := strings.NewReader("")
ini, _ := Parse(input)
_, err := ini.GetString("a", "val")
if err == nil {
t.Errorf("Got inital value for a/val")
return
}
ini.SetString("a", "val", "2")
val, _ := ini.GetString("a", "val")
if val != "2" {
t.Errorf("Bad posterior value for a/val")
return
}
}
func TestSetIntRedefine(t *testing.T) {
input := strings.NewReader("[a]\nval=1")
ini, _ := Parse(input)
val, _ := ini.GetInt("a", "val")
if val != 1 {
t.Errorf("Bad inital value for a/val")
return
}
ini.SetInt("a", "val", 2)
val, _ = ini.GetInt("a", "val")
if val != 2 {
t.Errorf("Bad posterior value for a/val")
return
}
}
func TestSetInt(t *testing.T) {
input := strings.NewReader("")
ini, _ := Parse(input)
_, err := ini.GetInt("a", "val")
if err == nil {
t.Errorf("Got inital value for a/val")
return
}
ini.SetInt("a", "val", 2)
val, _ := ini.GetInt("a", "val")
if val != 2 {
t.Errorf("Bad posterior value for a/val")
return
}
}
func TestSetBoolRedefine(t *testing.T) {
input := strings.NewReader("[a]\nval=yes")
ini, _ := Parse(input)
val, _ := ini.GetBool("a", "val")
if !val {
t.Errorf("Bad inital value for a/val")
return
}
ini.SetBool("a", "val", false)
val, _ = ini.GetBool("a", "val")
if val {
t.Errorf("Bad posterior value for a/val")
return
}
}
func TestSetBool(t *testing.T) {
input := strings.NewReader("")
ini, _ := Parse(input)
_, err := ini.GetBool("a", "val")
if err == nil {
t.Errorf("Got inital value for a/val")
return
}
ini.SetBool("a", "val", true)
val, _ := ini.GetBool("a", "val")
if !val {
t.Errorf("Bad posterior value for a/val")
return
}
}
func TestWritePretty(t *testing.T) {
ini := NewINI()
ini.SetString("main", "greeting", "hello world")
ini.SetBool("main", "works", true)
ini.SetInt("main", "number", 41)
ini.SetString("other", "greeting", "cześć!")
var buf bytes.Buffer
err := ini.Write(&buf, true)
if err != nil {
t.Errorf("Write error: %s", err)
return
}
if buf.String() != `[main]
greeting = hello world
number = 41
works = yes
[other]
greeting = cześć!
` {
t.Errorf("Output mismatch")
fmt.Println(buf.String())
}
}
type errorWriterTest struct {
left int
err error
}
func (w errorWriterTest) Write(p []byte) (int, error) {
if len(p) < w.left {
w.left -= len(p)
return len(p), nil
}
return 0, w.err
}
var errorWriterTests = []errorWriterTest{
{3, io.ErrShortWrite},
{23, io.ErrShortWrite},
}
func TestBadWrite(t *testing.T) {
ini := NewINI()
ini.SetString("main", "greeting", "hello world")
ini.SetBool("main", "works", true)
ini.SetInt("main", "number", 41)
ini.SetString("other", "greeting", "cześć!")
for idx, w := range errorWriterTests {
err := ini.Write(&w, false)
if err == nil {
t.Errorf("(%d) Should return error", idx+1)
}
}
}
func ExampleNewINI() {
i := NewINI()
i.SetString("example 1", "comment", "an example section")
i.SetInt("example 1", "magic number", 31337)
i.SetBool("example 1", "fun", true)
i.Write(os.Stdout, true)
// Output:
// [example 1]
// comment = an example section
// fun = yes
// magic number = 31337
}
|
package main
import (
"fmt"
"os"
)
func main(){
i:=0
for{
i++
fmt.Println("Helllooooooo")
if i==10{
break
}
}
for i:=0;i<10;i++{
fmt.Println("worlddddddddddddddddd")
}
for i:=true;i;i=false{
fmt.Println(i)
}
arguments := os.Args
if len(arguments) ==1{
fmt.Println("no argument provided")
}else if len(arguments) == 2{
fmt.Println("one argument provided")
}else{
fmt.Println("many arguments provided")
}
set := true
//no ternary support to go
// kill := set?"hello":"Ankita"
// fmt.Println(kill)
} |
package main
import (
"fmt"
"net"
"strconv"
"time"
msgpack "gopkg.in/vmihailenco/msgpack.v2"
)
type UDPRequest struct {
One string
Two int
Three string
}
func main() {
fmt.Println("Starting client")
serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8084")
if err != nil {
fmt.Println(err)
return
}
localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
if err != nil {
fmt.Println(err)
return
}
conn, err := net.DialUDP("udp", localAddr, serverAddr)
if err != nil {
fmt.Println(err)
return
}
defer conn.Close()
i := 0
for {
msg := &UDPRequest{}
msg.One = strconv.Itoa(i)
msg.Two = i
msg.Three = "some string"
i++
b, err := msgpack.Marshal(msg)
if err != nil {
fmt.Println(err)
}
_, err = conn.Write(b)
if err != nil {
fmt.Println(err)
}
time.Sleep(time.Second * 1)
}
}
|
// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you 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.
// Code generated from the elasticsearch-specification DO NOT EDIT.
// https://github.com/elastic/elasticsearch-specification/tree/33e8a1c9cad22a5946ac735c4fba31af2da2cec2
package types
import (
"bytes"
"encoding/json"
"errors"
"io"
)
// RunningStateSearchInterval type.
//
// https://github.com/elastic/elasticsearch-specification/blob/33e8a1c9cad22a5946ac735c4fba31af2da2cec2/specification/ml/_types/Datafeed.ts#L164-L169
type RunningStateSearchInterval struct {
End Duration `json:"end,omitempty"`
EndMs int64 `json:"end_ms"`
Start Duration `json:"start,omitempty"`
StartMs int64 `json:"start_ms"`
}
func (s *RunningStateSearchInterval) UnmarshalJSON(data []byte) error {
dec := json.NewDecoder(bytes.NewReader(data))
for {
t, err := dec.Token()
if err != nil {
if errors.Is(err, io.EOF) {
break
}
return err
}
switch t {
case "end":
if err := dec.Decode(&s.End); err != nil {
return err
}
case "end_ms":
if err := dec.Decode(&s.EndMs); err != nil {
return err
}
case "start":
if err := dec.Decode(&s.Start); err != nil {
return err
}
case "start_ms":
if err := dec.Decode(&s.StartMs); err != nil {
return err
}
}
}
return nil
}
// NewRunningStateSearchInterval returns a RunningStateSearchInterval.
func NewRunningStateSearchInterval() *RunningStateSearchInterval {
r := &RunningStateSearchInterval{}
return r
}
|
package controllers
import (
"context"
"net/http"
"time"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
"github.com/AskJag07/virtuoso-server/models"
)
func Students(client *mongo.Client) gin.HandlerFunc {
return func(c *gin.Context) {
var ctx, cancel = context.WithTimeout(context.Background(), 30*time.Second)
var students []models.Student
usersCollection := client.Database("App").Collection("users")
projection := bson.D{
{Key: "full_name", Value: 1},
{Key: "email", Value: 1},
{Key: "standard", Value: 1},
{Key: "created_at", Value: 1},
{Key: "updated_at", Value: 1},
}
cur, err := usersCollection.Find(ctx, bson.M{"admin": false}, options.Find().SetProjection(projection))
defer cancel()
if err != nil {
c.JSON(
http.StatusOK,
gin.H{"error": "Students not found."},
)
return
}
if err = cur.All(ctx, &students); err != nil {
c.JSON(
http.StatusInternalServerError,
gin.H{"error": err},
)
return
}
c.JSON(http.StatusOK, gin.H{
"students": students,
})
}
}
|
package main
import "math"
func main() {
}
func integerBreak(n int) int {
if n <= 3 {
return n - 1
}
quotient := n / 3
remainder := n % 3
if remainder == 0 {
return int(math.Pow(3, float64(quotient)))
} else if remainder == 1 {
return int(math.Pow(3, float64(quotient-1))) * 4
}
return int(math.Pow(3, float64(quotient))) * 2
}
func integerBreak_dp(n int) int {
dp := make([]int, n+1)
for i := 2; i <= n; i++ {
curMax := 0
for j := 1; j < i; j++ {
curMax = max(curMax, max(j*(i-j), j*dp[i-j]))
}
dp[i] = curMax
}
return dp[n]
}
func integerBreak_dp_optimize(n int) int {
if n < 4 {
return n - 1
}
dp := make([]int, n+1)
dp[2] = 1
for i := 3; i <= n; i++ {
dp[i] = max(max(2*(i-2), 2*dp[i-2]), max(3*(i-3), 3*dp[i-3]))
}
return dp[n]
}
func max(x, y int) int {
if x > y {
return x
}
return y
}
|
package vo
type TestResult struct {
//service.MatchLast `xorm:"extends"`
//Id string
//Name string
//CompName string
//entity2.EuroLast `xorm:"extends"`
}
|
package main // 包
import (
"log"
"net/smtp"
"github.com/jordan-wright/email"
)
func main() { // 入口函数
e := email.NewEmail() // := 定义且赋值
e.From = "1137807913@qq.com"
// [] Array 多个用户发邮件 { }集合
e.To = []string{"525876818@qq.com", "1733407461@qq.com", "2426298429@qq.com", "498165738@qq.com"}
e.Subject = "你在家还好吗？" // 标题
// byte go 类型
e.Text = []byte("自从放假一别，已有两月，甚是想念") // 内容
e.HTML = []byte(`
<ul>
<li><a href="https://juejin.im/post/5e575e02f265da573b0dad5f">掘金</a></li>
<li><a href="https://www.baidu.com/">百度</a></li>
</ul>`)
// 本地并没有搭建邮件服务器 由腾讯服务器转发
err := e.Send("smtp.qq.com:25", smtp.PlainAuth("", "1137807913@qq.com", "phtewfndqlchhbfh", "smtp.qq.com"))
e.AttachFile("marker.png") // 附件
if err != nil {
log.Fatal(err)
}
}
|
package redis
import (
"encoding/json"
"errors"
"time"
"github.com/gomodule/redigo/redis"
uuid "github.com/satori/go.uuid"
log "github.com/sirupsen/logrus"
)
// DelayData struct
type DelayData struct {
UUID string `json:"uuid"` // UUID for delay value
Time int64 `json:"time"` // the unix timestamp to trigger
Data string `json:"data"` // the queue origin data
}
// Consume a list queue
func (qi *QueueInstance) Consume(queueName string) (<-chan string, error) {
deliveries := make(chan string, 200)
concurency := make(chan bool, 200)
go func() {
for {
concurency <- true
go func() {
defer func() {
<-concurency
}()
d, err := qi.Pop(queueName)
if err != nil {
if nil != err && "redigo: nil returned" != err.Error() {
log.WithFields(log.Fields{
"queueName": queueName,
"Process handler has a error": err.Error(),
}).Warn("!!! ProcessDelay handler has a error")
}
// if any error occured sleep a while
time.Sleep(1 * time.Second)
return
}
deliveries <- d
}()
}
}()
return deliveries, nil
}
// Pop a element
func (qi *QueueInstance) Pop(queueName string) (string, error) {
conn, _ := qi.GetConnection()
defer conn.Close()
reply, err := conn.Do("RPOP", queueName)
if nil != err {
return "", err
}
replyStr, err := redis.String(reply, err)
if nil != err {
return "", err
}
return replyStr, nil
}
// Push a element
func (qi *QueueInstance) Push(queueName string, value string) (bool, error) {
conn, _ := qi.GetConnection()
defer conn.Close()
reply, err := conn.Do("LPUSH", queueName, value)
if nil != err {
return false, err
}
replyInt, err := redis.Int(reply, err)
if nil != err {
return false, err
}
if replyInt < 1 {
return false, errors.New("Push 0 element to queue")
}
return true, nil
}
// Length a queue's length
func (qi *QueueInstance) Length(queueName string) (int64, error) {
conn, _ := qi.GetConnection()
defer conn.Close()
reply, err := conn.Do("LLen", queueName)
if nil != err {
return 0, err
}
replyInt, err := redis.Int64(reply, err)
if nil != err {
return 0, err
}
return replyInt, nil
}
// DelayPop pop data from delay queue
func (qi *QueueInstance) DelayPop(queueName string, isReturnRaw bool) ([]string, error) {
conn, _ := qi.GetConnection()
defer conn.Close()
min := 0
max := time.Now().Unix()
// todo when number is to large, how to deal with
// zrangebyscore test 0 2 LIMIT 2 4
conn.Send("MULTI")
conn.Send("ZRANGEBYSCORE", queueName, min, max)
conn.Send("ZREMRANGEBYSCORE", queueName, min, max)
reply, err := conn.Do("EXEC")
result := []string{}
replys, err := redis.MultiBulk(reply, err)
if nil != err {
return result, err
}
// not resut, return empty result
if len(replys) <= 0 || replys[1].(int64) <= 0 {
return result, nil
}
// has result but length less than 0
replys2, err := redis.MultiBulk(replys[0], err)
if len(replys2) <= 0 {
return result, nil
}
for _, v := range replys2 {
if isReturnRaw {
result = append(result, string(v.([]byte)))
} else {
vv := &DelayData{}
err := json.Unmarshal(v.([]byte), vv)
if nil != err {
continue
}
result = append(result, vv.Data)
}
}
return result, err
}
// DelayPush push a element to a delayqueue
func (qi *QueueInstance) DelayPush(queueName string, value string, delayUnixTime int64) (bool, error) {
conn, _ := qi.GetConnection()
defer conn.Close()
uniqueID := uuid.NewV4().String()
// Json encode
delayData := &DelayData{
UUID: uniqueID,
Time: delayUnixTime,
Data: value,
}
jsonStr, err := json.Marshal(delayData)
if nil != err {
return false, err
}
reply, err := conn.Do("ZADD", queueName, "NX", delayUnixTime, jsonStr)
if nil != err {
return false, err
}
replyInt, err := redis.Int(reply, err)
if nil != err {
return false, err
}
if replyInt < 1 {
return false, errors.New("Push 0 element to delay queue")
}
return true, nil
}
// DelayLength a delay queue's length
func (qi *QueueInstance) DelayLength(queueName string) (int64, error) {
conn, _ := qi.GetConnection()
defer conn.Close()
reply, err := conn.Do("ZCOUNT", queueName, "-INF", "+INF")
if nil != err {
return 0, err
}
replyInt, err := redis.Int64(reply, err)
if nil != err {
return 0, err
}
return replyInt, nil
}
|
package query
import (
"context"
"github.com/angryronald/guestlist/internal/guest/domain/service/guest"
"github.com/angryronald/guestlist/internal/guest/public"
)
// CountEmptySeatsQuery encapsulate process for count empty seats in Query
type CountEmptySeatsQuery struct {
service guest.ServiceInterface
}
// NewCountEmptySeatsQuery build an Query for count empty seats
func NewCountEmptySeatsQuery(
service guest.ServiceInterface,
) CountEmptySeatsQuery {
return CountEmptySeatsQuery{
service: service,
}
}
func (q CountEmptySeatsQuery) Execute(ctx context.Context) (*public.CountEmptySeats, error) {
emptySeats, err := q.service.GetAvailableSpace(ctx)
if err != nil {
return nil, err
}
return &public.CountEmptySeats{
SeatsEmpty: emptySeats,
}, nil
}
|
package webhooks
import (
"context"
"net/http"
ctrl "sigs.k8s.io/controller-runtime"
"time"
)
const (
webhookDefaultTimeout = 10 * time.Second
)
type contextKey struct{}
func NewContextFromRequest(ctx context.Context, req *http.Request) context.Context {
query := req.URL.Query()
timeout := query.Get("timeout")
if len(timeout) == 0 {
return ctx
}
duration, err := time.ParseDuration(timeout)
if err != nil {
ctrl.Log.Error(err, "unable to parse timeout")
}
return context.WithValue(ctx, contextKey{}, &duration)
}
func TimeoutFromContext(ctx context.Context) time.Duration {
timeout := ctx.Value(contextKey{}).(*time.Duration)
if timeout != nil {
return *timeout
} else {
return webhookDefaultTimeout
}
}
|
package hash
import (
"crypto/rand"
"testing"
"github.com/stretchr/testify/require"
)
func TestHash(t *testing.T) {
data1 := []byte("The Cypherpunks are actively engaged in making the networks safer for privacy.")
hash1, err := Hash("ciphertext", data1)
require.NoError(t, err)
hash2, err := Hash("plaintext", data1)
require.NoError(t, err)
require.NotEqual(t, hash1, hash2)
}
func TestBlake2bKDF(t *testing.T) {
key := make([]byte, KeySize)
_, err := rand.Read(key)
require.NoError(t, err)
biggerKey1, err := Blake2bKDF(key, 512, nil, nil)
require.NoError(t, err)
salt := []byte{1, 2, 3, 4, 5, 6, 7, 8}
biggerKey2, err := Blake2bKDF(key, 512, salt, nil)
require.NoError(t, err)
require.NotEqual(t, biggerKey1, biggerKey2)
info := []byte{10, 9, 8, 7}
biggerKey3, err := Blake2bKDF(key, 512, nil, info)
require.NoError(t, err)
require.NotEqual(t, biggerKey1, biggerKey3)
require.NotEqual(t, biggerKey2, biggerKey3)
biggerKey4, err := Blake2bKDF(key, 512, salt, info)
require.NoError(t, err)
biggerKey5, err := Blake2bKDF(key, 512, append(salt, info...), nil)
require.NoError(t, err)
require.NotEqual(t, biggerKey4, biggerKey5)
biggerKey6, err := Blake2bKDF(key, 512, nil, append(salt, info...))
require.NoError(t, err)
require.NotEqual(t, biggerKey6, biggerKey5)
require.NotEqual(t, biggerKey6, biggerKey4)
}
func TestHashPassword(t *testing.T) {
salt := []byte{1, 2, 3, 4, 5, 6, 7, 8} // use a more entropic salt than this
password := []byte("my silly passphrase")
key := HashPassword(password, salt)
t.Logf("key: %x", key)
}
func TestValidBlake2bMAC(t *testing.T) {
data := []byte("We must defend our own privacy if we expect to have any.")
key1 := make([]byte, KeySize)
_, err := rand.Read(key1)
require.NoError(t, err)
mac1 := Blake2bMAC(key1, data)
require.True(t, ValidBlake2bMAC(data, mac1, key1))
key2 := make([]byte, KeySize)
_, err = rand.Read(key2)
require.NoError(t, err)
mac2 := Blake2bMAC(key2, data)
require.NotEqual(t, mac1, mac2)
require.True(t, ValidBlake2bMAC(data, mac2, key2))
require.False(t, ValidBlake2bMAC(data, mac2, key1))
}
|
package models
import (
"github.com/jinzhu/gorm"
)
//研发推广
type Application struct {
BaseModel
Name string `json:"name" form:"name"` //名称
Code string `json:"code" form:"code"` //编码
CategoryId int `json:"category_id" form:"category_id"` //分类
Category *Category `json:"category" form:"category"`
Image string `json:"image" form:"image"` //图片地址
Use string `json:"use" form:"use"` //用了啥
Talk string `json:"talk" form:"talk"` //大师说
Eat string `json:"eat" form:"eat"` //何时吃
}
func (app *Application) Create(db *gorm.DB) (*Application, error) {
var model Application
err := db.Create(&app).Error
if err == nil {
db.Where("id = ?", app.ID).First(&model)
}
return &model, err
}
func (app *Application) Update(db *gorm.DB) (*Application, error) {
err := db.Model(app).Updates(app).Error
db.First(app)
return app, err
}
|
// Licensed to SolID under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. SolID licenses this file to you 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 services
import (
"context"
corev1 "zntr.io/solid/api/gen/go/oidc/core/v1"
)
// Authorization describes authorization request processor.
type Authorization interface {
// Authorize a request.
Authorize(ctx context.Context, req *corev1.AuthorizationCodeRequest) (*corev1.AuthorizationCodeResponse, error)
// Register a request.
Register(ctx context.Context, req *corev1.RegistrationRequest) (*corev1.RegistrationResponse, error)
}
// Token describes token request processor.
type Token interface {
// Token handles token retrieval.
Token(ctx context.Context, req *corev1.TokenRequest) (*corev1.TokenResponse, error)
// Introspect handles token introspection.
Introspect(ctx context.Context, req *corev1.TokenIntrospectionRequest) (*corev1.TokenIntrospectionResponse, error)
// Revoke given token.
Revoke(ctx context.Context, req *corev1.TokenRevocationRequest) (*corev1.TokenRevocationResponse, error)
}
// Device authorization service contract.
type Device interface {
// Authorize process device authorization request.
Authorize(ctx context.Context, req *corev1.DeviceAuthorizationRequest) (*corev1.DeviceAuthorizationResponse, error)
// Validate user code
Validate(ctx context.Context, req *corev1.DeviceCodeValidationRequest) (*corev1.DeviceCodeValidationResponse, error)
}
// Client describes client management request processor.
type Client interface {
// Register process client registration request.
Register(ctx context.Context, req *corev1.ClientRegistrationRequest) (*corev1.ClientRegistrationResponse, error)
}
|
package main
//Printing a number in decimal, binary and hexadecimal formats
import "fmt"
func main() {
num := 1618
fmt.Printf("dec = %v\nbin = %b\nhex = %#x", num, num, num)
}
|
package main
import (
"encoding/csv"
"io"
"io/ioutil"
"strings"
"os"
)
// WriteOutput writes a csv file (specified in filename) from a slice of strings (specified in words)
func WriteOutput(words []string, filename string) {
// create file
f, err := os.Create(filename)
Check(err)
//writer
w := csv.NewWriter(f)
err = w.Write(words)
Check(err)
w.Flush()
Check(err)
}
// CsvPuzzleSlice creates a "word puzzle" slice by loading the file specified in filename
func CsvPuzzleSlice(filename string) [][]string {
f, err := ioutil.ReadFile(filename)
Check(err)
r := csv.NewReader(strings.NewReader(string(f)))
slice := make([][]string, 0, 0)
for {
record, err := r.Read()
if err == io.EOF {
break
}
Check(err)
slice = append(slice, record)
}
return slice
}
// CsvWords creates a slice of strings by loading the csv file specified in filename
func CsvWords(filename string) []string {
f, err := ioutil.ReadFile(filename)
Check(err)
r := csv.NewReader(strings.NewReader(string(f)))
for {
record, err := r.Read()
if err == io.EOF {
break
}
Check(err)
return record
}
return nil
} |
package main
import (
"fmt"
"sort"
)
// 47. 全排列 II
// 给定一个可包含重复数字的序列，返回所有不重复的全排列。
// https://leetcode-cn.com/problems/permutations-ii/
func main() {
nums := []int{1, 1, 2}
fmt.Println(permuteUnique1(nums))
fmt.Println(permuteUnique2(nums))
}
// 要点：在cur的同一个位置，不能使用重复数字
// 法一：时间最优
// 法二：空间最优
// 法一：通过排序 和 i > 0 && nums[i] == nums[i-1] && used[i-1] 来判断重复数字
// 使用used记录记录使用过的元素，key是元素在nums中的下标
func permuteUnique1(nums []int) (result [][]int) {
if len(nums) == 0 {
return nil
}
n := len(nums)
cur := make([]int, n)
used := make([]bool, n)
sort.Ints(nums)
helper1(nums, cur, 0, used, &result)
return result
}
func helper1(nums []int, cur []int, curIndex int, used []bool, result *[][]int) {
n := len(nums)
// 结束本次排列
if curIndex == n {
tmp := make([]int, n)
copy(tmp, cur)
*result = append(*result, tmp)
return
}
for i := 0; i < n; i++ {
// 排除使用过的元素
if used[i] {
continue
}
// 排除重复数字：相同的数字，不能在同一个位置出现
// 剪枝条件分析：https://leetcode-cn.com/problems/permutations-ii/solution/hot-100-47quan-pai-lie-ii-python3-hui-su-kao-lu-zh/
if i > 0 && nums[i] == nums[i-1] && !used[i-1] {
continue
}
// 处理当前层
cur[curIndex] = nums[i]
used[i] = true
// 进入下一层
helper1(nums, cur, curIndex+1, used, result)
// 撤销选择
used[i] = false
}
}
// 法二：空间最优
// 通过在原数组内交换元素来获得新的排列
func permuteUnique2(nums []int) (result [][]int) {
if len(nums) == 0 {
return nil
}
sort.Ints(nums)
helper2(nums, 0, &result)
return result
}
// i表示本次函数需要放置的元素位置
func helper2(nums []int, i int, result *[][]int) {
n := len(nums)
if i == n-1 {
tmp := make([]int, n)
copy(tmp, nums)
*result = append(*result, tmp)
return
}
// nums[i]和其他不同元素交换位置
// nums[0:i]是已经决定的部分，nums[i:]是待决定部分，同时待选元素也都在nums[i:]
for k := i; k < n; k++ {
// 跳过重复数字
if k != i && nums[k] == nums[i] {
continue
}
nums[k], nums[i] = nums[i], nums[k]
helper2(nums, i+1, result)
}
// 还原状态
for k := n - 1; k > i; k-- {
nums[i], nums[k] = nums[k], nums[i]
}
}
|
// Package sample models an audio sample
package sample
import (
"testing"
)
func TestValueFromByteU8(t *testing.T) {
//TODO: Test
}
func TestValueFromByteS8(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesU16LSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesU16MSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesS16LSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesS16MSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesS32LSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesS32MSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesF32LSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesF32MSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesF64LSB(t *testing.T) {
//TODO: Test
}
func TestValueFromBytesF64MSB(t *testing.T) {
//TODO: Test
}
func TestValueToByteU8(t *testing.T) {
// TODO
}
func TestValueToByteS8(t *testing.T) {
// TODO
}
func TestValueToBytesU16LSB(t *testing.T) {
// TODO
}
func TestValueToBytesS16LSB(t *testing.T) {
// TODO
}
func TestValueToBytesS32LSB(t *testing.T) {
// TODO
}
func TestValueToBytesF32LSB(t *testing.T) {
// TODO
}
func TestValueToBytesF64LSB(t *testing.T) {
// TODO
}
func TestValueToUint8(t *testing.T) {
// TODO
}
func TestValueToInt8(t *testing.T) {
// TODO
}
func TestValueToUint16(t *testing.T) {
// TODO
}
func TestValueToInt16(t *testing.T) {
// TODO
}
func TestValueToInt32(t *testing.T) {
// TODO
}
|
package schema
import (
"io/ioutil"
"os"
"path/filepath"
"strings"
"github.com/Juniper/contrail/pkg/common"
"github.com/flosch/pongo2"
)
//TemplateConfig is configuration option for templates.
type TemplateConfig struct {
TemplateType string `yaml:"type"`
TemplatePath string `yaml:"template_path"`
OutputPath string `yaml:"output_path"`
}
func ensureDir(path string) error {
return os.MkdirAll(filepath.Dir(path), os.ModePerm)
}
func (config *TemplateConfig) load(base string) (*pongo2.Template, error) {
path := filepath.Join(base, config.TemplatePath)
templateCode, err := common.GetContent(path)
if err != nil {
return nil, err
}
return pongo2.FromString(string(templateCode))
}
// nolint: gocyclo
func (config *TemplateConfig) apply(templateBase string, api *API) error {
tpl, err := config.load(templateBase)
if err != nil {
return err
}
if err = ensureDir(config.OutputPath); err != nil {
return err
}
if config.TemplateType == "all" {
output, err :=
tpl.Execute(pongo2.Context{"schemas": api.Schemas, "types": api.Types})
if err != nil {
return err
}
err = ioutil.WriteFile(config.OutputPath, []byte(output), 0644)
if err != nil {
return err
}
} else if config.TemplateType == "type" {
for goName, typeDef := range api.Types {
output, err :=
tpl.Execute(pongo2.Context{"type": typeDef, "name": goName})
if err != nil {
return err
}
err = ioutil.WriteFile(
strings.Replace(config.OutputPath, "__resource__", common.CamelToSnake(goName), 1),
[]byte(output), 0644)
if err != nil {
return err
}
}
for _, schema := range api.Schemas {
if schema.Type == AbstractType || schema.ID == "" {
continue
}
goName := schema.JSONSchema.GoName
typeDef := schema.JSONSchema
typeName := schema.TypeName
output, err :=
tpl.Execute(pongo2.Context{"type": typeDef, "typename": typeName, "name": goName,
"references": schema.References,
"back_references": schema.BackReferences,
"parents": schema.Parents, "children": schema.Children})
if err != nil {
return err
}
err = ioutil.WriteFile(
strings.Replace(config.OutputPath, "__resource__", common.CamelToSnake(goName), 1),
[]byte(output), 0644)
if err != nil {
return err
}
}
} else if config.TemplateType == "alltype" {
types := []*Schema{}
for typeName, typeDef := range api.Types {
typeDef.GoName = typeName
types = append(types,
&Schema{
JSONSchema: typeDef,
Children: []*BackReference{},
BackReferences: map[string]*BackReference{},
})
}
for _, schema := range api.Schemas {
if schema.Type == AbstractType || schema.ID == "" {
continue
}
types = append(types, schema)
}
output, err :=
tpl.Execute(pongo2.Context{"types": types})
if err != nil {
return err
}
err = ioutil.WriteFile(config.OutputPath, []byte(output), 0644)
if err != nil {
return err
}
} else {
for _, schema := range api.Schemas {
if schema.Type == AbstractType || schema.ID == "" {
continue
}
output, err :=
tpl.Execute(pongo2.Context{"schema": schema, "types": api.Types})
if err != nil {
return err
}
err = ioutil.WriteFile(
strings.Replace(config.OutputPath, "__resource__", schema.ID, 1),
[]byte(output), 0644)
if err != nil {
return err
}
}
}
return nil
}
//LoadTemplates loads templates from config path.
func LoadTemplates(path string) ([]*TemplateConfig, error) {
var config []*TemplateConfig
err := common.LoadFile(path, &config)
return config, err
}
//ApplyTemplates applies templates and generate codes.
func ApplyTemplates(api *API, templateBase string, config []*TemplateConfig) error {
// Make custom filters available for everyone
/* When called like this: {{ dict_value|dict_get_JSONSchema_by_string_key:key_var }}
then: dict_value is here as `in' variable and key_var is here as `param'
This is needed to obtain value from map with a key in variable (not as a hardcoded string)
*/
err := pongo2.RegisterFilter("dict_get_JSONSchema_by_string_key",
func(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
m := in.Interface().(map[string]*JSONSchema)
return pongo2.AsValue(m[param.String()]), nil
})
if err != nil {
return err
}
for _, templateConfig := range config {
err := templateConfig.apply(templateBase, api)
if err != nil {
return err
}
}
return nil
}
|
package main
import (
"flag"
"fmt"
"log"
"net"
"runtime"
"strconv"
"sync"
"time"
)
func genGameId() chan int {
ch := make(chan int)
go func() {
for i := 0; ; i++ {
ch <- (i*37+39)%(*games) + 1
}
}()
return ch
}
func genO1() chan string {
ch := make(chan string)
go func() {
for {
select {
case ch <- "0":
case ch <- "1":
}
}
}()
return ch
}
var host *string = flag.String("host", "localhost:10082", "服务器host:port")
var prefix *string = flag.String("prefix", "cs", "客服ID前缀")
var csMin *int = flag.Int("csMin", 1, "客服ID最小值")
var csMax *int = flag.Int("csMax", 60, "客服ID最大值")
var nid *bool = flag.Bool("nid", false, "是否发送NID验证，在接入立即发送")
var feedback *bool = flag.Bool("fb", false, "是否发送feedback请求，在挂断前发送")
var msgs *int = flag.Int("msgs", 0, "每个用户的聊天消息限制，超过数量挂断用户，0 表示不限制")
var dispatch *int = flag.Int("dp", 0, "每个用户在接收多少条消息时转接，0 表示不转接，转接时为了区别发送的是预览消息")
var away *time.Duration = flag.Duration("away", 0, "客服在登录多少秒之后离开，0 表示不离开")
var back *time.Duration = flag.Duration("back", 0, "客服在离开多少秒之后回来，0 表示不回来")
var maxconn *int = flag.Int("maxConn", 5, "客服可接人数")
var issue *string = flag.String("issue", "cs ==> usr [i get your issue msg]", "默认的消息回复内容")
var issueDispatch *string = flag.String("issueDispatch", "cs ==> usr [i get your dispatch issue msg]", "默认的转接消息回复内容")
var issuePreview *string = flag.String("preview", "cs ==> usr [i get your issue preview msg]", "默认的消息预览回复内容")
var games *int = flag.Int("game", 600, "转接玩家游戏ID随机范围1~game")
var msgGap *time.Duration = flag.Duration("msgGap", 3, "消息频率（秒）")
var logFile *string = flag.String("log", "./cs.log", "日志记录文件")
var genGame chan int = genGameId()
var genZeroOne chan string = genO1()
var wg sync.WaitGroup
func main() {
flag.Parse()
runtime.GOMAXPROCS(runtime.NumCPU())
LogStart()
auth()
addr, err := net.ResolveTCPAddr("tcp4", *host)
if err != nil {
fmt.Println(err)
}
for i := *csMin; i <= *csMax; i++ {
conn, err1 := net.DialTCP("tcp4", nil, addr)
if err1 != nil {
log.Printf("[%d] 连接服务器失败 %s", i, err1)
continue
}
conn.SetKeepAlive(true)
conn.SetNoDelay(true)
conn.SetLinger(-1)
csId := *prefix + strconv.Itoa(i)
maxConn := strconv.Itoa(*maxconn)
go handler(conn, csId, maxConn)
}
wg.Wait()
}
|
package reader
import (
"fmt"
"os"
"sync"
)
type resultWriter struct {
fileName string
resChan chan responseResult
wg *sync.WaitGroup
}
func newResultWriter(fileName string, resChan chan responseResult, wg *sync.WaitGroup) *resultWriter {
return &resultWriter{
fileName: fileName,
resChan: resChan,
wg: wg,
}
}
func (rw *resultWriter) asyncWrite() {
rw.wg.Add(1)
go rw.write()
}
func (rw *resultWriter) write() {
defer rw.wg.Done()
file, err := os.Create(rw.fileName)
if err != nil {
fmt.Println(err)
}
defer file.Close()
count := 0
for res := range rw.resChan {
_, err := file.Write([]byte(res.String()))
if err != nil {
fmt.Println(err)
}
count++
if count%10 == 0 {
fmt.Printf("[W] %d messages\n", count)
}
}
fmt.Printf("DONE WRITING TO FILE [%d messages]\n", count)
}
|
package client
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"path/filepath"
"github.com/go-gonzo/npm/commonjs/package"
)
const pkgNotFound = "Package (%s@%s) Not Found."
const (
NPM = "http://registry.npmjs.org/"
)
func Get(name, version string) (*pkg.Package, error) {
npm, err := url.Parse(NPM)
if err != nil {
return nil, err
}
npm.Path = filepath.Join(npm.Path, name, version)
resp, err := http.Get(npm.String())
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusNotFound {
return nil, fmt.Errorf(pkgNotFound, name, version)
}
pkg := &pkg.Package{}
err = json.NewDecoder(resp.Body).Decode(pkg)
return pkg, err
}
|
package issuer
import (
"context"
"strings"
"github.com/kumahq/kuma/pkg/core/resources/apis/system"
"github.com/kumahq/kuma/pkg/core/resources/manager"
core_model "github.com/kumahq/kuma/pkg/core/resources/model"
core_store "github.com/kumahq/kuma/pkg/core/resources/store"
)
var RevocationsSecretKey = core_model.ResourceKey{
Name: "user-token-revocations",
Mesh: core_model.NoMesh,
}
type TokenRevocations interface {
IsRevoked(id string) (bool, error)
}
func NewTokenRevocations(manager manager.ReadOnlyResourceManager) TokenRevocations {
return &secretsTokenRevocations{
manager: manager,
}
}
type secretsTokenRevocations struct {
manager manager.ReadOnlyResourceManager
}
func (s *secretsTokenRevocations) IsRevoked(id string) (bool, error) {
secret := system.NewGlobalSecretResource()
if err := s.manager.Get(context.Background(), secret, core_store.GetBy(RevocationsSecretKey)); err != nil {
if core_store.IsResourceNotFound(err) { // todo gets not found are not cached, we should cache it by ourselves here
return false, nil
}
return false, err
}
rawIds := strings.TrimSuffix(string(secret.Spec.GetData().GetValue()), "\n")
ids := strings.Split(rawIds, ",")
for _, revokedId := range ids {
if revokedId == id {
return true, nil
}
}
return false, nil
}
|
package repository
import (
"github.com/asdine/storm"
"github.com/cswank/quimby/internal/schema"
)
// Gadget does database-y things.
type Gadget struct {
db *storm.DB
}
func newGadget(db *storm.DB) *Gadget {
return &Gadget{
db: db,
}
}
func (g Gadget) GetAll() ([]schema.Gadget, error) {
var out []schema.Gadget
return out, g.db.All(&out)
}
func (g Gadget) Get(id int) (schema.Gadget, error) {
var out schema.Gadget
return out, g.db.One("ID", id, &out)
}
func (g Gadget) Create(name, url string) (*schema.Gadget, error) {
out := &schema.Gadget{Name: name, URL: url}
return out, g.db.Save(out)
}
func (g Gadget) Delete(id int) error {
out := &schema.Gadget{ID: id}
return g.db.DeleteStruct(out)
}
func (g Gadget) Update(id int, name, url string) error {
return g.db.Update(&schema.Gadget{ID: id, Name: name, URL: url})
}
func (g Gadget) List() ([]schema.Gadget, error) {
var gs []schema.Gadget
return gs, g.db.All(&gs)
}
|
package day05
import (
"bytes"
"encoding/json"
"fmt"
"log"
)
func MarshalUnmashalArr() {
var arr [3]string
marshalArr(arr)
unmarshalArr(arr)
}
func marshalArr(arr [3]string) { //编码JSON
fmt.Println("------编码JSON------")
arr = [3]string{"足球", "篮球", "乒乓球"}
if bytSli, err := json.Marshal(arr); err != nil {
log.Fatalln(err)
} else {
fmt.Printf("%s\n", bytSli)
}
}
func unmarshalArr(arr [3]string) { //解码JSON
fmt.Println("------解码JSON------")
jsonStr := `["足球","篮球","乒乓球"]`
bytSli := bytes.NewBufferString(jsonStr).Bytes()
if err := json.Unmarshal(bytSli, &arr); err != nil {
log.Fatalln(err)
} else {
fmt.Printf("%v\t %T\n", arr, arr)
}
}
|
package model
type Model struct {
ID uint32 `gorm:"primary_key" json:"id`
CreatedBy string `json:"created_by"`
ModifiedBy string `json:"modified_by"`
CreatedOn uint32 `json:"created_on"`
ModifiedOn uint32 `json:"modified_on"`
DeletededOn uint32 `json:"deleted_on"`
IsDel uint `json:"is_del`
}
|
package log
import (
"github.com/astaxie/beego/logs"
)
var (
log *logs.BeeLogger
)
func init() {
log = logs.NewLogger()
log.SetLogFuncCallDepth(3)
log.SetLogger(logs.AdapterConsole)
log.EnableFuncCallDepth(true)
log.Debug("this is a debug message")
}
func Info(format string, v ...interface{}) {
log.Info(format, v...)
}
func Error(format string, v ...interface{}) {
log.Error(format, v...)
}
|
package main
import (
"EsAlertLog/Service"
"EsAlertLog/utils"
"flag"
"fmt"
)
func Processor() {
logger:=utils.CreateLogger()
espath := flag.String("c", "", "Elasticsearch连接配置文件路径")
rulepath := flag.String("f", "", "告警规则配置文件路径")
mailpath := flag.String("m", "", "发件箱信息")
flag.Parse()
Ei, err := utils.NewEsInfo(*espath)
if err != nil {
logger.Panicln(err)
}
Rsi, err := utils.NewRulesInfo(*rulepath)
if err != nil {
logger.Panicln(err)
}
Mi, err := utils.ParseMailconf(*mailpath)
if err != nil {
logger.Panicln(err)
}
newclient, err := utils.NewEsClient(Ei)
if err!=nil{
logger.Panicln(err)
}
ResChan := make(chan utils.ResultInfo, 100)
esprocessclient := &Service.ProcessClient{
Pclient: newclient,
ResChan:ResChan,
}
esprocessclient.Process(Rsi)
Service.SendMail(ResChan, Mi)
}
func main() {
//解析Flag参数
fmt.Println("开始执行......")
logger:=utils.CreateLogger()
logger.Println("开始执行......")
Processor()
}
|
package string
import "strings"
// strings.Index的UTF-8版本
// 即 Utf8Index("Go语言中文网", "中文") 返回 4，而不是strings.Index的 8
func Utf8Index(str, substr string) int {
asciiPos := strings.Index(str, substr)
if asciiPos == -1 || asciiPos == 0 {
return asciiPos
}
pos := 0
totalSize := 0
reader := strings.NewReader(str)
for _, size, err := reader.ReadRune(); err == nil; _, size, err = reader.ReadRune() {
totalSize += size
pos++
// 匹配到
if totalSize == asciiPos {
return pos
}
}
return pos
}
|
package heap
import "fmt"
type minHeap struct {
Capacity int
Array []int
}
func NewEmptyMinHeap() Heap {
return &minHeap{
Capacity: 0,
Array: make([]int, 0),
}
}
func (h *minHeap) AddElement(e int) {
h.Array = append(h.Array, e)
h.Capacity++
j := h.Capacity - 1
for j > 0 {
if h.Array[j] < h.Array[h.parentIndex(j)] {
h.Array[j], h.Array[h.parentIndex(j)] = h.Array[h.parentIndex(j)], h.Array[j]
j = h.parentIndex(j)
} else {
break
}
}
}
func (h *minHeap) RemoveElement() error {
if h.Capacity <= 0 {
return HeapEmptyError
}
h.Array[0] = h.Array[h.Capacity-1]
h.Capacity--
i := 0
for h.leftIndex(i) < h.Capacity {
min := h.minIndexInTripe(i)
if i != min {
h.Array[i], h.Array[min] = h.Array[min], h.Array[i]
i = min
} else {
break
}
}
return nil
}
func (h *minHeap) TopElement() (int, error) {
if h.Capacity > 0 {
return h.Array[0], nil
}
return 0, HeapEmptyError
}
func (h *minHeap) Print() {
for i := 0; i < h.Capacity; i++ {
fmt.Printf("%d:%d ", i, h.Array[i])
}
fmt.Println()
}
func (h *minHeap) leftIndex(i int) int {
return 2*i + 1
}
func (h *minHeap) rightIndex(i int) int {
return 2*i + 2
}
func (h *minHeap) parentIndex(i int) int {
return (i - 1) / 2
}
func (h *minHeap) minIndexInTripe(i int) int {
ret := i
l := h.leftIndex(i)
r := h.rightIndex(i)
if l < h.Capacity && h.Array[l] < h.Array[ret] {
ret = l
}
if r < h.Capacity && h.Array[r] < h.Array[ret] {
ret = r
}
return ret
}
|
package ansilog
import (
"context"
"crypto/tls"
"crypto/x509"
"fmt"
"io"
"os"
"time"
"github.com/jackc/pgx/v4/pgxpool"
"github.com/oblq/ansilog/internal/hooks/pghook"
"github.com/oblq/ansilog/internal/hooks/stack_trace"
"github.com/oblq/swap"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
)
type TLSConfig struct {
ServerCa string `yaml:"server_ca.pem"`
ClientCert string `yaml:"client_cert.pem"`
ClientKey string `yaml:"client_key.pem"`
}
type Config struct {
// Out is a writer where logs are written.
// Optional. Default value is os.Stdout.
Out io.Writer
// The logging level the logger should log at.
// This defaults to `info`, which allows
// Info(), Warn(), Error() and Fatal() to be logged.
// Allowed values are:
// panic, fatal, error, warn, warning, info, debug and trace.
Level string
// StackTrace will extract stack-trace from errors created
// with "github.com/pkg/errors" package
// using Wrap() or WithStack() funcs.
StackTrace bool
// PostgresLevel > 0 will initialize a new postgres instance for the corresponding hook,
// also, postgres parameters must be provided in that case
PostgresLevel string
// Postgres
Host string
Port int
DB string
User string
Password string
TLSConfig *TLSConfig `yaml:",omitempty"`
}
type Logger struct {
*logrus.Logger
}
func NewWithConfig(config Config) (logger *Logger, err error) {
logger = &Logger{Logger: logrus.New()}
err = logger.setup(config)
return
}
func NewWithConfigPath(configFilePath string) (logger *Logger, err error) {
if len(configFilePath) == 0 {
return nil, errors.New("[ansilog hook] a valid config file path must be provided")
}
logger = &Logger{Logger: logrus.New()}
var config Config
if err = swap.Parse(&config, configFilePath); err != nil {
return
}
err = logger.setup(config)
return
}
func (l *Logger) Configure(configFiles ...string) (err error) {
l.Logger = logrus.New()
var config Config
if err = swap.Parse(&config, configFiles...); err != nil {
return err
}
if err = l.setup(config); err != nil {
return err
}
return
}
func (l *Logger) setup(config Config) error {
if config.Out != nil {
l.Out = config.Out
} else {
l.Out = os.Stdout
}
level, err := logrus.ParseLevel(config.Level)
if err != nil {
level = logrus.InfoLevel
}
l.Logger.Level = level
// config.Level
//log.Formatter = &logrus.JSONFormatter{
// time.RFC3339,
// false,
// nil,
//}
l.Formatter = &logrus.TextFormatter{
ForceColors: true,
DisableTimestamp: false,
FullTimestamp: true,
TimestampFormat: time.RFC3339, //"2006-01-02 15:04:05", // time.RFC3339, // //"2006-01-02 15:04 Z07:00", 2006-01-02T15:04:05-0700
DisableSorting: false,
DisableLevelTruncation: true,
QuoteEmptyFields: true,
}
//l.Formatter = &logrus.JSONFormatter{
// TimestampFormat: "2006-01-02 15:04:05",
// DisableTimestamp: false,
// DisableHTMLEscape: false,
// DataKey: "",
// FieldMap: nil,
// CallerPrettyfier: nil,
// PrettyPrint: true,
//}
if config.StackTrace {
l.AddHook(stack_trace.New())
}
if len(config.PostgresLevel) > 0 {
format := "postgres://%s:%s@%s:%d/%s?pool_max_conns=%d"
dbURL := fmt.Sprintf(format, config.User, config.Password, config.Host, config.Port, config.DB, 8)
if config.TLSConfig != nil {
dbURL += "&sslmode=require"
}
poolConfig, err := pgxpool.ParseConfig(dbURL)
if err != nil {
return errors.New("[ansilog hook] unable to parse db url: " + err.Error())
}
if config.TLSConfig != nil {
caCertPool := x509.NewCertPool()
ok := caCertPool.AppendCertsFromPEM([]byte(config.TLSConfig.ServerCa))
if !ok {
return errors.New("failed to append CA certificate")
}
var keyPair tls.Certificate
keyPair, err = tls.X509KeyPair([]byte(config.TLSConfig.ClientCert), []byte(config.TLSConfig.ClientKey))
//keyPair, err = tls.LoadX509KeyPair(pg.config.TLSConfig.ClientCert, pg.config.TLSConfig.ClientKey)
if err != nil {
return err
}
tlsConfig := &tls.Config{
RootCAs: caCertPool,
Certificates: []tls.Certificate{keyPair},
InsecureSkipVerify: true,
//ServerName: pg.config.Host, // the CA certificate must contain the IP SAN
}
poolConfig.ConnConfig.TLSConfig = tlsConfig
}
pool, err := pgxpool.ConnectConfig(context.Background(), poolConfig)
if err != nil {
return fmt.Errorf("unable to connect to postgres: %v\n", errors.WithStack(err))
}
// NewAsyncHook
hook := pghook.NewHook(pool)
//defer hook.Flush()
pgLevel, err := logrus.ParseLevel(config.PostgresLevel)
if err != nil {
return fmt.Errorf("[logger] invalid postgres level, no log will be saved to it: %+v", config.PostgresLevel)
}
hook.AddFilter(func(entry *logrus.Entry) *logrus.Entry {
if entry != nil {
// ignore entries
if _, ignore := entry.Data["ignore"]; ignore || entry.Level > pgLevel {
entry = nil
}
}
return entry
})
l.AddHook(hook)
}
return nil
}
|
package pool
import (
"container/heap"
"fmt"
"time"
"github.com/zmb3/spotify"
)
type Pool struct {
PlaylistID spotify.ID `json:"playlistid"`
PlaylistName string `'json:"playlist_name`
UserID string `json:"userid"`
// TimeStarted
SongHeap []*Song `json:"songheap"`
UserToVoteMap map[string][]string
}
type Song struct {
ID spotify.ID
Upvotes int `json:"upvotes"`
Downvotes int `json:"downvotes"`
Priority int `json:"priority"`
index int `json:"index"` // index into the priorty queue
TimeAdded time.Time `json:"timeadded"`
// meta
Album string `json:"albumname"`
Images []spotify.Image `json:"images"`
Artists []spotify.SimpleArtist `json:"artists"`
Duration int `json"duration"`
Name string `json:"name"`
}
func (s *Song) String() string {
return s.ID.String() + ", Priority: " + fmt.Sprintf("%d", s.Priority)
}
func (p *Pool) UpVote(id spotify.ID, userID string) {
for i := range p.SongHeap {
if p.SongHeap[i].ID == id {
//fmt.Printf("(UpVote) Updated priority of %s is %d\n", v.ID, v.Priority)
p.SongHeap[i].Upvotes++
p.SongHeap[i].Priority++
p.update(p.SongHeap[i], p.SongHeap[i].Priority)
p.UserToVoteMap[userID] = append(p.UserToVoteMap[userID], p.SongHeap[i].ID.String())
return
}
}
fmt.Println("(UpVote) DID NOT FIND SONG")
}
func (p *Pool) DownVote(id spotify.ID, userID string) {
//song := p.FindSong(id)
for i := range p.SongHeap {
if p.SongHeap[i].ID == id {
//fmt.Printf("(UpVote) Updated priority of %s is %d\n", v.ID, v.Priority)
p.SongHeap[i].Downvotes++
p.SongHeap[i].Priority--
p.update(p.SongHeap[i], p.SongHeap[i].Priority)
p.UserToVoteMap[userID] = append(p.UserToVoteMap[userID], p.SongHeap[i].ID.String())
return
}
}
fmt.Println("(DownVote) DID NOT FIND SONG")
}
func (p *Pool) Len() int { return len(p.SongHeap) }
func (p *Pool) Less(i, j int) bool {
return p.SongHeap[i].Priority > p.SongHeap[j].Priority
}
func (p *Pool) Swap(i, j int) {
p.SongHeap[i], p.SongHeap[j] = p.SongHeap[j], p.SongHeap[i]
p.SongHeap[i].index = i
p.SongHeap[j].index = j
}
func (p *Pool) Push(x interface{}) {
n := len(p.SongHeap)
item := x.(*Song)
item.index = n
p.SongHeap = append(p.SongHeap, item)
}
func (p *Pool) Pop() interface{} {
old := p.SongHeap
n := len(old)
item := old[n-1]
item.index = -1 // for safety
p.SongHeap = old[:n-1]
return item
}
// update modifies the priority and value of an Item in the queue.
func (pq *Pool) update(item *Song, priority int) {
//fmt.Println("(update) Requested priority: ", priority)
//fmt.Println("(update) Old priority of " + item.ID.String(), item.Priority)
item.Priority = priority
heap.Fix(pq, item.index)
//fmt.Println("(update) Updated priority of " + item.ID.String(), item.Priority)
}
func (p *Pool) copyPool() *Pool {
ps := &Pool{
PlaylistID: p.PlaylistID,
UserID: p.UserID,
SongHeap: make([]*Song, len(p.SongHeap)),
}
copy(ps.SongHeap, p.SongHeap)
return ps
}
func (p *Pool) getSecondSong() *Song {
poolCopy := p.copyPool()
firstSong := heap.Pop(poolCopy)
song := heap.Pop(poolCopy)
heap.Push(p, firstSong)
heap.Push(p, song)
return song.(*Song)
}
func (p *Pool) UpdateSpotifyPlaylist(c *spotify.Client, playlistId spotify.ID) {
playlist, err := c.GetPlaylistTracks(p.UserID, playlistId)
if err != nil {
fmt.Println("ERROR: (UpdateSpotifyPlaylist) ", err.Error())
}
trackToRemoveId := playlist.Tracks[1].Track.ID
trackToAddId := p.getSecondSong().ID
//fmt.Println("To Remove: ", trackToRemoveId)
//fmt.Println("To Add: ", trackToAddId)
if trackToAddId != trackToRemoveId {
//fmt.Println("(UpdateSpotifyPlaylist) Next song is not the correct one!")
newPlayListId, _ := c.RemoveTracksFromPlaylist(p.UserID, playlistId, trackToRemoveId)
newPlayListId, _ = c.AddTracksToPlaylist(p.UserID, spotify.ID(newPlayListId), trackToAddId)
} else {
//fmt.Println("(UpdateSpotifyPlaylist) Next song is correct!!")
}
}
func (p *Pool) AddNextSong(c *spotify.Client) {
firstSong := heap.Pop(p)
nextSong := heap.Pop(p)
toBeNextSong := heap.Pop(p)
//fmt.Println("first song: ", firstSong,"next song: ", nextSong, "to be next song: ", toBeNextSong)
_, err := c.RemoveTracksFromPlaylist(p.UserID, p.PlaylistID, firstSong.(*Song).ID)
if err != nil {
fmt.Println("remove error: ", err)
}
heap.Push(p, toBeNextSong)
heap.Push(p, nextSong)
c.AddTracksToPlaylist(p.UserID, p.PlaylistID, toBeNextSong.(*Song).ID)
}
func (p *Pool) HasUserVoted(userId string, songID string) bool {
_, ok := p.UserToVoteMap[userId]
if ok{
votedSongs := p.UserToVoteMap[userId]
for i := range votedSongs{
if votedSongs[i] == songID{
return true
}
}
}
return false
}
func TrackToSong(track *spotify.FullTrack, priority int) *Song {
return &Song{
ID: track.ID,
Name: track.Name,
Duration: track.Duration,
Album: track.Album.Name,
Images: track.Album.Images,
Artists: track.Artists,
Priority: priority,
}
}
|
package main
import (
"log"
"os"
"bytes"
"compress/gzip"
"io"
"flag"
"strings"
"github.com/hoisie/mustache"
"io/ioutil"
"regexp"
"fmt"
"github.com/murz/eg/proxy"
"github.com/murz/eg/templates"
)
func main() {
var path string;
flag.StringVar(&path, "path", "/", "")
args := os.Args[1:len(os.Args)] // throw out the first one because it's always eg
if len(args) > 0 {
switch args[0] {
case "new", "n":
new(args)
case "help":
help(args)
case "build", "b":
build(args)
case "run", "r":
run(args)
case "remove", "rm", "del", "delete":
delete(args)
}
}
}
func checkErr(err error) {
if err != nil {
log.Fatal(err)
}
}
func run(args []string) {
args = args[1:len(args)] // shave off the 'run' arg
processFlags(args)
proxy.Run()
}
func new(args []string) {
if len(args) < 2 {
log.Print("ego: Not enough args for `eg new`. Use `eg help` for more info.")
return
}
args = args[1:len(args)] // shave off the 'new' arg
switch(args[0]) {
case "app":
newApp(args)
case "controller", "ctrlr", "ctrl", "c":
newController(args)
case "action", "actn":
newAction(args)
}
}
func delete(args []string) {
if len(args) < 2 {
log.Print("ego: Not enough args for `eg delete`. Use `eg help` for more info.")
return
}
args = args[1:len(args)] // shave off the 'new' arg
switch(args[0]) {
case "action":
deleteAction(args)
}
}
func newApp(args []string) {
if len(args) < 2 {
log.Print("ego: Not enough args for `eg new app`. Use `eg help` for more info.")
return
}
args = args[1:len(args)] // shave off the 'app' arg
name := args[0]
os.Mkdir(name, 0777)
os.Mkdir(name+"/app", 0777)
os.Mkdir(name+"/app/controllers", 0777)
os.Mkdir(name+"/app/helpers", 0777)
os.Mkdir(name+"/app/models", 0777)
os.Mkdir(name+"/app/views", 0777)
os.Mkdir(name+"/app/views/errors", 0777)
os.Mkdir(name+"/app/assets", 0777)
os.Mkdir(name+"/app/assets/javascripts", 0777)
os.Mkdir(name+"/app/assets/stylesheets", 0777)
os.Mkdir(name+"/app/assets/images", 0777)
os.Mkdir(name+"/conf", 0777)
os.Mkdir(name+"/public", 0777)
routesconf := mustache.Render(string(templates.Routes()), map[string]string{})
routesconfFile, _ := os.Create(name+"/conf/routes.go")
routesconfFile.Write([]byte(routesconf))
dbconf := mustache.Render(string(templates.Databases()), map[string]string{})
dbconfFile, _ := os.Create(name+"/conf/db.go")
dbconfFile.Write([]byte(dbconf))
error404view := mustache.Render(string(error_html_mustache()), map[string]string {
"Message": "404 Not Found",
})
error404viewFile, _ := os.Create(name+"/app/views/errors/404.html")
error404viewFile.Write([]byte(error404view))
error501view := mustache.Render(string(error_html_mustache()), map[string]string {
"Message": "501 Not Implemented",
})
error501viewFile, _ := os.Create(name+"/app/views/errors/501.html")
error501viewFile.Write([]byte(error501view))
log.Printf("Your new ego application, '%v', was successfully created", args[0])
}
var flags = map[string]string {
"file": "",
"method": "GET",
"path": "/",
"port": "5000",
}
func newController(args []string) {
if len(args) < 2 {
log.Print("ego: Not enough args for `eg new controller`. Use `eg help` for more info.")
return
}
if (!checkDirs([]string{
"app",
"app/controllers",
})) {
log.Print("ego: You must be in an ego project directory to use `eg new controller`.")
return
}
// defFlag("method", "m", "GET")
// defFlag("path", "p", "/")
// flag.Parse()
name := args[1]
args = args[2:len(args)] // shave off the 'action name' args
processFlags(args)
ctrlFile, err := os.Create("app/controllers/"+strings.ToLower(name)+"_controller.go")
checkErr(err)
ctrl := mustache.Render(string(templates.Controller()), map[string]string {
"Name": strings.Title(name) + "Controller",
"Embed": "*http.Controller",
})
ctrlFile.WriteString(ctrl)
log.Printf("Controller '%v', was successfully created", name)
}
func newAction(args []string) {
if len(args) < 2 {
log.Print("ego: Not enough args for `eg new action`. Use `eg help` for more info.")
return
}
if (!checkDirs([]string{
"app",
"app/actions",
})) {
log.Print("ego: You must be in an ego project directory to use `eg new action`.")
return
}
// defFlag("method", "m", "GET")
// defFlag("path", "p", "/")
// flag.Parse()
name := args[1]
args = args[2:len(args)] // shave off the 'action name' args
processFlags(args)
var actionFile *os.File
var err error
if flags["file"] != "" {
actionFile, err = os.OpenFile("app/actions/"+flags["file"], os.O_WRONLY, 777)
checkErr(err)
} else {
actionFile, err = os.Create("app/actions/"+strings.ToLower(name)+".go")
checkErr(err)
cruft := mustache.Render(string(actionfile_go_mustache()), map[string]string {})
actionFile.WriteString(cruft)
}
action := mustache.Render(string(action_go_mustache()), map[string]string {
"Name": strings.Title(name),
"Path": flags["path"],
"Method": flags["method"],
})
actionFile.Seek(0, 2)
actionFile.WriteString("\n\n")
actionFile.WriteString(action)
log.Printf("Action '%v', was successfully created", name)
}
func deleteAction(args []string) {
if len(args) < 2 {
log.Print("ego: Not enough args for `eg rm action`. Use `eg help` for more info.")
return
}
if (!checkDirs([]string{
"app",
"app/actions",
})) {
log.Print("ego: You must be in an ego project directory to use `eg rm action`.")
return
}
name := args[1]
args = args[2:len(args)] // shave off the 'action name' args
processFlags(args)
if flags["file"] == "" {
log.Print("ego: Must specify -file with `eg rm action`")
}
actionFile, err := os.OpenFile("app/actions/"+flags["file"], os.O_RDWR, 777)
checkErr(err)
bytes, err := ioutil.ReadAll(actionFile)
checkErr(err)
expString := fmt.Sprintf("(?is)\\n\\nvar %v = actions\\.register.+?}\\)", name)
exp, err := regexp.Compile(expString)
checkErr(err)
pos := exp.FindAllIndex(bytes, -1)
oldStr := string(bytes)
str := make([]byte, pos[0][1] - pos[0][0])
actionFile.ReadAt(str, int64(pos[0][0]))
newStr := strings.Replace(oldStr, string(str), "", -1)
actionFile.Truncate(0)
actionFile.Seek(0, 0)
actionFile.WriteString(newStr)
log.Printf("pos: %v", pos)
}
func processFlags(args []string) {
next := ""
for _, arg := range args {
if next != "" {
flags[next] = arg
next = ""
} else if arg[0:1] == "-" {
name := arg[1:]
if name[0:1] == "-" {
name = name[1:]
}
pieces := strings.Split(name, "=")
if len(pieces) > 1 {
flags[pieces[0]] = pieces[1]
} else {
next = name
}
}
}
}
func build(args []string) {
// package views
// dirlist, err := ioutil.ReadDir("/app/views")
// if err != nil {
// log.Fatalf("Error reading %s: %s\n", dirname, err)
// }
// for _, f := range dirlist {
// filename := path.Join(tm.pkgName, dirname, f.Name())
// if f.IsDir() {
// tm.ParseDir(path.Join(dirname, f.Name()))
// } else {
// tm.Parse(filename)
// }
// }
}
func help(args []string) {
log.Print("lol.. todo")
}
func checkDirs(dirs []string) bool {
// var dirs = []string{
// "app",
// "app/actions",
// "app/models",
// "conf",
// "conf/app.json",
// "public",
// }
for _, dir := range dirs {
if ex, _ := exists(dir); !ex {
return false
}
}
return true
}
type Flag struct {
Name string
Value *string
Alt *string
}
var flagMap = make(map[string]*Flag)
func defFlag(name string, alt string, def string) {
var f = flag.String(name, def, "")
var altf = flag.String(alt, def, "")
fl := &Flag{
Name: name,
Value: f,
Alt: altf,
}
flagMap[name] = fl
}
func getFlag(name string) *Flag {
return flagMap[name]
}
func exists(path string) (bool, error) {
_, err := os.Stat(path)
if err == nil { return true, nil }
if os.IsNotExist(err) { return false, nil }
return false, err
}
// Templates
func server_go_mustache() []byte {
gz, err := gzip.NewReader(bytes.NewBuffer([]byte{
0x1f,0x8b,0x08,0x00,0x00,0x09,0x6e,0x88,0x00,0xff,0x34,0xcc,
0x3d,0xca,0x02,0x31,0x10,0x80,0xe1,0x3a,0x73,0x8a,0x61,0xaa,
0xa4,0xd9,0x14,0x5f,0xf7,0x81,0x57,0xd8,0x42,0x0f,0x20,0x63,
0x18,0xd7,0x20,0xf9,0x21,0x3f,0x2b,0x18,0x72,0x77,0x17,0xc1,
0xb7,0x7f,0xde,0xcc,0xee,0xc9,0x9b,0x60,0x60,0x1f,0x01,0x7c,
0xc8,0xa9,0x34,0xd4,0xa0,0x68,0xf3,0xed,0xd1,0x6f,0x8b,0x4b,
0xc1,0x86,0x5e,0xde,0x56,0xb6,0x44,0xa0,0xae,0x48,0x63,0xac,
0x1c,0x64,0x4e,0xcb,0x39,0x5b,0x76,0xcd,0xa7,0x58,0x09,0x0c,
0xc0,0xbd,0x47,0xf7,0xfd,0x68,0x83,0x03,0xd4,0xce,0x05,0x2b,
0x9e,0xf0,0x80,0xcb,0x2a,0xaf,0x8b,0x94,0x5d,0x8a,0xfe,0x69,
0x03,0xaa,0x2e,0xe7,0x1e,0x35,0xfd,0xff,0x1d,0x91,0x81,0xf9,
0x09,0x00,0x00,0xff,0xff,0xb2,0x01,0x5a,0x7e,0x8b,0x00,0x00,
0x00,
}))
if err != nil {
panic("Decompression failed: " + err.Error())
}
var b bytes.Buffer
io.Copy(&b, gz)
gz.Close()
return b.Bytes()
}
func db_json_mustache() []byte {
gz, err := gzip.NewReader(bytes.NewBuffer([]byte{
0x1f,0x8b,0x08,0x00,0x00,0x09,0x6e,0x88,0x00,0xff,0xaa,0xe6,
0xe2,0x54,0x4a,0x29,0xca,0x2c,0x4b,0x2d,0x52,0xb2,0x52,0x50,
0x2a,0xc8,0x2f,0x2e,0x49,0x2f,0x4a,0x2d,0x56,0xd2,0x01,0x0a,
0xe7,0x25,0xe6,0xa6,0x82,0x04,0x4b,0xf2,0x53,0xf2,0xe3,0x53,
0x52,0x73,0xf3,0xc1,0xa2,0xa5,0xc5,0x10,0xa5,0xa8,0xa2,0x05,
0x89,0xc5,0xc5,0xe5,0xf9,0x45,0x29,0x60,0x43,0x60,0x6c,0xae,
0x5a,0x40,0x00,0x00,0x00,0xff,0xff,0xb8,0x0c,0x60,0x76,0x5e,
0x00,0x00,0x00,
}))
if err != nil {
panic("Decompression failed: " + err.Error())
}
var b bytes.Buffer
io.Copy(&b, gz)
gz.Close()
return b.Bytes()
}
func app_json_mustache() []byte {
gz, err := gzip.NewReader(bytes.NewBuffer([]byte{
0x1f,0x8b,0x08,0x00,0x00,0x09,0x6e,0x88,0x00,0xff,0xaa,0xe6,
0xe2,0xe4,0xaa,0x05,0x04,0x00,0x00,0xff,0xff,0x23,0x18,0x17,
0xfc,0x05,0x00,0x00,0x00,
}))
if err != nil {
panic("Decompression failed: " + err.Error())
}
var b bytes.Buffer
io.Copy(&b, gz)
gz.Close()
return b.Bytes()
}
func actionfile_go_mustache() []byte {
gz, err := gzip.NewReader(bytes.NewBuffer([]byte{
0x1f,0x8b,0x08,0x00,0x00,0x09,0x6e,0x88,0x00,0xff,0x2a,0x48,
0x4c,0xce,0x4e,0x4c,0x4f,0x55,0x48,0x4c,0x2e,0xc9,0xcc,0xcf,
0x2b,0xe6,0xe2,0xca,0xcc,0x2d,0xc8,0x2f,0x2a,0x51,0xd0,0xe0,
0xe2,0x54,0x4a,0xcf,0x2c,0xc9,0x28,0x4d,0xd2,0x4b,0xce,0xcf,
0xd5,0xcf,0x2d,0x2d,0xaa,0xd2,0x4f,0x4d,0xcf,0xd7,0x87,0xaa,
0x53,0xc2,0x21,0x9d,0x51,0x52,0x52,0xa0,0xc4,0xa5,0xc9,0x05,
0x08,0x00,0x00,0xff,0xff,0x0b,0xc9,0xe7,0xd0,0x57,0x00,0x00,
0x00,
}))
if err != nil {
panic("Decompression failed: " + err.Error())
}
var b bytes.Buffer
io.Copy(&b, gz)
gz.Close()
return b.Bytes()
}
func action_go_mustache() []byte {
gz, err := gzip.NewReader(bytes.NewBuffer([]byte{
0x1f,0x8b,0x08,0x00,0x00,0x09,0x6e,0x88,0x00,0xff,0x3c,0x8e,
0xc1,0xaa,0x83,0x30,0x10,0x45,0xd7,0xc9,0x57,0x0c,0x2e,0x1e,
0xfa,0x10,0xdd,0x0b,0x5d,0x14,0xda,0x45,0x17,0xd5,0x22,0xfd,
0x81,0xa0,0xd3,0x46,0xd0,0xa8,0xc9,0xa4,0x14,0xc2,0xfc,0x7b,
0xad,0x4a,0x77,0x77,0x0e,0x77,0x0e,0xf7,0xa5,0x2c,0x84,0x50,
0xaa,0x01,0x99,0xe1,0x00,0xaa,0xa1,0x6e,0x34,0x2e,0xab,0xf1,
0xd9,0x39,0x42,0x1b,0xff,0x69,0xa2,0x29,0x3b,0xae,0x38,0x48,
0x71,0x53,0xa4,0x0b,0x88,0x42,0xf8,0x06,0xe6,0x28,0x95,0xe2,
0x8a,0xa4,0xc7,0x76,0x85,0x5b,0xdc,0xf0,0xf9,0x8d,0x8d,0x27,
0x2c,0xe0,0xe1,0x4d,0x03,0xb1,0xc5,0x19,0xfe,0x57,0x57,0x8d,
0xb3,0x47,0x47,0x09,0xec,0x97,0xf3,0x3d,0xc1,0xa2,0x16,0x79,
0x0e,0xf7,0xea,0x54,0x15,0x70,0x19,0xa6,0x1e,0x07,0x34,0x04,
0xa4,0x3b,0xb7,0x6f,0xca,0x96,0x86,0x45,0xf2,0xd6,0x6c,0x8f,
0xe5,0x48,0xbf,0x1e,0xb6,0x52,0x70,0x2a,0x39,0xf9,0x04,0x00,
0x00,0xff,0xff,0x71,0xb1,0xcf,0x2d,0xce,0x00,0x00,0x00,
}))
if err != nil {
panic("Decompression failed: " + err.Error())
}
var b bytes.Buffer
io.Copy(&b, gz)
gz.Close()
return b.Bytes()
}
func error_html_mustache() []byte {
gz, err := gzip.NewReader(bytes.NewBuffer([]byte{
0x1f,0x8b,0x08,0x00,0x00,0x09,0x6e,0x88,0x00,0xff,0x54,0x51,
0xc1,0x6e,0xeb,0x20,0x10,0x3c,0xfb,0x7d,0x05,0xcf,0xbd,0xb4,
0x92,0x1d,0xdb,0x72,0xdd,0x83,0x43,0x23,0xf5,0xd6,0x4b,0xfb,
0x0f,0x1b,0xd8,0x60,0x54,0x0c,0x16,0x90,0x36,0x6e,0x94,0x7f,
0x2f,0x98,0xb4,0x49,0x64,0x09,0x34,0x33,0xec,0x7a,0x76,0x96,
0xfe,0xe7,0x86,0xf9,0x79,0x42,0x32,0xf8,0x51,0x6d,0xfe,0xd1,
0x74,0x65,0x74,0x40,0xe0,0xe1,0xce,0xa8,0x97,0x5e,0xe1,0xe6,
0x78,0x7c,0x43,0xe7,0x40,0xe0,0xe9,0x44,0xab,0x44,0x45,0xd1,
0xf9,0x59,0x21,0x89,0xf5,0xcf,0xb9,0xc7,0x83,0xaf,0x98,0x73,
0x79,0x54,0xb2,0xd8,0xa7,0x20,0x5b,0xc3,0x67,0x72,0x8c,0x38,
0xdb,0x02,0xfb,0x10,0xd6,0xec,0x35,0xef,0xc9,0x1d,0x22,0xae,
0x17,0x76,0x02,0xce,0xa5,0x16,0x3d,0xa9,0x13,0x1e,0xc1,0x0a,
0xa9,0x7f,0xe1,0x29,0x1e,0x57,0x3d,0x76,0x46,0xfb,0x72,0x07,
0xa3,0x54,0x73,0x4f,0xf2,0x57,0x54,0x9f,0xe8,0x25,0x03,0xf2,
0x8e,0x7b,0xcc,0x8b,0x17,0x2b,0x41,0x15,0x0e,0xb4,0x2b,0x1d,
0x5a,0xb9,0x4b,0x1d,0x99,0x51,0xc6,0x86,0x5f,0xb6,0xf0,0xd8,
0x76,0xed,0x2d,0xd7,0x75,0x5d,0x22,0xa2,0xf7,0xd2,0x0d,0xc0,
0xcd,0x57,0x5f,0x93,0x76,0x3a,0x90,0xa6,0x0e,0x87,0x15,0x5b,
0xb8,0xaf,0x8b,0xe5,0x5b,0xb5,0x0f,0x57,0x6f,0x41,0x49,0x11,
0x6c,0x32,0xd4,0x1e,0xed,0xc5,0xeb,0xd0,0x9c,0x9d,0x2a,0xf4,
0x41,0x28,0xdd,0x04,0x6c,0x19,0xaf,0xac,0x57,0x0d,0x8e,0xeb,
0xcb,0x14,0x4e,0x7e,0x63,0xdf,0x3d,0x4d,0x87,0xbf,0x62,0x5a,
0x2d,0x69,0xc6,0xf0,0xab,0x73,0xfa,0x34,0xce,0xbe,0x04,0x3d,
0x34,0xb7,0x2b,0x08,0x38,0xbe,0x4b,0x7a,0x80,0x71,0x6b,0x3f,
0x01,0x00,0x00,0xff,0xff,0x61,0xd4,0x4f,0xc1,0xcc,0x01,0x00,
0x00,
}))
if err != nil {
panic("Decompression failed: " + err.Error())
}
var b bytes.Buffer
io.Copy(&b, gz)
gz.Close()
return b.Bytes()
}
|
package live
import (
"github.com/gorilla/websocket"
)
func NewWebSocketClient(addr, id, host string) (*Client, error) {
wsConn, _, err := websocket.DefaultDialer.Dial(addr, nil)
if err != nil {
return nil, err
}
transport := NewWebSocketTransport(wsConn)
cli, err := NewClientWithTransport(transport, id, host)
return cli, err
}
|
package actions
import (
"github.com/mezis/klask/config"
"github.com/mezis/klask/index"
"net/http"
)
func OnIndicesCreate(res http.ResponseWriter, req *http.Request) {
defer failMessage(res)
resource, err := index.New("unnamed", config.Pool())
abortOn(err)
requestJson(req, &resource)
exists, err := resource.Exists()
abortOn(err)
if exists {
fail(http.StatusConflict, "already exists")
}
err = resource.Save()
abortOn(err)
respondJson(res, http.StatusCreated, resource)
}
|
package gcp
import "testing"
func TestGetNameFromURL(t *testing.T) {
var testCases = []struct {
item, url, expected string
}{
{
item: "zones",
url: "https://www.googleapis.com/compute/v1/projects/ci-op-lk2ifbjc/zones/us-central1-a",
expected: "us-central1-a",
},
{
item: "networks",
url: "https://www.googleapis.com/compute/v1/projects/ci-op-lk2ifbjc/global/networks/ci-op-lk2ifbjc-15937-q68kj-network",
expected: "ci-op-lk2ifbjc-15937-q68kj-network",
},
}
for _, testCase := range testCases {
t.Run(testCase.item, func(t *testing.T) {
if actual, expected := getNameFromURL(testCase.item, testCase.url), testCase.expected; actual != expected {
t.Errorf("got incorrect name %s for item %s from url %s", actual, testCase.item, testCase.url)
}
})
}
}
func TestGetRegionFromZone(t *testing.T) {
if actual, expected := getRegionFromZone("us-central1-a"), "us-central1"; actual != expected {
t.Errorf("got %s, not %s", actual, expected)
}
}
func TestGetDiskLimit(t *testing.T) {
var testCases = []struct {
url, expected string
}{
{
url: "https://www.googleapis.com/compute/v1/projects/ci-op-lk2ifbjc/zones/us-central1-a/diskTypes/pd-standard",
expected: "disks_total_storage",
},
{
url: "https://www.googleapis.com/compute/v1/projects/ci-op-lk2ifbjc/zones/us-central1-a/diskTypes/pd-ssd",
expected: "ssd_total_storage",
},
{
url: "https://www.googleapis.com/compute/v1/projects/ci-op-lk2ifbjc/zones/us-central1-a/diskTypes/pd-balanced",
expected: "ssd_total_storage",
},
}
for _, testCase := range testCases {
t.Run(testCase.url, func(t *testing.T) {
if actual, expected := getDiskLimit(testCase.url), testCase.expected; actual != expected {
t.Errorf("got incorrect limit %s for url %s", actual, testCase.url)
}
})
}
}
|
//
// Copyright (c) 2017, Stardog Union. <http://stardog.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 main
import (
"encoding/json"
"fmt"
"io/ioutil"
"math/rand"
"os"
"path"
"strings"
"testing"
"time"
"path/filepath"
"github.com/stardog-union/stardog-graviton/aws"
"github.com/stardog-union/stardog-graviton"
"errors"
)
var (
goodoutput1 = `{
"bastion_contact": {
"sensitive": false,
"type": "string",
"value": "bastion.sometest.com"
},
"stardog_contact": {
"sensitive": false,
"type": "string",
"value": "stardog.sometest.com"
},
"stardog_internal_contact": {
"sensitive": false,
"type": "string",
"value": "stardoginternal.sometest.com"
},
"zookeeper_nodes": {
"sensitive": false,
"type": "list",
"value": [
"zk0.sometest.com",
"zk1.sometest.com",
"zk2.sometest.com"
]
},
"volumes": { "sensitive": false, "type": "list", "value": ["vol-46313ce8", "vol-a34ba11c", "vol-50313cfe"]}
}`
packerFile = filepath.Join(os.TempDir(), "packer")
terraformFile = filepath.Join(os.TempDir(), "terraform")
)
func TestAbout(t *testing.T) {
dir, _ := ioutil.TempDir("", "stardogtests")
confDir := path.Join(dir, "a", "new", "dir")
defer os.RemoveAll(confDir)
rc := realMain([]string{"--config-dir", confDir, "about"})
if rc != 0 {
t.Fatal("About should return 0")
}
if !sdutils.PathExists(confDir) {
t.Fatalf("The conf dir should have been created %s", confDir)
}
}
func TestDeploymentList(t *testing.T) {
confDir, _ := ioutil.TempDir("", "stardogtests")
sshKeyFile := path.Join(confDir, "keyfile")
fakeOut := "xxx"
ioutil.WriteFile(sshKeyFile, []byte(fakeOut), 0600)
defer os.RemoveAll(confDir)
consoleLog := path.Join(confDir, "output0")
depname1 := randDeployName()
depname2 := randDeployName()
awsKeyID := os.Getenv("AWS_ACCESS_KEY_ID")
defer os.Setenv("AWS_ACCESS_KEY_ID", awsKeyID)
os.Setenv("AWS_ACCESS_KEY_ID", "gravitontest")
awsSecretKeyID := os.Getenv("AWS_SECRET_ACCESS_KEY")
defer os.Setenv("AWS_SECRET_ACCESS_KEY", awsSecretKeyID)
os.Setenv("AWS_SECRET_ACCESS_KEY", "somevalue")
rc := realMain([]string{"--quiet", "--config-dir", confDir, "--console-file", consoleLog, "deployment", "list"})
if rc != 0 {
t.Fatal("About should return 0")
}
b, err := ioutil.ReadFile(consoleLog)
if err != nil {
t.Fatal("the console log was not created")
}
if strings.TrimSpace(string(b)) != "" {
t.Fatal("There should have been no output")
}
err = buildImage("ami-beefwest", confDir, "4.2", "/etc/group", "us-west-1")
if err != nil {
t.Fatalf("Failed to make the ami %s", err)
}
rc = realMain([]string{"--quiet", "--config-dir", confDir, "deployment", "new", "--private-key", sshKeyFile, "--aws-key-name", "keyname", depname1, "4.2"})
if rc != 0 {
t.Fatal("dep new should return 0")
}
rc = realMain([]string{"--quiet", "--config-dir", confDir, "deployment", "new", "--private-key", sshKeyFile, "--aws-key-name", "keyname", depname2, "4.2"})
if rc != 0 {
t.Fatal("dep new should return 0")
}
rc = realMain([]string{"--quiet", "--config-dir", confDir, "--console-file", consoleLog, "deployment", "list"})
if rc != 0 {
t.Fatal("About should return 0")
}
b, err = ioutil.ReadFile(consoleLog)
if err != nil {
t.Fatal("the console log was not created")
}
output := string(b)
if !strings.Contains(output, depname1) {
t.Fatalf("The deployment %s was not listed", depname1)
}
if !strings.Contains(output, depname2) {
t.Fatalf("The deployment %s was not listed", depname2)
}
rc = realMain([]string{"--quiet", "--config-dir", confDir, "deployment", "destroy", "--force", depname1})
if rc != 0 {
t.Fatal("dep destroy should return 0")
}
rc = realMain([]string{"--quiet", "--config-dir", confDir, "deployment", "destroy", "--force", depname2})
if rc != 0 {
t.Fatal("dep destroy should return 0")
}
}
func TestStatusNoDeploy(t *testing.T) {
rc := realMain([]string{"--quiet", "status"})
if rc == 0 {
t.Fatal("Should have failed")
}
}
func buildImage(amiName string, confDir string, version string, releasefile string, region string) error {
startPath := os.Getenv("PATH")
defer os.Setenv("PATH", startPath)
data := fmt.Sprintf("amazon-ebs,artifact,0,string,AMIs were created:%s", amiName)
aws.MakeTestPacker(0, data, confDir)
rc := realMain([]string{"--quiet", "--config-dir", confDir, "baseami", "--region", region, releasefile, version})
if rc != 0 {
return errors.New("Build image failed")
}
return nil
}
func loadAmiFile(filepath string) (map[string]string, error) {
b, err := ioutil.ReadFile(filepath)
if err != nil {
return nil, err
}
m := make(map[string]string)
err = json.Unmarshal(b, &m)
if err != nil {
return nil, err
}
return m, nil
}
func TestBuildImageTop(t *testing.T) {
awsKeyID := os.Getenv("AWS_ACCESS_KEY_ID")
defer os.Setenv("AWS_ACCESS_KEY_ID", awsKeyID)
os.Setenv("AWS_ACCESS_KEY_ID", "gravitontest")
awsSecretKeyID := os.Getenv("AWS_SECRET_ACCESS_KEY")
defer os.Setenv("AWS_SECRET_ACCESS_KEY", awsSecretKeyID)
os.Setenv("AWS_SECRET_ACCESS_KEY", "somevalue")
confDir, _ := ioutil.TempDir("", "stardogtests")
defer os.RemoveAll(confDir)
err := buildImage("ami-nopexxxx", confDir, "4.2", "/etc/group", "us-west-1")
if err != nil {
t.Fatalf("Failed to make the ami %s", err)
}
err = buildImage("ami-beefeast", confDir, "4.2", "/etc/group", "us-east-1")
if err != nil {
t.Fatalf("Failed to make the ami %s", err)
}
err = buildImage("ami-beefwest", confDir, "4.2", "/etc/group", "us-west-1")
if err != nil {
t.Fatalf("Failed to make the ami %s", err)
}
err = buildImage("ami-43xxeast", confDir, "4.3", "/etc/group", "us-east-1")
if err != nil {
t.Fatalf("Failed to make the ami %s", err)
}
ami42Path := path.Join(confDir, "amis-4.2.json")
if !sdutils.PathExists(ami42Path) {
t.Fatalf("The 4.2 file doesn't exist %s", ami42Path)
}
m42, err := loadAmiFile(ami42Path)
if err != nil {
t.Fatalf("Failed to load the 4.2 ami info %s", err)
}
ent, ok := m42["us-west-1"]
if !ok {
t.Fatal("The expected region was not there")
}
if ent != "ami-beefwest" {
t.Fatal("The wrong ami was found")
}
ent, ok = m42["us-east-1"]
if !ok {
t.Fatal("The expected region was not there")
}
if ent != "ami-beefeast" {
t.Fatal("The wrong ami was found")
}
ami43Path := path.Join(confDir, "amis-4.3.json")
if !sdutils.PathExists(ami43Path) {
t.Fatalf("The 4.3 file doesn't exist %s", ami43Path)
}
m43, err := loadAmiFile(ami43Path)
if err != nil {
t.Fatalf("Failed to load the 4.3 ami info %s", err)
}
ent, ok = m43["us-east-1"]
if !ok {
t.Fatal("The expected region was not there")
}
if ent != "ami-43xxeast" {
t.Fatal("The wrong ami was found")
}
}
func TestBasicDeploy(t *testing.T) {
awsKeyID := os.Getenv("AWS_ACCESS_KEY_ID")
defer os.Setenv("AWS_ACCESS_KEY_ID", awsKeyID)
os.Setenv("AWS_ACCESS_KEY_ID", "gravitontest")
awsSecretKeyID := os.Getenv("AWS_SECRET_ACCESS_KEY")
defer os.Setenv("AWS_SECRET_ACCESS_KEY", awsSecretKeyID)
os.Setenv("AWS_SECRET_ACCESS_KEY", "somevalue")
confDir, _ := ioutil.TempDir("", "stardogtests")
defer os.RemoveAll(confDir)
sshKeyFile := path.Join(confDir, "keyfile")
fakeOut := "xxx"
ioutil.WriteFile(sshKeyFile, []byte(fakeOut), 0600)
region := "us-west-1"
err := buildImage("ami-deadbeef", confDir, "50.10", "/etc/group", region)
if err != nil {
t.Fatalf("Failed to make the ami %s", err)
}
startPath := os.Getenv("PATH")
defer os.Setenv("PATH", startPath)
exeDir, _, _ := aws.MakeTestTerraform(0, goodoutput1, "")
defer os.RemoveAll(exeDir)
os.Setenv("PATH", strings.Join([]string{exeDir, os.Getenv("PATH")}, ":"))
consoleLog := path.Join(confDir, "output2")
depName := randDeployName()
rc := realMain([]string{"--config-dir", confDir, "launch", "--no-wait",
"--region", region, "--aws-key-name", "keyname", "--private-key", sshKeyFile,
"--sd-version", "50.10", "--license", "/etc/group", depName})
if rc != 0 {
t.Fatal("launch failed")
}
rc = realMain([]string{"--config-dir", confDir, "status", depName})
if rc != 0 {
t.Fatal("status failed")
}
if !sdutils.PathExists(path.Join(confDir, "deployments", depName)) {
t.Fatal("The deployment directory should exist")
}
rc = realMain([]string{"--console-file", consoleLog, "--config-dir", confDir, "volume", "status", depName})
if rc != 0 {
t.Fatal("volume status failed")
}
b, err := ioutil.ReadFile(consoleLog)
if err != nil {
t.Fatal("the console log was not created")
}
vols := []string{"vol-46313ce8", "vol-a34ba11c", "vol-50313cfe"}
output1 := string(b)
for _, vol := range vols {
if !strings.Contains(output1, vol) {
t.Fatalf("The volume %s should have been found", vol)
}
}
rc = realMain([]string{"--console-file", consoleLog, "--config-dir", confDir, "instance", "status", depName})
if rc != 0 {
t.Fatal("instance status failed")
}
b, err = ioutil.ReadFile(consoleLog)
if err != nil {
t.Fatal("the console log was not created")
}
instances := []string{"stardog.sometest.com", "bastion.sometest.com"}
output1 = string(b)
for _, inst := range instances {
if !strings.Contains(output1, inst) {
t.Fatalf("The instance %s should have been found", inst)
}
}
rc = realMain([]string{"--config-dir", confDir, "destroy", "--force", depName})
if rc != 0 {
t.Fatal("status failed")
}
if sdutils.PathExists(path.Join(confDir, "deployments", depName)) {
t.Fatal("The deployment directory should not exist")
}
}
func TestSteppedOutDeploy(t *testing.T) {
awsKeyID := os.Getenv("AWS_ACCESS_KEY_ID")
defer os.Setenv("AWS_ACCESS_KEY_ID", awsKeyID)
os.Setenv("AWS_ACCESS_KEY_ID", "gravitontest")
awsSecretKeyID := os.Getenv("AWS_SECRET_ACCESS_KEY")
defer os.Setenv("AWS_SECRET_ACCESS_KEY", awsSecretKeyID)
os.Setenv("AWS_SECRET_ACCESS_KEY", "somevalue")
confDir, _ := ioutil.TempDir("", "stardogtests")
defer os.RemoveAll(confDir)
sshKeyFile := path.Join(confDir, "keyfile")
fakeOut := "xxx"
ioutil.WriteFile(sshKeyFile, []byte(fakeOut), 0600)
region := "us-west-1"
err := buildImage("ami-deadbeef", confDir, "4.2", "/etc/group", region)
if err != nil {
t.Fatalf("Failed to make the ami %s", err)
}
startPath := os.Getenv("PATH")
defer os.Setenv("PATH", startPath)
exeDir, _, _ := aws.MakeTestTerraform(0, goodoutput1, "")
defer os.RemoveAll(exeDir)
sshExeDir, _, _ := aws.MakeTestSSH(0)
defer os.RemoveAll(sshExeDir)
os.Setenv("PATH", strings.Join([]string{exeDir, os.Getenv("PATH")}, ":"))
depName := randDeployName()
rc := realMain([]string{"--config-dir", confDir, "deployment", "new", "--private-key", sshKeyFile, "--aws-key-name", "keyname", "--region", region, depName, "4.2"})
if rc != 0 {
t.Fatal("depl new failed")
}
rc = realMain([]string{"--config-dir", confDir, "volume", "new", depName, "/etc/group", "1", "1"})
if rc != 0 {
t.Fatal("status failed")
}
if !sdutils.PathExists(path.Join(confDir, "deployments", depName)) {
t.Fatal("The deployment directory should exist")
}
os.Setenv("STARDOG_GRAVITON_HEALTHY", "false")
rc = realMain([]string{"--config-dir", confDir, "instance", "new", "--wait-timeout", "2", depName, "1"})
os.Unsetenv("STARDOG_GRAVITON_HEALTHY")
if rc == 0 {
t.Fatal("instance start should have failed with timeout")
}
rc = realMain([]string{"--config-dir", confDir, "instance", "status", depName})
if rc != 0 {
t.Fatal("instance status failed")
}
rc = realMain([]string{"--config-dir", confDir, "instance", "destroy", "--force", depName})
if rc != 0 {
t.Fatal("Should be able to destroy the instance")
}
rc = realMain([]string{"--config-dir", confDir, "volume", "destroy", "--force", depName})
if rc != 0 {
t.Fatal("Should be able to destroy the volume")
}
rc = realMain([]string{"--config-dir", confDir, "deployment", "destroy", "--force", depName})
if rc != 0 {
t.Fatal("Should be able to destroy the deployment")
}
if sdutils.PathExists(path.Join(confDir, "deployments", depName)) {
t.Fatal("The deployment directory should not exist")
}
}
func TestDestroyNoExist(t *testing.T) {
confDir, _ := ioutil.TempDir("", "stardogtests")
defer os.RemoveAll(confDir)
depName := randDeployName()
rc := realMain([]string{"--config-dir", confDir, "deployment", "destroy", "--force", depName})
if rc == 0 {
t.Fatal("Should fail when deleting a non existing deployment")
}
rc = realMain([]string{"--config-dir", confDir, "volume", "destroy", "--force", depName})
if rc == 0 {
t.Fatal("Should fail when deleting a non existing volume")
}
rc = realMain([]string{"--config-dir", confDir, "instance", "destroy", "--force", depName})
if rc == 0 {
t.Fatal("Should fail when deleting a non existing instance")
}
rc = realMain([]string{"--config-dir", confDir, "instance", "status", depName})
if rc == 0 {
t.Fatal("Should fail when status a non existing instance")
}
rc = realMain([]string{"--config-dir", confDir, "volume", "status", depName})
if rc == 0 {
t.Fatal("Should fail when status a non existing instance")
}
rc = realMain([]string{"--config-dir", confDir, "volume", "new", depName, "/etc/group", "/etc/group", "1", "1"})
if rc == 0 {
t.Fatal("Should fail when deleting a non existing volume")
}
rc = realMain([]string{"--config-dir", confDir, "instance", "new", depName, "1"})
if rc == 0 {
t.Fatal("Should fail when deleting a non existing instance")
}
rc = realMain([]string{"--config-dir", confDir, "client", depName, "hostname"})
if rc == 0 {
t.Fatal("client command should have failed")
}
}
func init() {
rand.Seed(time.Now().UnixNano())
os.Setenv("STARDOG_GRAVITON_UNIT_TEST", "on")
dir, err := ioutil.TempDir("", "stardogtest")
if err != nil {
panic("failed to make a temp dir")
}
_, _, err = aws.MakeTestPacker(0, "amazon-ebs,artifact,0,string,AMIs were created:ami-deadbeef", dir)
if err != nil {
panic("failed to make fake packer")
}
_, _, err = aws.MakeTestTerraform(0, "terraform data", dir)
if err != nil {
panic("failed to make fake terraform")
}
// We need to trick the tests into thinking packer and terraform exists for stubs
os.Setenv("PATH", strings.Join([]string{dir, os.Getenv("PATH")}, ":"))
}
var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
func randDeployName() string {
b := make([]rune, 10)
for i := range b {
b[i] = letterRunes[rand.Intn(len(letterRunes))]
}
return string(b)
}
func TestCleanup(t *testing.T) {
os.Remove(packerFile)
os.Remove(terraformFile)
}
|
// Copyright 2023 Google LLC. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package identitytoolkit
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io/ioutil"
"strings"
"github.com/GoogleCloudPlatform/declarative-resource-client-library/dcl"
)
func (r *Tenant) validate() error {
if err := dcl.RequiredParameter(r.Project, "Project"); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.MfaConfig) {
if err := r.MfaConfig.validate(); err != nil {
return err
}
}
return nil
}
func (r *TenantMfaConfig) validate() error {
return nil
}
func (r *Tenant) basePath() string {
params := map[string]interface{}{}
return dcl.Nprintf("https://identitytoolkit.googleapis.com/v2", params)
}
func (r *Tenant) getURL(userBasePath string) (string, error) {
nr := r.urlNormalized()
params := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
"name": dcl.ValueOrEmptyString(nr.Name),
}
return dcl.URL("projects/{{project}}/tenants/{{name}}", nr.basePath(), userBasePath, params), nil
}
func (r *Tenant) listURL(userBasePath string) (string, error) {
nr := r.urlNormalized()
params := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
}
return dcl.URL("projects/{{project}}/tenants", nr.basePath(), userBasePath, params), nil
}
func (r *Tenant) createURL(userBasePath string) (string, error) {
nr := r.urlNormalized()
params := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
}
return dcl.URL("projects/{{project}}/tenants", nr.basePath(), userBasePath, params), nil
}
func (r *Tenant) deleteURL(userBasePath string) (string, error) {
nr := r.urlNormalized()
params := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
"name": dcl.ValueOrEmptyString(nr.Name),
}
return dcl.URL("projects/{{project}}/tenants/{{name}}", nr.basePath(), userBasePath, params), nil
}
// tenantApiOperation represents a mutable operation in the underlying REST
// API such as Create, Update, or Delete.
type tenantApiOperation interface {
do(context.Context, *Tenant, *Client) error
}
// newUpdateTenantUpdateTenantRequest creates a request for an
// Tenant resource's UpdateTenant update type by filling in the update
// fields based on the intended state of the resource.
func newUpdateTenantUpdateTenantRequest(ctx context.Context, f *Tenant, c *Client) (map[string]interface{}, error) {
req := map[string]interface{}{}
res := f
_ = res
if v := f.DisplayName; !dcl.IsEmptyValueIndirect(v) {
req["displayName"] = v
}
if v := f.AllowPasswordSignup; !dcl.IsEmptyValueIndirect(v) {
req["allowPasswordSignup"] = v
}
if v := f.EnableEmailLinkSignin; !dcl.IsEmptyValueIndirect(v) {
req["enableEmailLinkSignin"] = v
}
if v := f.DisableAuth; !dcl.IsEmptyValueIndirect(v) {
req["disableAuth"] = v
}
if v := f.EnableAnonymousUser; !dcl.IsEmptyValueIndirect(v) {
req["enableAnonymousUser"] = v
}
if v, err := expandTenantMfaConfig(c, f.MfaConfig, res); err != nil {
return nil, fmt.Errorf("error expanding MfaConfig into mfaConfig: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
req["mfaConfig"] = v
}
if v := f.TestPhoneNumbers; !dcl.IsEmptyValueIndirect(v) {
req["testPhoneNumbers"] = v
}
return req, nil
}
// marshalUpdateTenantUpdateTenantRequest converts the update into
// the final JSON request body.
func marshalUpdateTenantUpdateTenantRequest(c *Client, m map[string]interface{}) ([]byte, error) {
return json.Marshal(m)
}
type updateTenantUpdateTenantOperation struct {
// If the update operation has the REQUIRES_APPLY_OPTIONS trait, this will be populated.
// Usually it will be nil - this is to prevent us from accidentally depending on apply
// options, which should usually be unnecessary.
ApplyOptions []dcl.ApplyOption
FieldDiffs []*dcl.FieldDiff
}
// do creates a request and sends it to the appropriate URL. In most operations,
// do will transcribe a subset of the resource into a request object and send a
// PUT request to a single URL.
func (op *updateTenantUpdateTenantOperation) do(ctx context.Context, r *Tenant, c *Client) error {
_, err := c.GetTenant(ctx, r)
if err != nil {
return err
}
u, err := r.updateURL(c.Config.BasePath, "UpdateTenant")
if err != nil {
return err
}
req, err := newUpdateTenantUpdateTenantRequest(ctx, r, c)
if err != nil {
return err
}
c.Config.Logger.InfoWithContextf(ctx, "Created update: %#v", req)
body, err := marshalUpdateTenantUpdateTenantRequest(c, req)
if err != nil {
return err
}
_, err = dcl.SendRequest(ctx, c.Config, "PATCH", u, bytes.NewBuffer(body), c.Config.RetryProvider)
if err != nil {
return err
}
return nil
}
func (c *Client) listTenantRaw(ctx context.Context, r *Tenant, pageToken string, pageSize int32) ([]byte, error) {
u, err := r.urlNormalized().listURL(c.Config.BasePath)
if err != nil {
return nil, err
}
m := make(map[string]string)
if pageToken != "" {
m["pageToken"] = pageToken
}
if pageSize != TenantMaxPage {
m["pageSize"] = fmt.Sprintf("%v", pageSize)
}
u, err = dcl.AddQueryParams(u, m)
if err != nil {
return nil, err
}
resp, err := dcl.SendRequest(ctx, c.Config, "GET", u, &bytes.Buffer{}, c.Config.RetryProvider)
if err != nil {
return nil, err
}
defer resp.Response.Body.Close()
return ioutil.ReadAll(resp.Response.Body)
}
type listTenantOperation struct {
Tenants []map[string]interface{} `json:"tenants"`
Token string `json:"nextPageToken"`
}
func (c *Client) listTenant(ctx context.Context, r *Tenant, pageToken string, pageSize int32) ([]*Tenant, string, error) {
b, err := c.listTenantRaw(ctx, r, pageToken, pageSize)
if err != nil {
return nil, "", err
}
var m listTenantOperation
if err := json.Unmarshal(b, &m); err != nil {
return nil, "", err
}
var l []*Tenant
for _, v := range m.Tenants {
res, err := unmarshalMapTenant(v, c, r)
if err != nil {
return nil, m.Token, err
}
res.Project = r.Project
l = append(l, res)
}
return l, m.Token, nil
}
func (c *Client) deleteAllTenant(ctx context.Context, f func(*Tenant) bool, resources []*Tenant) error {
var errors []string
for _, res := range resources {
if f(res) {
// We do not want deleteAll to fail on a deletion or else it will stop deleting other resources.
err := c.DeleteTenant(ctx, res)
if err != nil {
errors = append(errors, err.Error())
}
}
}
if len(errors) > 0 {
return fmt.Errorf("%v", strings.Join(errors, "\n"))
} else {
return nil
}
}
type deleteTenantOperation struct{}
func (op *deleteTenantOperation) do(ctx context.Context, r *Tenant, c *Client) error {
r, err := c.GetTenant(ctx, r)
if err != nil {
if dcl.IsNotFound(err) {
c.Config.Logger.InfoWithContextf(ctx, "Tenant not found, returning. Original error: %v", err)
return nil
}
c.Config.Logger.WarningWithContextf(ctx, "GetTenant checking for existence. error: %v", err)
return err
}
u, err := r.deleteURL(c.Config.BasePath)
if err != nil {
return err
}
// Delete should never have a body
body := &bytes.Buffer{}
_, err = dcl.SendRequest(ctx, c.Config, "DELETE", u, body, c.Config.RetryProvider)
if err != nil {
return fmt.Errorf("failed to delete Tenant: %w", err)
}
// We saw a race condition where for some successful delete operation, the Get calls returned resources for a short duration.
// This is the reason we are adding retry to handle that case.
retriesRemaining := 10
dcl.Do(ctx, func(ctx context.Context) (*dcl.RetryDetails, error) {
_, err := c.GetTenant(ctx, r)
if dcl.IsNotFound(err) {
return nil, nil
}
if retriesRemaining > 0 {
retriesRemaining--
return &dcl.RetryDetails{}, dcl.OperationNotDone{}
}
return nil, dcl.NotDeletedError{ExistingResource: r}
}, c.Config.RetryProvider)
return nil
}
// Create operations are similar to Update operations, although they do not have
// specific request objects. The Create request object is the json encoding of
// the resource, which is modified by res.marshal to form the base request body.
type createTenantOperation struct {
response map[string]interface{}
}
func (op *createTenantOperation) FirstResponse() (map[string]interface{}, bool) {
return op.response, len(op.response) > 0
}
func (op *createTenantOperation) do(ctx context.Context, r *Tenant, c *Client) error {
c.Config.Logger.InfoWithContextf(ctx, "Attempting to create %v", r)
u, err := r.createURL(c.Config.BasePath)
if err != nil {
return err
}
req, err := r.marshal(c)
if err != nil {
return err
}
if r.Name != nil {
// Allowing creation to continue with Name set could result in a Tenant with the wrong Name.
return fmt.Errorf("server-generated parameter Name was specified by user as %v, should be unspecified", dcl.ValueOrEmptyString(r.Name))
}
resp, err := dcl.SendRequest(ctx, c.Config, "POST", u, bytes.NewBuffer(req), c.Config.RetryProvider)
if err != nil {
return err
}
o, err := dcl.ResponseBodyAsJSON(resp)
if err != nil {
return fmt.Errorf("error decoding response body into JSON: %w", err)
}
op.response = o
// Include Name in URL substitution for initial GET request.
m := op.response
r.Name = dcl.SelfLinkToName(dcl.FlattenString(m["name"]))
if _, err := c.GetTenant(ctx, r); err != nil {
c.Config.Logger.WarningWithContextf(ctx, "get returned error: %v", err)
return err
}
return nil
}
func (c *Client) getTenantRaw(ctx context.Context, r *Tenant) ([]byte, error) {
u, err := r.getURL(c.Config.BasePath)
if err != nil {
return nil, err
}
resp, err := dcl.SendRequest(ctx, c.Config, "GET", u, &bytes.Buffer{}, c.Config.RetryProvider)
if err != nil {
return nil, err
}
defer resp.Response.Body.Close()
b, err := ioutil.ReadAll(resp.Response.Body)
if err != nil {
return nil, err
}
return b, nil
}
func (c *Client) tenantDiffsForRawDesired(ctx context.Context, rawDesired *Tenant, opts ...dcl.ApplyOption) (initial, desired *Tenant, diffs []*dcl.FieldDiff, err error) {
c.Config.Logger.InfoWithContext(ctx, "Fetching initial state...")
// First, let us see if the user provided a state hint. If they did, we will start fetching based on that.
var fetchState *Tenant
if sh := dcl.FetchStateHint(opts); sh != nil {
if r, ok := sh.(*Tenant); !ok {
c.Config.Logger.WarningWithContextf(ctx, "Initial state hint was of the wrong type; expected Tenant, got %T", sh)
} else {
fetchState = r
}
}
if fetchState == nil {
fetchState = rawDesired
}
if fetchState.Name == nil {
// We cannot perform a get because of lack of information. We have to assume
// that this is being created for the first time.
desired, err := canonicalizeTenantDesiredState(rawDesired, nil)
return nil, desired, nil, err
}
// 1.2: Retrieval of raw initial state from API
rawInitial, err := c.GetTenant(ctx, fetchState)
if rawInitial == nil {
if !dcl.IsNotFound(err) {
c.Config.Logger.WarningWithContextf(ctx, "Failed to retrieve whether a Tenant resource already exists: %s", err)
return nil, nil, nil, fmt.Errorf("failed to retrieve Tenant resource: %v", err)
}
c.Config.Logger.InfoWithContext(ctx, "Found that Tenant resource did not exist.")
// Perform canonicalization to pick up defaults.
desired, err = canonicalizeTenantDesiredState(rawDesired, rawInitial)
return nil, desired, nil, err
}
c.Config.Logger.InfoWithContextf(ctx, "Found initial state for Tenant: %v", rawInitial)
c.Config.Logger.InfoWithContextf(ctx, "Initial desired state for Tenant: %v", rawDesired)
// The Get call applies postReadExtract and so the result may contain fields that are not part of API version.
if err := extractTenantFields(rawInitial); err != nil {
return nil, nil, nil, err
}
// 1.3: Canonicalize raw initial state into initial state.
initial, err = canonicalizeTenantInitialState(rawInitial, rawDesired)
if err != nil {
return nil, nil, nil, err
}
c.Config.Logger.InfoWithContextf(ctx, "Canonicalized initial state for Tenant: %v", initial)
// 1.4: Canonicalize raw desired state into desired state.
desired, err = canonicalizeTenantDesiredState(rawDesired, rawInitial, opts...)
if err != nil {
return nil, nil, nil, err
}
c.Config.Logger.InfoWithContextf(ctx, "Canonicalized desired state for Tenant: %v", desired)
// 2.1: Comparison of initial and desired state.
diffs, err = diffTenant(c, desired, initial, opts...)
return initial, desired, diffs, err
}
func canonicalizeTenantInitialState(rawInitial, rawDesired *Tenant) (*Tenant, error) {
// TODO(magic-modules-eng): write canonicalizer once relevant traits are added.
return rawInitial, nil
}
/*
* Canonicalizers
*
* These are responsible for converting either a user-specified config or a
* GCP API response to a standard format that can be used for difference checking.
* */
func canonicalizeTenantDesiredState(rawDesired, rawInitial *Tenant, opts ...dcl.ApplyOption) (*Tenant, error) {
if rawInitial == nil {
// Since the initial state is empty, the desired state is all we have.
// We canonicalize the remaining nested objects with nil to pick up defaults.
rawDesired.MfaConfig = canonicalizeTenantMfaConfig(rawDesired.MfaConfig, nil, opts...)
return rawDesired, nil
}
canonicalDesired := &Tenant{}
if dcl.IsZeroValue(rawDesired.Name) || (dcl.IsEmptyValueIndirect(rawDesired.Name) && dcl.IsEmptyValueIndirect(rawInitial.Name)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
canonicalDesired.Name = rawInitial.Name
} else {
canonicalDesired.Name = rawDesired.Name
}
if dcl.StringCanonicalize(rawDesired.DisplayName, rawInitial.DisplayName) {
canonicalDesired.DisplayName = rawInitial.DisplayName
} else {
canonicalDesired.DisplayName = rawDesired.DisplayName
}
if dcl.BoolCanonicalize(rawDesired.AllowPasswordSignup, rawInitial.AllowPasswordSignup) {
canonicalDesired.AllowPasswordSignup = rawInitial.AllowPasswordSignup
} else {
canonicalDesired.AllowPasswordSignup = rawDesired.AllowPasswordSignup
}
if dcl.BoolCanonicalize(rawDesired.EnableEmailLinkSignin, rawInitial.EnableEmailLinkSignin) {
canonicalDesired.EnableEmailLinkSignin = rawInitial.EnableEmailLinkSignin
} else {
canonicalDesired.EnableEmailLinkSignin = rawDesired.EnableEmailLinkSignin
}
if dcl.BoolCanonicalize(rawDesired.DisableAuth, rawInitial.DisableAuth) {
canonicalDesired.DisableAuth = rawInitial.DisableAuth
} else {
canonicalDesired.DisableAuth = rawDesired.DisableAuth
}
if dcl.BoolCanonicalize(rawDesired.EnableAnonymousUser, rawInitial.EnableAnonymousUser) {
canonicalDesired.EnableAnonymousUser = rawInitial.EnableAnonymousUser
} else {
canonicalDesired.EnableAnonymousUser = rawDesired.EnableAnonymousUser
}
canonicalDesired.MfaConfig = canonicalizeTenantMfaConfig(rawDesired.MfaConfig, rawInitial.MfaConfig, opts...)
if dcl.IsZeroValue(rawDesired.TestPhoneNumbers) || (dcl.IsEmptyValueIndirect(rawDesired.TestPhoneNumbers) && dcl.IsEmptyValueIndirect(rawInitial.TestPhoneNumbers)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
canonicalDesired.TestPhoneNumbers = rawInitial.TestPhoneNumbers
} else {
canonicalDesired.TestPhoneNumbers = rawDesired.TestPhoneNumbers
}
if dcl.NameToSelfLink(rawDesired.Project, rawInitial.Project) {
canonicalDesired.Project = rawInitial.Project
} else {
canonicalDesired.Project = rawDesired.Project
}
return canonicalDesired, nil
}
func canonicalizeTenantNewState(c *Client, rawNew, rawDesired *Tenant) (*Tenant, error) {
if dcl.IsEmptyValueIndirect(rawNew.Name) && dcl.IsEmptyValueIndirect(rawDesired.Name) {
rawNew.Name = rawDesired.Name
} else {
}
if dcl.IsEmptyValueIndirect(rawNew.DisplayName) && dcl.IsEmptyValueIndirect(rawDesired.DisplayName) {
rawNew.DisplayName = rawDesired.DisplayName
} else {
if dcl.StringCanonicalize(rawDesired.DisplayName, rawNew.DisplayName) {
rawNew.DisplayName = rawDesired.DisplayName
}
}
if dcl.IsEmptyValueIndirect(rawNew.AllowPasswordSignup) && dcl.IsEmptyValueIndirect(rawDesired.AllowPasswordSignup) {
rawNew.AllowPasswordSignup = rawDesired.AllowPasswordSignup
} else {
if dcl.BoolCanonicalize(rawDesired.AllowPasswordSignup, rawNew.AllowPasswordSignup) {
rawNew.AllowPasswordSignup = rawDesired.AllowPasswordSignup
}
}
if dcl.IsEmptyValueIndirect(rawNew.EnableEmailLinkSignin) && dcl.IsEmptyValueIndirect(rawDesired.EnableEmailLinkSignin) {
rawNew.EnableEmailLinkSignin = rawDesired.EnableEmailLinkSignin
} else {
if dcl.BoolCanonicalize(rawDesired.EnableEmailLinkSignin, rawNew.EnableEmailLinkSignin) {
rawNew.EnableEmailLinkSignin = rawDesired.EnableEmailLinkSignin
}
}
if dcl.IsEmptyValueIndirect(rawNew.DisableAuth) && dcl.IsEmptyValueIndirect(rawDesired.DisableAuth) {
rawNew.DisableAuth = rawDesired.DisableAuth
} else {
if dcl.BoolCanonicalize(rawDesired.DisableAuth, rawNew.DisableAuth) {
rawNew.DisableAuth = rawDesired.DisableAuth
}
}
if dcl.IsEmptyValueIndirect(rawNew.EnableAnonymousUser) && dcl.IsEmptyValueIndirect(rawDesired.EnableAnonymousUser) {
rawNew.EnableAnonymousUser = rawDesired.EnableAnonymousUser
} else {
if dcl.BoolCanonicalize(rawDesired.EnableAnonymousUser, rawNew.EnableAnonymousUser) {
rawNew.EnableAnonymousUser = rawDesired.EnableAnonymousUser
}
}
if dcl.IsEmptyValueIndirect(rawNew.MfaConfig) && dcl.IsEmptyValueIndirect(rawDesired.MfaConfig) {
rawNew.MfaConfig = rawDesired.MfaConfig
} else {
rawNew.MfaConfig = canonicalizeNewTenantMfaConfig(c, rawDesired.MfaConfig, rawNew.MfaConfig)
}
if dcl.IsEmptyValueIndirect(rawNew.TestPhoneNumbers) && dcl.IsEmptyValueIndirect(rawDesired.TestPhoneNumbers) {
rawNew.TestPhoneNumbers = rawDesired.TestPhoneNumbers
} else {
}
rawNew.Project = rawDesired.Project
return rawNew, nil
}
func canonicalizeTenantMfaConfig(des, initial *TenantMfaConfig, opts ...dcl.ApplyOption) *TenantMfaConfig {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &TenantMfaConfig{}
if dcl.IsZeroValue(des.State) || (dcl.IsEmptyValueIndirect(des.State) && dcl.IsEmptyValueIndirect(initial.State)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.State = initial.State
} else {
cDes.State = des.State
}
if dcl.IsZeroValue(des.EnabledProviders) || (dcl.IsEmptyValueIndirect(des.EnabledProviders) && dcl.IsEmptyValueIndirect(initial.EnabledProviders)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.EnabledProviders = initial.EnabledProviders
} else {
cDes.EnabledProviders = des.EnabledProviders
}
return cDes
}
func canonicalizeTenantMfaConfigSlice(des, initial []TenantMfaConfig, opts ...dcl.ApplyOption) []TenantMfaConfig {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]TenantMfaConfig, 0, len(des))
for _, d := range des {
cd := canonicalizeTenantMfaConfig(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]TenantMfaConfig, 0, len(des))
for i, d := range des {
cd := canonicalizeTenantMfaConfig(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewTenantMfaConfig(c *Client, des, nw *TenantMfaConfig) *TenantMfaConfig {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for TenantMfaConfig while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
return nw
}
func canonicalizeNewTenantMfaConfigSet(c *Client, des, nw []TenantMfaConfig) []TenantMfaConfig {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []TenantMfaConfig
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareTenantMfaConfigNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewTenantMfaConfig(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewTenantMfaConfigSlice(c *Client, des, nw []TenantMfaConfig) []TenantMfaConfig {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []TenantMfaConfig
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewTenantMfaConfig(c, &d, &n))
}
return items
}
// The differ returns a list of diffs, along with a list of operations that should be taken
// to remedy them. Right now, it does not attempt to consolidate operations - if several
// fields can be fixed with a patch update, it will perform the patch several times.
// Diffs on some fields will be ignored if the `desired` state has an empty (nil)
// value. This empty value indicates that the user does not care about the state for
// the field. Empty fields on the actual object will cause diffs.
// TODO(magic-modules-eng): for efficiency in some resources, add batching.
func diffTenant(c *Client, desired, actual *Tenant, opts ...dcl.ApplyOption) ([]*dcl.FieldDiff, error) {
if desired == nil || actual == nil {
return nil, fmt.Errorf("nil resource passed to diff - always a programming error: %#v, %#v", desired, actual)
}
c.Config.Logger.Infof("Diff function called with desired state: %v", desired)
c.Config.Logger.Infof("Diff function called with actual state: %v", actual)
var fn dcl.FieldName
var newDiffs []*dcl.FieldDiff
// New style diffs.
if ds, err := dcl.Diff(desired.Name, actual.Name, dcl.DiffInfo{Type: "ReferenceType", OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Name")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.DisplayName, actual.DisplayName, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateTenantUpdateTenantOperation")}, fn.AddNest("DisplayName")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.AllowPasswordSignup, actual.AllowPasswordSignup, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateTenantUpdateTenantOperation")}, fn.AddNest("AllowPasswordSignup")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.EnableEmailLinkSignin, actual.EnableEmailLinkSignin, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateTenantUpdateTenantOperation")}, fn.AddNest("EnableEmailLinkSignin")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.DisableAuth, actual.DisableAuth, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateTenantUpdateTenantOperation")}, fn.AddNest("DisableAuth")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.EnableAnonymousUser, actual.EnableAnonymousUser, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateTenantUpdateTenantOperation")}, fn.AddNest("EnableAnonymousUser")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.MfaConfig, actual.MfaConfig, dcl.DiffInfo{ObjectFunction: compareTenantMfaConfigNewStyle, EmptyObject: EmptyTenantMfaConfig, OperationSelector: dcl.TriggersOperation("updateTenantUpdateTenantOperation")}, fn.AddNest("MfaConfig")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.TestPhoneNumbers, actual.TestPhoneNumbers, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateTenantUpdateTenantOperation")}, fn.AddNest("TestPhoneNumbers")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Project, actual.Project, dcl.DiffInfo{Type: "ReferenceType", OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Project")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if len(newDiffs) > 0 {
c.Config.Logger.Infof("Diff function found diffs: %v", newDiffs)
}
return newDiffs, nil
}
func compareTenantMfaConfigNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*TenantMfaConfig)
if !ok {
desiredNotPointer, ok := d.(TenantMfaConfig)
if !ok {
return nil, fmt.Errorf("obj %v is not a TenantMfaConfig or *TenantMfaConfig", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*TenantMfaConfig)
if !ok {
actualNotPointer, ok := a.(TenantMfaConfig)
if !ok {
return nil, fmt.Errorf("obj %v is not a TenantMfaConfig", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.State, actual.State, dcl.DiffInfo{Type: "EnumType", OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("State")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.EnabledProviders, actual.EnabledProviders, dcl.DiffInfo{Type: "EnumType", OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("EnabledProviders")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
// urlNormalized returns a copy of the resource struct with values normalized
// for URL substitutions. For instance, it converts long-form self-links to
// short-form so they can be substituted in.
func (r *Tenant) urlNormalized() *Tenant {
normalized := dcl.Copy(*r).(Tenant)
normalized.Name = dcl.SelfLinkToName(r.Name)
normalized.DisplayName = dcl.SelfLinkToName(r.DisplayName)
normalized.Project = dcl.SelfLinkToName(r.Project)
return &normalized
}
func (r *Tenant) updateURL(userBasePath, updateName string) (string, error) {
nr := r.urlNormalized()
if updateName == "UpdateTenant" {
fields := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
"name": dcl.ValueOrEmptyString(nr.Name),
}
return dcl.URL("projects/{{project}}/tenants/{{name}}", nr.basePath(), userBasePath, fields), nil
}
return "", fmt.Errorf("unknown update name: %s", updateName)
}
// marshal encodes the Tenant resource into JSON for a Create request, and
// performs transformations from the resource schema to the API schema if
// necessary.
func (r *Tenant) marshal(c *Client) ([]byte, error) {
m, err := expandTenant(c, r)
if err != nil {
return nil, fmt.Errorf("error marshalling Tenant: %w", err)
}
return json.Marshal(m)
}
// unmarshalTenant decodes JSON responses into the Tenant resource schema.
func unmarshalTenant(b []byte, c *Client, res *Tenant) (*Tenant, error) {
var m map[string]interface{}
if err := json.Unmarshal(b, &m); err != nil {
return nil, err
}
return unmarshalMapTenant(m, c, res)
}
func unmarshalMapTenant(m map[string]interface{}, c *Client, res *Tenant) (*Tenant, error) {
flattened := flattenTenant(c, m, res)
if flattened == nil {
return nil, fmt.Errorf("attempted to flatten empty json object")
}
return flattened, nil
}
// expandTenant expands Tenant into a JSON request object.
func expandTenant(c *Client, f *Tenant) (map[string]interface{}, error) {
m := make(map[string]interface{})
res := f
_ = res
if v, err := dcl.DeriveField("projects/%s/tenants/%s", f.Name, dcl.SelfLinkToName(f.Project), dcl.SelfLinkToName(f.Name)); err != nil {
return nil, fmt.Errorf("error expanding Name into name: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["name"] = v
}
if v := f.DisplayName; dcl.ValueShouldBeSent(v) {
m["displayName"] = v
}
if v := f.AllowPasswordSignup; dcl.ValueShouldBeSent(v) {
m["allowPasswordSignup"] = v
}
if v := f.EnableEmailLinkSignin; dcl.ValueShouldBeSent(v) {
m["enableEmailLinkSignin"] = v
}
if v := f.DisableAuth; dcl.ValueShouldBeSent(v) {
m["disableAuth"] = v
}
if v := f.EnableAnonymousUser; dcl.ValueShouldBeSent(v) {
m["enableAnonymousUser"] = v
}
if v, err := expandTenantMfaConfig(c, f.MfaConfig, res); err != nil {
return nil, fmt.Errorf("error expanding MfaConfig into mfaConfig: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["mfaConfig"] = v
}
if v := f.TestPhoneNumbers; dcl.ValueShouldBeSent(v) {
m["testPhoneNumbers"] = v
}
if v, err := dcl.EmptyValue(); err != nil {
return nil, fmt.Errorf("error expanding Project into project: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["project"] = v
}
return m, nil
}
// flattenTenant flattens Tenant from a JSON request object into the
// Tenant type.
func flattenTenant(c *Client, i interface{}, res *Tenant) *Tenant {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
if len(m) == 0 {
return nil
}
resultRes := &Tenant{}
resultRes.Name = dcl.SelfLinkToName(dcl.FlattenString(m["name"]))
resultRes.DisplayName = dcl.FlattenString(m["displayName"])
resultRes.AllowPasswordSignup = dcl.FlattenBool(m["allowPasswordSignup"])
resultRes.EnableEmailLinkSignin = dcl.FlattenBool(m["enableEmailLinkSignin"])
resultRes.DisableAuth = dcl.FlattenBool(m["disableAuth"])
resultRes.EnableAnonymousUser = dcl.FlattenBool(m["enableAnonymousUser"])
resultRes.MfaConfig = flattenTenantMfaConfig(c, m["mfaConfig"], res)
resultRes.TestPhoneNumbers = dcl.FlattenKeyValuePairs(m["testPhoneNumbers"])
resultRes.Project = dcl.FlattenString(m["project"])
return resultRes
}
// expandTenantMfaConfigMap expands the contents of TenantMfaConfig into a JSON
// request object.
func expandTenantMfaConfigMap(c *Client, f map[string]TenantMfaConfig, res *Tenant) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandTenantMfaConfig(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandTenantMfaConfigSlice expands the contents of TenantMfaConfig into a JSON
// request object.
func expandTenantMfaConfigSlice(c *Client, f []TenantMfaConfig, res *Tenant) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandTenantMfaConfig(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenTenantMfaConfigMap flattens the contents of TenantMfaConfig from a JSON
// response object.
func flattenTenantMfaConfigMap(c *Client, i interface{}, res *Tenant) map[string]TenantMfaConfig {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]TenantMfaConfig{}
}
if len(a) == 0 {
return map[string]TenantMfaConfig{}
}
items := make(map[string]TenantMfaConfig)
for k, item := range a {
items[k] = *flattenTenantMfaConfig(c, item.(map[string]interface{}), res)
}
return items
}
// flattenTenantMfaConfigSlice flattens the contents of TenantMfaConfig from a JSON
// response object.
func flattenTenantMfaConfigSlice(c *Client, i interface{}, res *Tenant) []TenantMfaConfig {
a, ok := i.([]interface{})
if !ok {
return []TenantMfaConfig{}
}
if len(a) == 0 {
return []TenantMfaConfig{}
}
items := make([]TenantMfaConfig, 0, len(a))
for _, item := range a {
items = append(items, *flattenTenantMfaConfig(c, item.(map[string]interface{}), res))
}
return items
}
// expandTenantMfaConfig expands an instance of TenantMfaConfig into a JSON
// request object.
func expandTenantMfaConfig(c *Client, f *TenantMfaConfig, res *Tenant) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.State; !dcl.IsEmptyValueIndirect(v) {
m["state"] = v
}
if v := f.EnabledProviders; v != nil {
m["enabledProviders"] = v
}
return m, nil
}
// flattenTenantMfaConfig flattens an instance of TenantMfaConfig from a JSON
// response object.
func flattenTenantMfaConfig(c *Client, i interface{}, res *Tenant) *TenantMfaConfig {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &TenantMfaConfig{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyTenantMfaConfig
}
r.State = flattenTenantMfaConfigStateEnum(m["state"])
r.EnabledProviders = flattenTenantMfaConfigEnabledProvidersEnumSlice(c, m["enabledProviders"], res)
return r
}
// flattenTenantMfaConfigStateEnumMap flattens the contents of TenantMfaConfigStateEnum from a JSON
// response object.
func flattenTenantMfaConfigStateEnumMap(c *Client, i interface{}, res *Tenant) map[string]TenantMfaConfigStateEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]TenantMfaConfigStateEnum{}
}
if len(a) == 0 {
return map[string]TenantMfaConfigStateEnum{}
}
items := make(map[string]TenantMfaConfigStateEnum)
for k, item := range a {
items[k] = *flattenTenantMfaConfigStateEnum(item.(interface{}))
}
return items
}
// flattenTenantMfaConfigStateEnumSlice flattens the contents of TenantMfaConfigStateEnum from a JSON
// response object.
func flattenTenantMfaConfigStateEnumSlice(c *Client, i interface{}, res *Tenant) []TenantMfaConfigStateEnum {
a, ok := i.([]interface{})
if !ok {
return []TenantMfaConfigStateEnum{}
}
if len(a) == 0 {
return []TenantMfaConfigStateEnum{}
}
items := make([]TenantMfaConfigStateEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenTenantMfaConfigStateEnum(item.(interface{})))
}
return items
}
// flattenTenantMfaConfigStateEnum asserts that an interface is a string, and returns a
// pointer to a *TenantMfaConfigStateEnum with the same value as that string.
func flattenTenantMfaConfigStateEnum(i interface{}) *TenantMfaConfigStateEnum {
s, ok := i.(string)
if !ok {
return nil
}
return TenantMfaConfigStateEnumRef(s)
}
// flattenTenantMfaConfigEnabledProvidersEnumMap flattens the contents of TenantMfaConfigEnabledProvidersEnum from a JSON
// response object.
func flattenTenantMfaConfigEnabledProvidersEnumMap(c *Client, i interface{}, res *Tenant) map[string]TenantMfaConfigEnabledProvidersEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]TenantMfaConfigEnabledProvidersEnum{}
}
if len(a) == 0 {
return map[string]TenantMfaConfigEnabledProvidersEnum{}
}
items := make(map[string]TenantMfaConfigEnabledProvidersEnum)
for k, item := range a {
items[k] = *flattenTenantMfaConfigEnabledProvidersEnum(item.(interface{}))
}
return items
}
// flattenTenantMfaConfigEnabledProvidersEnumSlice flattens the contents of TenantMfaConfigEnabledProvidersEnum from a JSON
// response object.
func flattenTenantMfaConfigEnabledProvidersEnumSlice(c *Client, i interface{}, res *Tenant) []TenantMfaConfigEnabledProvidersEnum {
a, ok := i.([]interface{})
if !ok {
return []TenantMfaConfigEnabledProvidersEnum{}
}
if len(a) == 0 {
return []TenantMfaConfigEnabledProvidersEnum{}
}
items := make([]TenantMfaConfigEnabledProvidersEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenTenantMfaConfigEnabledProvidersEnum(item.(interface{})))
}
return items
}
// flattenTenantMfaConfigEnabledProvidersEnum asserts that an interface is a string, and returns a
// pointer to a *TenantMfaConfigEnabledProvidersEnum with the same value as that string.
func flattenTenantMfaConfigEnabledProvidersEnum(i interface{}) *TenantMfaConfigEnabledProvidersEnum {
s, ok := i.(string)
if !ok {
return nil
}
return TenantMfaConfigEnabledProvidersEnumRef(s)
}
// This function returns a matcher that checks whether a serialized resource matches this resource
// in its parameters (as defined by the fields in a Get, which definitionally define resource
// identity). This is useful in extracting the element from a List call.
func (r *Tenant) matcher(c *Client) func([]byte) bool {
return func(b []byte) bool {
cr, err := unmarshalTenant(b, c, r)
if err != nil {
c.Config.Logger.Warning("failed to unmarshal provided resource in matcher.")
return false
}
nr := r.urlNormalized()
ncr := cr.urlNormalized()
c.Config.Logger.Infof("looking for %v\nin %v", nr, ncr)
if nr.Project == nil && ncr.Project == nil {
c.Config.Logger.Info("Both Project fields null - considering equal.")
} else if nr.Project == nil || ncr.Project == nil {
c.Config.Logger.Info("Only one Project field is null - considering unequal.")
return false
} else if *nr.Project != *ncr.Project {
return false
}
if nr.Name == nil && ncr.Name == nil {
c.Config.Logger.Info("Both Name fields null - considering equal.")
} else if nr.Name == nil || ncr.Name == nil {
c.Config.Logger.Info("Only one Name field is null - considering unequal.")
return false
} else if *nr.Name != *ncr.Name {
return false
}
return true
}
}
type tenantDiff struct {
// The diff should include one or the other of RequiresRecreate or UpdateOp.
RequiresRecreate bool
UpdateOp tenantApiOperation
FieldName string // used for error logging
}
func convertFieldDiffsToTenantDiffs(config *dcl.Config, fds []*dcl.FieldDiff, opts []dcl.ApplyOption) ([]tenantDiff, error) {
opNamesToFieldDiffs := make(map[string][]*dcl.FieldDiff)
// Map each operation name to the field diffs associated with it.
for _, fd := range fds {
for _, ro := range fd.ResultingOperation {
if fieldDiffs, ok := opNamesToFieldDiffs[ro]; ok {
fieldDiffs = append(fieldDiffs, fd)
opNamesToFieldDiffs[ro] = fieldDiffs
} else {
config.Logger.Infof("%s required due to diff: %v", ro, fd)
opNamesToFieldDiffs[ro] = []*dcl.FieldDiff{fd}
}
}
}
var diffs []tenantDiff
// For each operation name, create a tenantDiff which contains the operation.
for opName, fieldDiffs := range opNamesToFieldDiffs {
// Use the first field diff's field name for logging required recreate error.
diff := tenantDiff{FieldName: fieldDiffs[0].FieldName}
if opName == "Recreate" {
diff.RequiresRecreate = true
} else {
apiOp, err := convertOpNameToTenantApiOperation(opName, fieldDiffs, opts...)
if err != nil {
return diffs, err
}
diff.UpdateOp = apiOp
}
diffs = append(diffs, diff)
}
return diffs, nil
}
func convertOpNameToTenantApiOperation(opName string, fieldDiffs []*dcl.FieldDiff, opts ...dcl.ApplyOption) (tenantApiOperation, error) {
switch opName {
case "updateTenantUpdateTenantOperation":
return &updateTenantUpdateTenantOperation{FieldDiffs: fieldDiffs}, nil
default:
return nil, fmt.Errorf("no such operation with name: %v", opName)
}
}
func extractTenantFields(r *Tenant) error {
vMfaConfig := r.MfaConfig
if vMfaConfig == nil {
// note: explicitly not the empty object.
vMfaConfig = &TenantMfaConfig{}
}
if err := extractTenantMfaConfigFields(r, vMfaConfig); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vMfaConfig) {
r.MfaConfig = vMfaConfig
}
return nil
}
func extractTenantMfaConfigFields(r *Tenant, o *TenantMfaConfig) error {
return nil
}
func postReadExtractTenantFields(r *Tenant) error {
vMfaConfig := r.MfaConfig
if vMfaConfig == nil {
// note: explicitly not the empty object.
vMfaConfig = &TenantMfaConfig{}
}
if err := postReadExtractTenantMfaConfigFields(r, vMfaConfig); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vMfaConfig) {
r.MfaConfig = vMfaConfig
}
return nil
}
func postReadExtractTenantMfaConfigFields(r *Tenant, o *TenantMfaConfig) error {
return nil
}
|
package base
// Selector is a Warp10 selector
type Selector string
const (
// WildCardSelector select all available GTS
WildCardSelector Selector = "~.*{}"
)
// NewSelector Build a new Selector
func NewSelector(className string, labels Labels) Selector {
return Selector(className + formatLabels(labels))
}
|
package main
import "fmt"
type foo int
func main() {
var myAge foo = 44
fmt.Printf("%T \t %v \n", myAge, myAge)
var yourAge int
yourAge = 29
fmt.Printf("%T \t\t %v \n", yourAge, yourAge)
// this doesn't work :
// fmt.Println(myAge + yourAge) // not same type so can't add
// this conversion works :
// fmt.Println(int(myAge) + yourAge)
// fmt.Println("\t\t", myAge+foo(yourAge)) // cause foo is embedded in int
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.