text stringlengths 11 4.05M |
|---|
package common
import (
"fmt"
"os"
"path"
"runtime"
"strings"
)
// These vars are set by the build script in scripts/build_partner_tools.rb
var (
Version string
BuildDate string
GitHash string
License string
WikiUrl string
RepoUrl string
Email string
)
// Current Pharos API Version
const PharosAPIVersion = "v2"
// Exit Codes
const (
// EXIT_OK means program completed successfully.
EXIT_OK = 0
// EXIT_RUNTIME_ERR means program did not complete
// successfully due to an error. The error may have
// occurred outside the program, such as a network
// error or an error on a remote server.
EXIT_RUNTIME_ERR = 1
// EXIT_BAG_INVALID is used primarily for apt_validate.
// It means the program completed its run and found that
// the bag is not valid.
EXIT_BAG_INVALID = 2
// EXIT_USER_ERR means the user did not supply some
// required option or argument, or the user supplied
// invalid options/arguments.
EXIT_USER_ERR = 3
// EXIT_ITEM_NOT_FOUND can occur when the user tries to
// upload, download, or validate a file that doesn't exist,
// or when apt_check_ingest is asked to check on a bag
// which has no record in Pharos.
EXIT_ITEM_NOT_FOUND = 4
// EXIT_NOT_INGESTED occurs when apt_check_ingest finds
// a WorkItem record for a bag in Pharos, but the bag has
// not yet been fully ingested.
EXIT_NOT_INGESTED = 5
// EXIT_SOME_INGESTED occurs when apt_check_ingest finds
// multiple WorkItems in Pharos matching a bag name, and
// some versions of the bag have been ingested while others
// have not.
EXIT_SOME_INGESTED = 6
// EXIT_NO_OP means the user requested help message or
// version info. The program printed the info, and no other
// operations were performed.
EXIT_NO_OP = 100
)
func GetVersion() string {
osName := strings.Title(runtime.GOOS)
architecture := runtime.GOARCH
appName := path.Base(os.Args[0])
version := fmt.Sprintf("\n%s\n", appName)
version += fmt.Sprintf(" Version %s for %s %s\n", Version, osName, architecture)
version += fmt.Sprintf(" Commit %s. Built %s.\n", GitHash, BuildDate)
version += fmt.Sprintf(" Released by APTrust.org under the %s license.\n", License)
version += fmt.Sprintf(" Help: %s\n", Email)
version += fmt.Sprintf(" More info at %s\n", WikiUrl)
return version
}
|
package reflection
import "reflect"
func PopulateFunction(readerFuncType reflect.Type, readerFuncPtrValue reflect.Value, reflectedFunc func([]reflect.Value) []reflect.Value) {
newFuncValue := reflect.MakeFunc(readerFuncType, reflectedFunc)
readerFuncPtrValue.Elem().Set(newFuncValue)
}
|
package raftkv
import (
"bytes"
"encoding/gob"
"labrpc"
"log"
"raft"
"sync"
"time"
)
const Debug = -3
func DPrintf(level int, format string, a ...interface{}) (n int, err error) {
if Debug > level {
log.Printf(format, a...)
}
return
}
type Op struct {
// Your definitions here.
// Field names must start with capital letters,
// otherwise RPC will break.
Op string // "Put" or "Append" or "Get"
Key string
Value string
UUID string
}
type Reply struct {
Value string
Index int
Op string
Err
}
type RaftKV struct {
mu sync.Mutex
me int
rf *raft.Raft
applyCh chan raft.ApplyMsg
persister *raft.Persister
maxraftstate int // snapshot if log grows this big
// Your definitions here.
keyValue map[string]string
logs map[string]Reply
lastIndex int
lastTerm int
lastSavedIndex int
quitCh chan bool
}
func (kv *RaftKV) saveSnapshot() {
w := new(bytes.Buffer)
e := gob.NewEncoder(w)
e.Encode(kv.lastIndex)
e.Encode(kv.lastTerm)
e.Encode(kv.keyValue)
e.Encode(kv.logs)
data := w.Bytes()
kv.persister.SaveSnapshot(data)
}
//
// restore previously persisted state.
//
func (kv *RaftKV) readSnapshot(data []byte) {
if data == nil || len(data) < 1 { // bootstrap without any state?
return
}
r := bytes.NewBuffer(data)
d := gob.NewDecoder(r)
d.Decode(&kv.lastIndex)
d.Decode(&kv.lastTerm)
d.Decode(&kv.keyValue)
d.Decode(&kv.logs)
}
func (kv *RaftKV) Get(args *GetArgs, reply *GetReply) {
// Your code here.
DPrintf(0, "Server Start Get: %v\n", args)
defer DPrintf(-1, "Server End Get: %v\n", args)
kv.mu.Lock()
logs, isDulpicate := kv.logs[args.UUID]
kv.mu.Unlock()
if isDulpicate {
DPrintf(-1, "Dulplicate: %v, reply is %v\n", args, logs)
reply.WrongLeader = false
reply.Value = logs.Value
return
}
starti, _, ok, leaderId := kv.rf.Start(Op{"Get", args.Key, "", args.UUID})
term, _ := kv.rf.GetState()
DPrintf(-1, "After Server Start Get: %v\n", ok)
if !ok {
reply.WrongLeader = true
reply.LeaderId = leaderId
reply.Err = "It's wrong leader!"
DPrintf(-1, "Wrong leader Get: %v\n", args)
return
}
now := time.Now()
for time.Since(now).Seconds() < 1 {
kv.mu.Lock()
if nowTerm, isLeader := kv.rf.GetState(); !isLeader || nowTerm != term {
reply.WrongLeader = true
reply.LeaderId = -1
reply.Err = "The server lost its leadership!"
kv.mu.Unlock()
break
}
if r, isExist := kv.logs[args.UUID]; isExist && r.Index == starti {
reply.WrongLeader = false
reply.Value = r.Value
DPrintf(-1, "KVserver %v Success Get: %v, value is %v, reply is %v, keyvalue is %v\n", kv.me, args, r, reply, kv.keyValue)
kv.mu.Unlock()
return
} else if isExist && r.Index != starti {
reply.WrongLeader = true
reply.LeaderId = -1
reply.Err = "The server lost its leadership!"
kv.mu.Unlock()
return
}
kv.mu.Unlock()
time.Sleep(time.Millisecond * 10)
}
DPrintf(-1, "Timeout Get: %v\n", args)
reply.WrongLeader = true
reply.LeaderId = -1
reply.Err = "Timeout!"
}
func (kv *RaftKV) PutAppend(args *PutAppendArgs, reply *PutAppendReply) {
// Your code here.
DPrintf(0, "Server Start Put: %v\n", args)
defer DPrintf(-1, "Server End Put: %v\n", args)
kv.mu.Lock()
_, isDulpicate := kv.logs[args.UUID]
kv.mu.Unlock()
if isDulpicate {
reply.WrongLeader = false
return
}
starti, _, ok, leaderId := kv.rf.Start(Op{args.Op, args.Key, args.Value, args.UUID})
term, _ := kv.rf.GetState()
DPrintf(-2, "After Server Start Put: %v. I'm %v, leaderId is %v\n", ok, kv.me, leaderId)
if !ok {
reply.WrongLeader = true
reply.LeaderId = leaderId
reply.Err = "It's wrong leader!"
DPrintf(0, "Wrong leader put: %v\n", args)
return
}
// replyCh := kv.replyCh
// replyMsg := <-replyCh
// DPrintf(0, "Reply\n")
// DPrintf(0, "%v ==? %v\n", starti, replyMsg.Index)
// if replyMsg.Index == starti {
// reply.WrongLeader = false
// }
now := time.Now()
for time.Since(now).Seconds() < 1 {
kv.mu.Lock()
if nowTerm, isLeader := kv.rf.GetState(); !isLeader || nowTerm != term {
reply.WrongLeader = true
reply.LeaderId = -1
reply.Err = "The server lost its leadership!"
kv.mu.Unlock()
break
}
if r, isExist := kv.logs[args.UUID]; isExist && r.Index == starti {
DPrintf(-1, "KVserver %v Success put: %v, keyvalue is %v\n", kv.me, args, kv.keyValue)
kv.mu.Unlock()
reply.WrongLeader = false
return
} else if isExist && r.Index != starti {
reply.WrongLeader = true
reply.LeaderId = -1
reply.Err = "The server lost its leadership!"
kv.mu.Unlock()
return
}
kv.mu.Unlock()
time.Sleep(time.Millisecond * 10)
}
DPrintf(-1, "TImeout: %v\n", args)
reply.WrongLeader = true
reply.LeaderId = -1
// reply.Err = " Timeout!"
}
//
// the tester calls Kill() when a RaftKV instance won't
// be needed again. you are not required to do anything
// in Kill(), but it might be convenient to (for example)
// turn off debug output from this instance.
//
func (kv *RaftKV) Kill() {
kv.mu.Lock()
close(kv.quitCh)
DPrintf(-3, "Kill kvserver %v\n", kv.me)
kv.mu.Unlock()
kv.rf.Kill()
// Your code here, if desired.
}
//
// servers[] contains the ports of the set of
// servers that will cooperate via Raft to
// form the fault-tolerant key/value service.
// me is the index of the current server in servers[].
// the k/v server should store snapshots with persister.SaveSnapshot(),
// and Raft should save its state (including log) with persister.SaveRaftState().
// the k/v server should snapshot when Raft's saved state exceeds maxraftstate bytes,
// in order to allow Raft to garbage-collect its log. if maxraftstate is -1,
// you don't need to snapshot.
// StartKVServer() must return quickly, so it should start goroutines
// for any long-running work.
//
func StartKVServer(servers []*labrpc.ClientEnd, me int, persister *raft.Persister, maxraftstate int) *RaftKV {
// call gob.Register on structures you want
// Go's RPC library to marshall/unmarshall.
gob.Register(Op{})
kv := new(RaftKV)
kv.me = me
kv.maxraftstate = maxraftstate
kv.persister = persister
// You may need initialization code here.
kv.lastSavedIndex = -1
kv.applyCh = make(chan raft.ApplyMsg)
kv.quitCh = make(chan bool)
kv.rf = raft.Make(servers, me, persister, kv.applyCh)
kv.keyValue = make(map[string]string)
kv.logs = make(map[string]Reply)
kv.readSnapshot(persister.ReadSnapshot())
applyCh := kv.applyCh
// replyCh := kv.replyCh
go func() {
for m := range applyCh {
kv.mu.Lock()
select {
case <-kv.quitCh:
kv.mu.Unlock()
return
default:
me := kv.me
DPrintf(-3, "%v Apply MSg: %v\n", me, m)
if m.UseSnapshot {
DPrintf(0, "%v Save snapshot\n", me)
DPrintf(0, "%v Before keyvalue: %v\n", me, kv.keyValue)
kv.persister.SaveSnapshot(m.Snapshot)
kv.readSnapshot(kv.persister.ReadSnapshot())
DPrintf(0, "%v After keyvalue: %v\n", me, kv.keyValue)
kv.lastSavedIndex = -1
kv.mu.Unlock()
continue
}
reply := Reply{}
reply.Index = m.Index
op := m.Command.(Op)
kv.lastIndex = m.Index
kv.lastTerm = m.Term
DPrintf(0, "kv server %v update lastIndex: %v, last term: %v\n", kv.me, m.Index, m.Term)
_, ok := kv.logs[op.UUID]
if ok {
DPrintf(0, "%v's duplicate %v, logs: %v\n", me, m, kv.logs)
kv.mu.Unlock()
continue
}
reply.Op = op.Op
if op.Op == "Put" {
kv.keyValue[op.Key] = op.Value
} else if op.Op == "Append" {
kv.keyValue[op.Key] = kv.keyValue[op.Key] + op.Value
} else {
reply.Value = kv.keyValue[op.Key]
}
kv.logs[op.UUID] = reply
DPrintf(-3, "%v's keyValue: %v\n", me, kv.keyValue)
DPrintf(-3, "%v's logs: %v\n", me, kv.logs)
DPrintf(-3, "Finish %v Apply MSg: %v\n", me, m)
}
kv.mu.Unlock()
}
}()
if kv.maxraftstate != -1 {
go func() {
for {
kv.mu.Lock()
select {
case <-kv.quitCh:
kv.mu.Unlock()
return
default:
if kv.maxraftstate != -1 && kv.persister.RaftStateSize() > kv.maxraftstate &&
kv.lastSavedIndex != kv.lastIndex {
kv.saveSnapshot()
kv.rf.SetDiscardIndex(kv.lastIndex, kv.lastTerm)
kv.lastSavedIndex = kv.lastIndex
DPrintf(-3, "Server %v save snapshot lastIndex: %v lastTerm: %v\n", me, kv.lastIndex, kv.lastTerm)
} else {
}
}
kv.mu.Unlock()
time.Sleep(time.Millisecond * 50)
}
}()
}
// You may need initialization code here.
return kv
}
|
package routes
import (
"net/http"
"ocg-be/controller"
"ocg-be/middlewares"
"github.com/gorilla/mux"
)
func Setup(r *mux.Router) {
routeAdmin := r.PathPrefix("/admin").Subrouter()
routeAdmin.Use(middlewares.IsAuthorized)
routesPublic(r)
routesAdmin(routeAdmin)
}
func routesPublic(r *mux.Router) {
//api-products
r.HandleFunc("/products", controller.GetProducts).Methods(http.MethodGet) //GET_PRODUCTS
r.HandleFunc("/products/collections", controller.GetProductCollection).Methods(http.MethodGet)
r.HandleFunc("/products/{handle}", controller.GetProductByHandle).Methods(http.MethodGet) //GET_PRODUCT_By_Id
r.HandleFunc("/products", controller.CreateProduct).Methods(http.MethodPost) //POST_PRODUCT
r.HandleFunc("/products/{id}", controller.DeleteProductById).Methods(http.MethodDelete) //DELETE_PRODUCT_By_Id
r.HandleFunc("/products", controller.UpdateProduct).Methods(http.MethodPatch) //GET_PRODUCT_By_Id
//api-image
r.HandleFunc("/uploads", controller.CreateProductImage).Methods(http.MethodPost) //Upload_images
image := http.StripPrefix("/images/", http.FileServer(http.Dir("./")))
r.PathPrefix("/images/").Handler(image) //Prefix-image
//api-authens
r.HandleFunc("/login", controller.Login).Methods(http.MethodPost) //Login
r.HandleFunc("/register", controller.Register).Methods(http.MethodPost) //Register
r.HandleFunc("/logout", controller.Logout).Methods(http.MethodPost) //Logout
//api-orders
//collections
// r.HandleFunc("/collections/:name", controller.GetAllCollections).Methods(http.MethodGet)
r.HandleFunc("/collections", controller.GetAllCollections).Methods(http.MethodGet)
r.HandleFunc("/collections", controller.CreateCollection).Methods(http.MethodPut)
r.HandleFunc("/collections", controller.AddProductToCollection).Methods(http.MethodPost)
r.HandleFunc("/collects/{id}", controller.RemoveProductFromCollection).Methods(http.MethodDelete)
r.HandleFunc("/collections/{id}", controller.DeleteCollectionById).Methods(http.MethodDelete)
}
func routesAdmin(r *mux.Router) { //admin/...
r.HandleFunc("/orders", controller.GetAllOrders).Methods(http.MethodGet)
}
|
package router
import (
"fmt"
"io/ioutil"
"log"
"time"
"github.com/AsynkronIT/protoactor-go/actor"
"github.com/stretchr/testify/mock"
)
var nilPID *actor.PID
func init() {
// discard all logging in tests
log.SetOutput(ioutil.Discard)
}
func spawnMockProcess(name string) (*actor.PID, *mockProcess) {
p := &mockProcess{}
pid, ok := actor.ProcessRegistry.Add(p, name)
if !ok {
panic(fmt.Errorf("did not spawn named process '%s'", name))
}
return pid, p
}
func removeMockProcess(pid *actor.PID) {
actor.ProcessRegistry.Remove(pid)
}
type mockProcess struct {
mock.Mock
}
func (m *mockProcess) SendUserMessage(pid *actor.PID, message interface{}, sender *actor.PID) {
m.Called(pid, message, sender)
}
func (m *mockProcess) SendSystemMessage(pid *actor.PID, message interface{}) {
m.Called(pid, message)
}
func (m *mockProcess) Stop(pid *actor.PID) {
m.Called(pid)
}
type mockContext struct {
mock.Mock
}
func (m *mockContext) Watch(pid *actor.PID) {
m.Called(pid)
}
func (m *mockContext) Unwatch(pid *actor.PID) {
m.Called(pid)
}
func (m *mockContext) Message() interface{} {
args := m.Called()
return args.Get(0)
}
func (m *mockContext) SetReceiveTimeout(d time.Duration) {
m.Called(d)
}
func (m *mockContext) ReceiveTimeout() time.Duration {
args := m.Called()
return args.Get(0).(time.Duration)
}
func (m *mockContext) Sender() *actor.PID {
args := m.Called()
return args.Get(0).(*actor.PID)
}
func (m *mockContext) MessageHeader() actor.ReadonlyMessageHeader {
args := m.Called()
return args.Get(0).(actor.ReadonlyMessageHeader)
}
func (m *mockContext) Tell(pid *actor.PID, message interface{}) {
m.Called()
}
func (m *mockContext) Request(pid *actor.PID, message interface{}) {
m.Called()
}
func (m *mockContext) SetBehavior(r actor.ActorFunc) {
m.Called(r)
}
func (m *mockContext) PushBehavior(r actor.ActorFunc) {
m.Called(r)
}
func (m *mockContext) PopBehavior() {
m.Called()
}
func (m *mockContext) Self() *actor.PID {
args := m.Called()
return args.Get(0).(*actor.PID)
}
func (m *mockContext) Parent() *actor.PID {
args := m.Called()
return args.Get(0).(*actor.PID)
}
func (m *mockContext) Spawn(p *actor.Props) *actor.PID {
args := m.Called(p)
return args.Get(0).(*actor.PID)
}
func (m *mockContext) SpawnPrefix(p *actor.Props, prefix string) *actor.PID {
args := m.Called(p, prefix)
return args.Get(0).(*actor.PID)
}
func (m *mockContext) SpawnNamed(p *actor.Props, name string) (*actor.PID, error) {
args := m.Called(p, name)
return args.Get(0).(*actor.PID), args.Get(1).(error)
}
func (m *mockContext) Children() []*actor.PID {
args := m.Called()
return args.Get(0).([]*actor.PID)
}
func (m *mockContext) Stash() {
m.Called()
}
func (m *mockContext) Respond(response interface{}) {
m.Called(response)
}
func (m *mockContext) Actor() actor.Actor {
args := m.Called()
return args.Get(0).(actor.Actor)
}
func (m *mockContext) AwaitFuture(f *actor.Future, cont func(res interface{}, err error)) {
m.Called(f, cont)
}
func (m *mockContext) RequestFuture(pid *actor.PID, message interface{}, timeout time.Duration) *actor.Future {
args := m.Called()
return args.Get(0).(*actor.Future)
}
|
package _13_Roman_to_Integer
import "testing"
func TestRomanToInt(t *testing.T) {
var (
roman string
)
roman = "III"
if num := romanToInt(roman); num != 3 {
t.Errorf("wrong num with %d", num)
}
}
|
package db
import (
"context"
"crypto/rand"
"crypto/sha1"
"errors"
"github.com/jackc/pgx/v4"
"github.com/jackc/pgx/v4/pgxpool"
"log"
)
const INSERT_USER = `INSERT INTO USERS(aud, email, password, salt, role)
VALUES ( $1,$2, $3, $4, $5 )`
const CHECK_AUD = `SELECT COUNT(*)
FROM USERS as u
WHERE u.aud = $1`
func checkAudExists(ctx context.Context, pool *pgxpool.Pool, aud string) (bool, error) {
conn, err := pool.Acquire(ctx)
if err != nil {
log.Printf("ERROR: unable to acquire connection from pool. %v\n", err)
return false, err
}
defer conn.Release()
tx, err := conn.BeginTx(ctx, pgx.TxOptions{
IsoLevel: pgx.ReadUncommitted,
})
if err != nil {
log.Printf("ERROR: Unable to set transaction level. %v\n", err)
return false, err
}
defer tx.Rollback(ctx)
rows, err := tx.Query(ctx, CHECK_AUD, aud)
if err != nil {
log.Printf("ERROR: Unable to query Users DB to check aud. %v\n", err)
return false, err
}
var count uint32
for rows.Next() {
err = rows.Scan(&count)
if err != nil {
log.Printf("ERROR: unable to query Users DB to check aud. %v\n", err)
return false, err
}
}
return count != 0, nil
}
func InsertUser(ctx context.Context, pool *pgxpool.Pool, aud string, email string, password []byte, role string) (bool, error) {
// first check if user exists in DB
testAud, err := getUserAud(ctx, pool, email)
if testAud != "" {
return false, errors.New("email_exists")
}
conn, err := pool.Acquire(ctx)
if err != nil {
log.Printf("ERROR: unable to acquire connection from pool. %v\n", err)
return false, err
}
defer conn.Release()
tx, err := conn.BeginTx(ctx, pgx.TxOptions{
IsoLevel: pgx.ReadUncommitted,
})
if err != nil {
log.Printf("ERROR: Unable to set transaction level. %v\n", err)
return false, err
}
defer tx.Rollback(ctx)
if aud == "" {
salt := generateRandomSalt(32)
h := sha1.New()
h.Write(append(password, salt...))
hashedPwd := h.Sum(nil)
h = sha1.New()
h.Write(append([]byte(email), salt...))
aud = string(h.Sum(nil))
// ensure aud is unique
audExists, err := checkAudExists(ctx, pool, aud)
if err != nil {
log.Printf("ERROR: unable to check whether generated aud exists.\n")
return false, err
}
for audExists {
h = sha1.New()
salt = generateRandomSalt(32)
h.Write(append([]byte(aud), salt...))
aud = string(h.Sum(nil))
audExists, err = checkAudExists(ctx, pool, aud)
if err != nil {
log.Printf("ERROR: unable to check whether generated aud exists.\n")
return false, err
}
}
_, err = tx.Query(ctx, INSERT_USER, aud, email, hashedPwd, salt, role)
if err != nil {
log.Printf("ERROR: Unable to query Users DB to get aud. %v\n", err)
return false, err
}
} else {
_, err := tx.Query(ctx, INSERT_USER, aud, email, nil, nil, role)
if err != nil {
log.Printf("ERROR: Unable to insert User info into DB. %v\n", err)
return false , err
}
}
_ = tx.Commit(ctx)
return true, nil
}
func generateRandomSalt(saltSize int) []byte {
salt := make([]byte, saltSize)
_, err := rand.Read(salt[:])
if err != nil {
log.Printf("ERROR: unable to generate sakt")
}
return salt
} |
package models
import (
"errors"
"fmt"
"os"
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/postgres" //postgres driver
"github.com/joho/godotenv"
)
var conn *gorm.DB
func init() {
fmt.Println("connecting to database...")
err := godotenv.Load("conf.env")
if err != nil {
LogError(errors.New("error accessing config file"))
}
username := os.Getenv("db_user")
password := os.Getenv("db_pass")
if os.Getenv("app_mode") == "prod" {
username = os.Getenv("prod_db_user")
password = os.Getenv("prod_db_pass")
}
dbName := os.Getenv("db_name")
dbHost := os.Getenv("db_host")
dbURL := fmt.Sprintf("host=%s user=%s dbname=%s sslmode=disable password=%s", dbHost, username, dbName, password)
db, err := gorm.Open("postgres", dbURL)
if err != nil {
defer recover()
LogError(err)
panic(err)
}
conn = db
if err == nil {
fmt.Println("Database connection successful")
}
autoMigrateTables()
}
func autoMigrateTables() {
conn.AutoMigrate(&Subscribe{})
}
//GetDB sends the db objects
func GetDB() *gorm.DB {
return conn
}
|
package domain
import "time"
//AuthTokenResponse ...
type AuthTokenResponse struct {
Token string `json:"token"`
ExpiresAt time.Time `json:"expires_at"`
}
|
package lintcode
/**
* Definition for a binary tree node.
*
*/
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
var treeMap map[int]int
/**
* @param inOrder: A list of integers that inorder traversal of a tree
* @param preOrder: A list of integers that preorder traversal of a tree
* @return: Root of a tree
*/
func buildTree(inOrder []int, preOrder []int) *TreeNode {
treeMap = make(map[int]int, len(inOrder))
for i := 0; i < len(inOrder); i++ {
treeMap[inOrder[i]] = i
}
return build(inOrder, preOrder, 0, len(inOrder)-1, 0, len(preOrder)-1)
}
func build(inOrder []int, preOrder []int, inLeft int, inRight int, preLeft int, preRight int) *TreeNode {
if len(inOrder) == 0 || len(preOrder) == 0 {
return nil
}
// 注意特殊情况
if inRight < 0 || preRight < 0 || inLeft > inRight || preLeft > preRight {
return nil
}
rootVal := preOrder[preLeft]
root := &TreeNode{
rootVal,
nil,
nil,
}
rootLoc := treeMap[rootVal]
if inLeft == inRight || preLeft == preRight {
return root
}
// 根据中序遍历得到左子树（或右子树）节点个数，由此推算先续遍历中的左子树和右子树下标
leftNum := rootLoc - inLeft
// rightNum := inRight - rootLoc
// 中序下标： [inLeft:rootLoc-1],rootLoc(根节点),[rootLoc+1:inRight]
// 先序下标： preLeft(根节点）,[preLeft+1:preLeft+1+(左子树节点个数-1)],[preLeft+1+(左子树节点个数-1)+1:preRight]
root.Left = build(inOrder, preOrder, inLeft, rootLoc-1, preLeft+1, preLeft+leftNum)
root.Right = build(inOrder, preOrder, rootLoc+1, inRight, preLeft+leftNum+1, preRight)
return root
}
|
// connected clients |
package controllers
import (
"testing"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
corev1 "k8s.io/api/core/v1"
)
func Test_podsStatusState_waitingOnPods(t *testing.T) {
type fields struct {
expectedRunningPods int
readyCount int
notReadyCount int
podRevisions []int
podErrors []corev1.Pod
}
tests := []struct {
name string
fields fields
want bool
}{
{
"ready",
fields{
3,
3,
0,
[]int{1, 1, 1},
[]corev1.Pod{},
},
false,
},
{
"ready but has a pod with errors",
fields{
3,
2,
1,
[]int{1, 1, 1},
[]corev1.Pod{
{
ObjectMeta: metav1.ObjectMeta{
Name: "test",
},
},
},
},
false,
},
{
"not ready",
fields{
3,
2,
1,
[]int{1, 1, 1},
[]corev1.Pod{},
},
true,
},
{
"ready but mismatched revisions",
fields{
3,
2,
1,
[]int{1, 1, 2},
[]corev1.Pod{},
},
true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := &podsStatusState{
expectedRunningPods: tt.fields.expectedRunningPods,
readyCount: tt.fields.readyCount,
notReadyCount: tt.fields.notReadyCount,
podRevisions: tt.fields.podRevisions,
podErrors: tt.fields.podErrors,
}
if got := s.waitingOnPods(); got != tt.want {
t.Errorf("waitingOnPods() = %v, want %v", got, tt.want)
}
})
}
}
|
package api
import (
"encoding/json"
"net/http"
"testing"
"github.com/MarcelCode/ROWA/src/db"
"github.com/stretchr/testify/assert"
)
func TestPlantHandler(t *testing.T) {
mockStore := db.InitMockStore()
mockStore.On("Plant", &db.PlantType{}).Return(1, nil).Once()
c, rec := InitialiseTestServer(http.MethodPost, "/plant/get-position")
expected := 1
if assert.NoError(t, PlantHandler(c)) {
assert.Equal(t, http.StatusOK, rec.Code)
var requestBody int
err := json.NewDecoder(rec.Body).Decode(&requestBody)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, expected, requestBody)
}
mockStore.AssertExpectations(t)
}
func TestFinishPlantingHandler(t *testing.T) {
mockStore := db.InitMockStore()
mockStore.On("FinishPlanting", &db.PlantedModule{}).Return(
&db.Status{Message: "Planting Done"}, nil).Once()
c, rec := InitialiseTestServer(http.MethodPost, "/plant/finish")
expected := &db.Status{Message: "Planting Done"}
if assert.NoError(t, FinishPlantingHandler(c)) {
assert.Equal(t, http.StatusOK, rec.Code)
var requestBody *db.Status
err := json.NewDecoder(rec.Body).Decode(&requestBody)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, expected, requestBody)
}
mockStore.AssertExpectations(t)
}
|
package inmemory
import (
"context"
"fmt"
"net"
"sort"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/test/bufconn"
pb "github.com/pomerium/pomerium/pkg/grpc/registry"
)
const (
ttl = time.Second * 2
)
func TestRegistryListWatch(t *testing.T) {
t.Parallel()
brSvc := &pb.Service{Kind: pb.ServiceKind_DATABROKER, Endpoint: "http://localhost"}
kinds := []pb.ServiceKind{pb.ServiceKind_DATABROKER}
svc := []*pb.Service{brSvc}
ctx, client, cancel, err := newTestRegistry()
require.NoError(t, err)
defer cancel()
wc, err := client.Watch(ctx, &pb.ListRequest{Kinds: kinds})
require.NoError(t, err)
entries, err := wc.Recv()
require.NoError(t, err)
assert.Empty(t, entries.Services)
reportResp, err := client.Report(ctx, &pb.RegisterRequest{Services: svc})
require.NoError(t, err)
assert.LessOrEqual(t, reportResp.CallBackAfter.AsDuration(), ttl)
entries, err = client.List(ctx, &pb.ListRequest{Kinds: kinds})
require.NoError(t, err)
assertEqual(t, svc, entries.Services)
entries, err = wc.Recv()
assert.NoError(t, err)
assertEqual(t, svc, entries.Services)
// wait to expire - an empty list should arrive
entries, err = wc.Recv()
assert.NoError(t, err)
assert.Empty(t, entries.Services)
entries, err = client.List(ctx, &pb.ListRequest{Kinds: kinds})
require.NoError(t, err)
assert.Empty(t, entries.Services)
}
func TestRegistryFilter(t *testing.T) {
t.Parallel()
ctx, client, cancel, err := newTestRegistry()
require.NoError(t, err)
defer cancel()
brSvc := &pb.Service{Kind: pb.ServiceKind_DATABROKER, Endpoint: "http://localhost"}
authSvc := &pb.Service{Kind: pb.ServiceKind_AUTHENTICATE, Endpoint: "http://localhost"}
mtrcsSvc := &pb.Service{Kind: pb.ServiceKind_PROMETHEUS_METRICS, Endpoint: "http://localhost/metrics"}
reportResp, err := client.Report(ctx, &pb.RegisterRequest{Services: []*pb.Service{brSvc, authSvc, mtrcsSvc}})
assert.NoError(t, err, "%v")
assert.LessOrEqual(t, reportResp.CallBackAfter.AsDuration(), ttl)
entries, err := client.List(ctx, &pb.ListRequest{Kinds: []pb.ServiceKind{pb.ServiceKind_DATABROKER}})
require.NoError(t, err)
assertEqual(t, []*pb.Service{brSvc}, entries.Services)
entries, err = client.List(ctx, &pb.ListRequest{Kinds: []pb.ServiceKind{pb.ServiceKind_DATABROKER, pb.ServiceKind_PROMETHEUS_METRICS}})
require.NoError(t, err)
assertEqual(t, []*pb.Service{brSvc, mtrcsSvc}, entries.Services)
entries, err = client.List(ctx, &pb.ListRequest{Kinds: []pb.ServiceKind{}}) // nil filter means all
require.NoError(t, err)
assertEqual(t, []*pb.Service{brSvc, mtrcsSvc, authSvc}, entries.Services)
}
func TestRegistryExpiration(t *testing.T) {
t.Parallel()
svcA := &pb.Service{Kind: pb.ServiceKind_PROMETHEUS_METRICS, Endpoint: "http://host-a/metrics"}
svcB := &pb.Service{Kind: pb.ServiceKind_PROMETHEUS_METRICS, Endpoint: "http://host-b/metrics"}
ctx, client, cancel, err := newTestRegistry()
require.NoError(t, err)
defer cancel()
wc, err := client.Watch(ctx, &pb.ListRequest{Kinds: []pb.ServiceKind{pb.ServiceKind_PROMETHEUS_METRICS}})
require.NoError(t, err)
entries, err := wc.Recv()
require.NoError(t, err)
assert.Empty(t, entries.Services)
_, err = client.Report(ctx, &pb.RegisterRequest{Services: []*pb.Service{svcA, svcB}})
require.NoError(t, err)
ctxB, cancelB := context.WithCancel(ctx)
go func(ctx context.Context) {
after := time.Microsecond
for {
select {
case <-time.After(after):
resp, err := client.Report(ctx, &pb.RegisterRequest{Services: []*pb.Service{svcB}})
if err != nil {
return
}
after = resp.CallBackAfter.AsDuration()
case <-ctx.Done():
return
}
}
}(ctxB)
// first, both services should be reported
entries, err = wc.Recv()
assert.NoError(t, err)
assertEqual(t, []*pb.Service{svcA, svcB}, entries.Services)
// then, svcA should expire as it is not sending updates anymore
entries, err = wc.Recv()
assert.NoError(t, err)
assertEqual(t, []*pb.Service{svcB}, entries.Services)
// now we cancel updates for B, and both registration should expire
cancelB()
entries, err = wc.Recv()
assert.NoError(t, err)
assert.Empty(t, entries.Services)
}
func TestRegistryErrors(t *testing.T) {
t.Parallel()
ctx, client, cancel, err := newTestRegistry()
require.NoError(t, err)
defer cancel()
tc := [][]*pb.Service{
{{Kind: pb.ServiceKind_UNDEFINED_DO_NOT_USE, Endpoint: "http://localhost"}},
{{Kind: pb.ServiceKind_PROMETHEUS_METRICS, Endpoint: ""}},
{{Kind: pb.ServiceKind_PROMETHEUS_METRICS, Endpoint: "/metrics"}},
{},
nil,
}
for _, svc := range tc {
_, err := client.Report(ctx, &pb.RegisterRequest{Services: svc})
assert.Error(t, err, svc)
}
}
func newTestRegistry() (context.Context, pb.RegistryClient, func(), error) {
cancel := new(cancelAll)
l := bufconn.Listen(1024)
cancel.Append(func() { l.Close() })
dialer := func(context.Context, string) (net.Conn, error) {
return l.Dial()
}
ctx, ctxCancel := context.WithCancel(context.Background())
cancel.Append(ctxCancel)
gs := grpc.NewServer()
ttl := time.Second
pb.RegisterRegistryServer(gs, New(ctx, ttl))
go gs.Serve(l)
cancel.Append(gs.Stop)
conn, err := grpc.DialContext(ctx, "inmem", grpc.WithContextDialer(dialer), grpc.WithInsecure())
if err != nil {
cancel.Cancel()
return nil, nil, nil, fmt.Errorf("failed to dial bufnet: %w", err)
}
cancel.Append(func() { conn.Close() })
return ctx, pb.NewRegistryClient(conn), cancel.Cancel, nil
}
type cancelAll []func()
func (c *cancelAll) Append(fn func()) { *c = append(*c, fn) }
func (c *cancelAll) Cancel() {
for _, fn := range *c {
fn()
}
}
type serviceList []*pb.Service
func (l serviceList) Len() int { return len(l) }
func (l serviceList) Less(i, j int) bool {
if l[i].Kind == l[j].Kind {
return l[i].Endpoint < l[j].Endpoint
}
return l[i].Kind < l[j].Kind
}
func (l serviceList) Swap(i, j int) { t := l[i]; l[i] = l[j]; l[j] = t }
func assertEqual(t *testing.T, want, got []*pb.Service) {
t.Helper()
sort.Sort(serviceList(want))
sort.Sort(serviceList(got))
diff := cmp.Diff(want, got, cmpopts.IgnoreUnexported(pb.Service{}))
if diff != "" {
t.Errorf("(-want +got):\n%s", diff)
}
}
func TestAssertEqual(t *testing.T) {
svcA := &pb.Service{Kind: pb.ServiceKind_PROMETHEUS_METRICS, Endpoint: "http://host-a/metrics"}
svcB := &pb.Service{Kind: pb.ServiceKind_PROMETHEUS_METRICS, Endpoint: "http://host-b/metrics"}
svcC := &pb.Service{Kind: pb.ServiceKind_AUTHENTICATE, Endpoint: "http://host-a/"}
svcD := &pb.Service{Kind: pb.ServiceKind_AUTHORIZE, Endpoint: "http://host-a/"}
svcE := &pb.Service{Kind: pb.ServiceKind_AUTHENTICATE, Endpoint: "http://host-e/"}
svcF := &pb.Service{Kind: pb.ServiceKind_AUTHORIZE, Endpoint: "http://host-f/"}
assertEqual(t, []*pb.Service{svcA, svcB}, []*pb.Service{svcA, svcB})
assertEqual(t, []*pb.Service{svcB, svcA}, []*pb.Service{svcA, svcB})
assertEqual(t, []*pb.Service{svcC, svcD}, []*pb.Service{svcD, svcC})
assertEqual(t, []*pb.Service{svcE, svcF}, []*pb.Service{svcF, svcE})
}
|
package mumgo
import (
"crypto/tls"
"fmt"
)
type Config struct {
Username string
Password string
Host string
Port int
CertFile string
KeyFile string
}
var zeroCnf, defaultCnf = Config{}, Config{
Username: "mumgo",
Host: "localhost",
Port: 64738,
CertFile: "~/.mumgo/mumgo.crt",
KeyFile: "~/.mumgo/mumgo.key"}
// Creates a new Config with unassigned fields initialized to defaults
func NewConfig(base ...Config) Config {
var c Config
if len(base) == 0 {
c = Config{}
} else {
c = base[0]
}
if c.Username == zeroCnf.Username {
c.Username = defaultCnf.Username
}
if c.Host == zeroCnf.Host {
c.Host = defaultCnf.Host
}
if c.Port == zeroCnf.Port {
c.Port = defaultCnf.Port
}
if c.CertFile == zeroCnf.CertFile {
c.CertFile = defaultCnf.CertFile
}
if c.KeyFile == zeroCnf.KeyFile {
c.KeyFile = defaultCnf.KeyFile
}
return c
}
// Get the tls.Config describing *CertFile* & *KeyFile*
func (c *Config) GetTLSConfig(verify bool) (tls.Config, error) {
cert, err := tls.LoadX509KeyPair(c.CertFile, c.KeyFile)
if err != nil {
return tls.Config{}, err
}
config := tls.Config{
Certificates: []tls.Certificate{cert},
InsecureSkipVerify: !verify}
return config, nil
}
// Get the address string described by *Host* & *Port*
func (c *Config) GetAddr() string {
return fmt.Sprintf("%s:%d", c.Host, c.Port)
}
|
package main
import (
"fmt"
"github.com/jnewmano/advent2020/input"
"github.com/jnewmano/advent2020/output"
)
func main() {
sum := parta()
fmt.Println(sum)
}
func parta() interface{} {
// input.SetRaw(raw)
// var things = input.Load()
// var things = input.LoadSliceSliceString("")
var things = input.LoadSliceInt("")
p := 25
fmt.Println(len(things))
// var list = make([]int)
for i, _ := range things {
if i < p {
continue
}
fmt.Println(things[i])
if verify(things, p, i) == false {
return things[i]
}
}
// output.High(list)
// output.Sum(list)
return nil
}
func verify(nums []int, p int, idx int) bool {
for _, v := range nums[idx-p : idx] {
for _, k := range nums[idx-p : idx] {
if v == k {
continue
}
fmt.Println(v, k, nums[idx])
if v+k == nums[idx] {
return true
}
}
}
return false
}
var _ = output.High(nil)
var raw = `35
20
15
25
47
40
62
55
65
95
102
117
150
182
127
219
299
277
309
576`
|
package main
import (
"flag"
"log"
"net/http"
"time"
"github.com/hoenn/ynab-metrics/pkg/accounts"
"github.com/hoenn/ynab-metrics/pkg/budgets"
"github.com/hoenn/ynab-metrics/pkg/categories"
"github.com/hoenn/ynab-metrics/pkg/config"
"github.com/hoenn/ynab-metrics/pkg/ratelimit"
"github.com/hoenn/ynab-metrics/pkg/transactions"
"github.com/prometheus/client_golang/prometheus/promhttp"
"go.bmvs.io/ynab"
)
var cfgFile = flag.String("config", "config.json", "The configuration file to use for exporting")
func main() {
flag.Parse()
cfg := config.ParseConfig(*cfgFile)
if cfg.AccessToken == "" {
log.Fatal("User token is empty")
}
c := ynab.NewClient(cfg.AccessToken)
go func() {
for {
budgets := budgets.GetBudgets(c)
accounts.StartMetrics(c, budgets)
categories.StartMetrics(c, budgets)
if cfg.GetTrans {
transactions.StartMetrics(c, budgets)
}
ratelimit.StartMetrics(c)
time.Sleep(time.Duration(cfg.IntervalSeconds) * time.Second)
}
}()
http.Handle("/metrics", promhttp.Handler())
log.Fatal(http.ListenAndServe(":"+cfg.Port, nil))
}
|
package server
import (
"encoding/json"
"fmt"
"net/http"
"github.com/bryanl/dolb/entity"
"github.com/bryanl/dolb/kvs"
"github.com/bryanl/dolb/pkg/app"
"github.com/bryanl/dolb/pkg/lbfactory"
"github.com/bryanl/dolb/service"
"github.com/gorilla/mux"
"golang.org/x/net/context"
)
// LoadBalancerService is a service for managing LoadBalancers.
type LoadBalancerService struct {
Context context.Context
KVS kvs.KVS
EntityManager entity.Manager
LBFactoryFn func(kvs.KVS, entity.Manager) app.LoadBalancerFactory
Mux *mux.Router
}
func defaultLBFactoryFn(kv kvs.KVS, em entity.Manager) app.LoadBalancerFactory {
return lbfactory.New(kv, em)
}
// NewLoadBalancerService builds a LoadBalancerService.
func NewLoadBalancerService(kv kvs.KVS, em entity.Manager, options ...func(*LoadBalancerService)) *LoadBalancerService {
lbs := LoadBalancerService{
Mux: mux.NewRouter(),
KVS: kv,
EntityManager: em,
}
for _, option := range options {
option(&lbs)
}
if lbs.LBFactoryFn == nil {
lbs.LBFactoryFn = defaultLBFactoryFn
}
if lbs.Context == nil {
lbs.Context = context.Background()
}
lbs.handle("/api2/lb", lbs.Create, "POST")
return &lbs
}
// LBFactoryFn sets LBFactoryFn on a LoadBalancerService.
func LBFactoryFn(fn func(kvs.KVS, entity.Manager) app.LoadBalancerFactory) func(*LoadBalancerService) {
return func(lbs *LoadBalancerService) {
lbs.LBFactoryFn = fn
}
}
// Context configures LoadBalancerService Context.
func Context(ctx context.Context) func(*LoadBalancerService) {
return func(lbs *LoadBalancerService) {
lbs.Context = ctx
}
}
func (s *LoadBalancerService) handle(path string, fn service.HandlerFunc2, methods ...string) {
s.Mux.Handle(path, service.Handler2{F: fn, Ctx: s.Context}).Methods(methods...)
}
// Create creates a LoadBalancer
func (s *LoadBalancerService) Create(ctx context.Context, r *http.Request) service.Response {
defer r.Body.Close()
var bc app.BootstrapConfig
err := json.NewDecoder(r.Body).Decode(&bc)
if err != nil {
return service.Response{Body: fmt.Errorf("could not decode json: %v", err), Status: 422}
}
factory := s.LBFactoryFn(s.KVS, s.EntityManager)
lb, err := factory.Build(&bc)
if err != nil {
return service.Response{Body: fmt.Errorf("unable to build load balancer: %v", err), Status: 400}
}
return service.Response{Body: lb, Status: 201}
}
|
package saver
import (
"fmt"
"github.com/ozonva/ova-track-api/internal/flusher"
"github.com/ozonva/ova-track-api/internal/utils"
"time"
)
type BufferedSaver struct {
flusher flusher.Flusher
bufferedTracks []utils.Track
}
func (bs * BufferedSaver) SaveToBuffer (tracks []utils.Track){
bs.FlushBuffer()
bs.bufferedTracks = append(bs.bufferedTracks, tracks...)
}
func (bs * BufferedSaver) FlushBuffer (){
if bs.bufferedTracks == nil {
return
}
notFlushed := bs.flusher.Flush(bs.bufferedTracks)
if notFlushed != nil {
fmt.Errorf("cannot flush tracks %v", notFlushed)
}
bs.bufferedTracks = notFlushed
}
func NewBufferSaver(flusher flusher.Flusher) BufferedSaver {
return BufferedSaver {flusher, nil}
}
// ====================================================================================
type Saver interface {
Save(tracks []utils.Track)
Close()
Init ()
}
type TimelapseBufferedSaver struct {
bs BufferedSaver
timer time.Timer
}
func (tls * TimelapseBufferedSaver) Init (msc int64) {
timer := time.NewTimer(time.Duration(msc) * time.Millisecond)
for true {
select {
case <-timer.C:
tls.bs.FlushBuffer()
}
}
}
func (tls * TimelapseBufferedSaver) Save (tracks []utils.Track) {
tls.bs.SaveToBuffer(tracks)
}
func (tls * TimelapseBufferedSaver) Close () {
tls.timer.Stop()
tls.bs.FlushBuffer()
}
func NewTimelapseBufferedSaver (bufferSaver BufferedSaver) TimelapseBufferedSaver{
return TimelapseBufferedSaver {bufferSaver, time.Timer{}}
}
// ====================================================================================
|
package main
import (
"github.com/dgraph-io/badger"
"github.com/hashicorp/raft"
)
type BadgerStore struct {
store *badger.DB
}
type Options struct{
Path string
StorageOptions *badger.Options
}
// Create new badger store with default options
func NewStore(path string)(*BadgerStore, error){
return New(Options{Path: path, StorageOptions: &badger.DefaultOptions})
}
func New(opts Options)(*BadgerStore, error){
opts.StorageOptions.Dir = opts.Path
opts.StorageOptions.ValueDir = opts.Path
db, err := badger.Open(*opts.StorageOptions)
if err != nil {
return nil, err
}
dbs := BadgerStore{
store: db,
}
return &dbs, err
}
func (dbs *BadgerStore)Set(k, v []byte) error{
txn := dbs.store.NewTransaction(true)
defer txn.Discard()
err := txn.Set(k, v)
if err != nil {
return err
}
if err := txn.Commit(nil); err != nil {
return err
}
return nil
}
func (dbs *BadgerStore) Get(k []byte) ([]byte, error) {
var val []byte
err := dbs.store.View(func(txn *badger.Txn) error {
item, err := txn.Get(k)
if err != nil {
return err
}
val, err = item.Value()
if err != nil {
return err
}
return nil
})
return val, err
}
// StoreLog is used to store a single raft log
func (dbs *BadgerStore) StoreLog(log *raft.Log) error {
return dbs.StoreLogs([]*raft.Log{log})
}
// StoreLogs is used to store a set of raft logs
func (dbs *BadgerStore) StoreLogs(logs []*raft.Log) error {
txn := dbs.store.NewTransaction(true)
defer txn.Discard()
for _, log := range logs {
key := uint64ToBytes(log.Index)
val, err := encodeMsgPack(log)
if err != nil {
return err
}
err = txn.Set(key, val.Bytes())
if err != nil {
return err
}
}
if err := txn.Commit(nil); err != nil {
return err
}
return nil
}
|
package spot
import (
"testing"
"github.com/stretchr/testify/assert"
)
// TestNewRoute tests NewRoute method
func TestNewRoute(t *testing.T) {
tt := map[string]struct {
name string
level string
points int
information string
expectedRes Route
}{
"nominal case": {name: "Aline la maline", level: "5a", points: 5, information: "maillon rapide",
expectedRes: Route{
Name: "Aline la maline",
Level: "5a",
Points: 5,
Information: "maillon rapide",
}},
}
for n, tc := range tt {
t.Run(n, func(t *testing.T) {
route := NewRoute(tc.name, tc.level, tc.points, tc.information)
assert.Equal(t, tc.expectedRes, route)
})
}
}
// TestValidate tests Validate method
func TestValidate(t *testing.T) {
tt := map[string]struct {
name string
expectedErr string
}{
"nominal case: no space": {name: "laBagarre", expectedErr: ""},
"error case: one space": {name: "la Bagarre", expectedErr: "spot name 'la Bagarre' contains at least one space"},
"error case: several spaces ": {name: "la Bagarre with spaces", expectedErr: "spot name 'la Bagarre with spaces' contains at least one space"},
"error case: empty": {name: "", expectedErr: "spot name field is empty"},
}
for n, tc := range tt {
spotDetails := Details{
Name: tc.name,
}
t.Run(n, func(t *testing.T) {
err := spotDetails.Validate()
if tc.expectedErr != "" {
assert.Equal(t, tc.expectedErr, err.Error())
} else {
assert.Equal(t, tc.name, spotDetails.Name)
}
})
}
}
|
package main
func main() {
x := []int{100, 101, 102}
for k, v := range x {
println(k, ":", v)
}
}
|
/*
* @Descripttion:
* @Author: lly
* @Date: 2021-05-28 22:44:51
* @LastEditors: lly
* @LastEditTime: 2021-05-31 01:36:23
*/
package main
import (
"context"
"fmt"
"pb/user"
"github.com/micro/micro/v3/service"
)
const (
Address = "127.0.0.1:8899"
)
func main() {
// create a new service
service := service.New()
// parse command line flags
service.Init()
client := user.NewUserInfoSvrService("user.UserInfo", service.Client())
rsp, err := client.GetUserInfo(context.Background(), &user.GetUserInfoReq{UserID: 1})
if err != nil {
fmt.Println(err)
}
fmt.Println(rsp)
/*
grpc 使用
// 连接
conn, err := grpc.Dial(Address, grpc.WithDefaultCallOptions(grpc.CallContentSubtype(codec.JSON{}.Name())))
if err != nil {
//grpclog.Fatalln(err)
return
}
defer conn.Close()
// // 注册用户
regsReq := &user.RegisterUserReq{User: &user.UserInfo{
Name: "雷雨",
Gender: 1,
Age: 18,
Addr: "深圳",
Phone: "17685244412",
}}
regsRsp, err := c.RegisterUser(context.Background(), regsReq)
if err != nil {
grpclog.Fatalln(err)
}
fmt.Printf("regsRsp=%+v\n", regsRsp)
// // 查询用户
// err = conn.Invoke(context.Background(), "/user.UserInfoSvr/GetUserInfo", req, out)
// if err != nil {
// fmt.Printf("err=%v\n", err)
// return
// }
// fmt.Printf("rsp=%+v\n", out)
*/
}
|
// Copyright 2017 Gruppe 12 IS-105. All rights reserved.
package main
import (
"fmt"
"net"
"./Crypt"
"bufio"
)
var key = Crypt.Randomkey()
func main() {
p := make([]byte, 2048)
conn, err := net.Dial("udp", "158.37.63.180:8009")
if err != nil {
fmt.Printf("Some error %v", err)
return
}
var msg, _ = Crypt.AesEncrypt([]byte("Møte fr 5.5 14:45 Flåklypa"), []byte(key))
fmt.Fprintf(conn, string(key))
fmt.Fprintf(conn, string(msg))
_, err = bufio.NewReader(conn).Read(p)
if err == nil {
fmt.Printf("%s\n", p)
} else {
fmt.Printf("Some error %v\n", err)
}
conn.Close()
}
// Kode fra https://gist.github.com/iwanbk/2295233, https://coderwall.com/p/wohavg/creating-a-simple-tcp-server-in-go -
// - https://systembash.com/a-simple-go-tcp-server-and-tcp-client/ og http://stackoverflow.com/questions/27176523/udp-in-golang-listen-not-a-blocking-call delvis gjennbrukt her.
|
package reconciler
import (
"context"
"testing"
"time"
"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install"
"github.com/stretchr/testify/require"
corev1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/types"
"github.com/operator-framework/api/pkg/operators/v1alpha1"
"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/clientfake"
)
func validGrpcCatalogSource(image, address string) *v1alpha1.CatalogSource {
return &v1alpha1.CatalogSource{
ObjectMeta: metav1.ObjectMeta{
Name: "img-catalog",
Namespace: testNamespace,
UID: types.UID("catalog-uid"),
Labels: map[string]string{"olm.catalogSource": "img-catalog"},
},
Spec: v1alpha1.CatalogSourceSpec{
Image: image,
Address: address,
SourceType: v1alpha1.SourceTypeGrpc,
},
}
}
func grpcCatalogSourceWithSecret(secretNames []string) *v1alpha1.CatalogSource {
return &v1alpha1.CatalogSource{
ObjectMeta: metav1.ObjectMeta{
Name: "private-catalog",
Namespace: testNamespace,
UID: types.UID("catalog-uid"),
Labels: map[string]string{"olm.catalogSource": "img-catalog"},
},
Spec: v1alpha1.CatalogSourceSpec{
Image: "private-image",
Address: "",
SourceType: v1alpha1.SourceTypeGrpc,
Secrets: secretNames,
},
}
}
func grpcCatalogSourceWithStatus(status v1alpha1.CatalogSourceStatus) *v1alpha1.CatalogSource {
catsrc := validGrpcCatalogSource("image", "")
catsrc.Status = status
return catsrc
}
func grpcCatalogSourceWithAnnotations(annotations map[string]string) *v1alpha1.CatalogSource {
catsrc := validGrpcCatalogSource("image", "")
catsrc.ObjectMeta.Annotations = annotations
return catsrc
}
func TestGrpcRegistryReconciler(t *testing.T) {
now := func() metav1.Time { return metav1.Date(2018, time.January, 26, 20, 40, 0, 0, time.UTC) }
blockOwnerDeletion := true
isController := true
// We expect the empty string secret name should not be set
// on the service account
testSecrets := []string{"test-secret", ""}
type cluster struct {
k8sObjs []runtime.Object
}
type in struct {
cluster cluster
catsrc *v1alpha1.CatalogSource
}
type out struct {
status *v1alpha1.RegistryServiceStatus
cluster cluster
err error
}
tests := []struct {
testName string
in in
out out
}{
{
testName: "Grpc/NoExistingRegistry/CreateSuccessful",
in: in{
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
{
testName: "Grpc/ExistingRegistry/CreateSuccessful",
in: in{
cluster: cluster{
k8sObjs: objectsForCatalogSource(validGrpcCatalogSource("test-img", "")),
},
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
{
testName: "Grpc/Address/CreateSuccessful",
in: in{
cluster: cluster{},
catsrc: validGrpcCatalogSource("", "catalog.svc.cluster.local:50001"),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
},
},
},
{
testName: "Grpc/AddressAndImage/CreateSuccessful",
in: in{
cluster: cluster{},
catsrc: validGrpcCatalogSource("img-catalog", "catalog.svc.cluster.local:50001"),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
{
testName: "Grpc/ExistingRegistry/BadServiceWithWrongHash",
in: in{
cluster: cluster{
k8sObjs: setLabel(objectsForCatalogSource(validGrpcCatalogSource("test-img", "")), &corev1.Service{}, ServiceHashLabelKey, "wrongHash"),
},
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
{
testName: "Grpc/ExistingRegistry/BadService",
in: in{
cluster: cluster{
k8sObjs: modifyObjName(objectsForCatalogSource(validGrpcCatalogSource("test-img", "")), &corev1.Service{}, "badName"),
},
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
{
testName: "Grpc/ExistingRegistry/BadPod",
in: in{
cluster: cluster{
k8sObjs: setLabel(objectsForCatalogSource(validGrpcCatalogSource("test-img", "")), &corev1.Pod{}, CatalogSourceLabelKey, ""),
},
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
{
testName: "Grpc/ExistingRegistry/OldPod",
in: in{
cluster: cluster{
k8sObjs: objectsForCatalogSource(validGrpcCatalogSource("old-img", "")),
},
catsrc: validGrpcCatalogSource("new-img", ""),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
{
testName: "Grpc/PrivateRegistry/SAHasSecrets",
in: in{
cluster: cluster{
k8sObjs: []runtime.Object{
&corev1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: "test-secret",
Namespace: testNamespace,
},
},
},
},
catsrc: grpcCatalogSourceWithSecret(testSecrets),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "private-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
cluster: cluster{
k8sObjs: []runtime.Object{
&corev1.ServiceAccount{
ObjectMeta: metav1.ObjectMeta{
Name: "private-catalog",
Namespace: testNamespace,
Labels: map[string]string{install.OLMManagedLabelKey: install.OLMManagedLabelValue},
OwnerReferences: []metav1.OwnerReference{
{
Name: "private-catalog",
UID: types.UID("catalog-uid"),
Kind: v1alpha1.CatalogSourceKind,
APIVersion: v1alpha1.CatalogSourceCRDAPIVersion,
BlockOwnerDeletion: &blockOwnerDeletion,
Controller: &isController,
},
},
},
ImagePullSecrets: []corev1.LocalObjectReference{
{
Name: "test-secret",
},
},
},
},
},
},
},
{
testName: "Grpc/NoExistingRegistry/CreateWithAnnotations",
in: in{
catsrc: grpcCatalogSourceWithAnnotations(map[string]string{
"annotation1": "value1",
"annotation2": "value2",
}),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
{
testName: "Grpc/ExistingRegistry/UpdateInvalidRegistryServiceStatus",
in: in{
cluster: cluster{
k8sObjs: objectsForCatalogSource(validGrpcCatalogSource("image", "")),
},
catsrc: grpcCatalogSourceWithStatus(v1alpha1.CatalogSourceStatus{
RegistryServiceStatus: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
},
}),
},
out: out{
status: &v1alpha1.RegistryServiceStatus{
CreatedAt: now(),
Protocol: "grpc",
ServiceName: "img-catalog",
ServiceNamespace: testNamespace,
Port: "50051",
},
},
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
stopc := make(chan struct{})
defer close(stopc)
factory, client := fakeReconcilerFactory(t, stopc, withNow(now), withK8sObjs(tt.in.cluster.k8sObjs...), withK8sClientOptions(clientfake.WithNameGeneration(t)))
rec := factory.ReconcilerForSource(tt.in.catsrc)
err := rec.EnsureRegistryServer(tt.in.catsrc)
require.Equal(t, tt.out.err, err)
require.Equal(t, tt.out.status, tt.in.catsrc.Status.RegistryServiceStatus)
if tt.out.err != nil {
return
}
// Check for resource existence
decorated := grpcCatalogSourceDecorator{tt.in.catsrc, runAsUser}
pod := decorated.Pod(tt.in.catsrc.GetName())
service := decorated.Service()
sa := decorated.ServiceAccount()
listOptions := metav1.ListOptions{LabelSelector: labels.SelectorFromSet(labels.Set{CatalogSourceLabelKey: tt.in.catsrc.GetName()}).String()}
outPods, podErr := client.KubernetesInterface().CoreV1().Pods(pod.GetNamespace()).List(context.TODO(), listOptions)
outService, serviceErr := client.KubernetesInterface().CoreV1().Services(service.GetNamespace()).Get(context.TODO(), service.GetName(), metav1.GetOptions{})
outsa, saerr := client.KubernetesInterface().CoreV1().ServiceAccounts(sa.GetNamespace()).Get(context.TODO(), sa.GetName(), metav1.GetOptions{})
switch rec.(type) {
case *GrpcRegistryReconciler:
// Should be created by a GrpcRegistryReconciler
require.NoError(t, podErr)
require.Len(t, outPods.Items, 1)
outPod := outPods.Items[0]
require.Equal(t, pod.GetGenerateName(), outPod.GetGenerateName())
require.Equal(t, pod.GetLabels(), outPod.GetLabels())
require.Equal(t, pod.GetAnnotations(), outPod.GetAnnotations())
require.Equal(t, pod.Spec, outPod.Spec)
require.NoError(t, serviceErr)
require.Equal(t, service, outService)
require.NoError(t, saerr)
if len(tt.in.catsrc.Spec.Secrets) > 0 {
require.Equal(t, tt.out.cluster.k8sObjs[0], outsa)
}
case *GrpcAddressRegistryReconciler:
// Should not be created by a GrpcAddressRegistryReconciler
require.NoError(t, podErr)
require.Len(t, outPods.Items, 0)
require.NoError(t, err)
require.True(t, apierrors.IsNotFound(serviceErr))
}
})
}
}
func TestRegistryPodPriorityClass(t *testing.T) {
now := func() metav1.Time { return metav1.Date(2018, time.January, 26, 20, 40, 0, 0, time.UTC) }
type cluster struct {
k8sObjs []runtime.Object
}
type in struct {
cluster cluster
catsrc *v1alpha1.CatalogSource
}
tests := []struct {
testName string
in in
priorityclass string
}{
{
testName: "Grpc/WithValidPriorityClassAnnotation",
in: in{
catsrc: grpcCatalogSourceWithAnnotations(map[string]string{
"operatorframework.io/priorityclass": "system-cluster-critical",
}),
},
priorityclass: "system-cluster-critical",
},
{
testName: "Grpc/WithInvalidPriorityClassAnnotation",
in: in{
catsrc: grpcCatalogSourceWithAnnotations(map[string]string{
"operatorframework.io/priorityclass": "",
}),
},
priorityclass: "",
},
{
testName: "Grpc/WithNoPriorityClassAnnotation",
in: in{
catsrc: grpcCatalogSourceWithAnnotations(map[string]string{
"annotationkey": "annotationvalue",
}),
},
priorityclass: "",
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
stopc := make(chan struct{})
defer close(stopc)
factory, client := fakeReconcilerFactory(t, stopc, withNow(now), withK8sObjs(tt.in.cluster.k8sObjs...), withK8sClientOptions(clientfake.WithNameGeneration(t)))
rec := factory.ReconcilerForSource(tt.in.catsrc)
err := rec.EnsureRegistryServer(tt.in.catsrc)
require.NoError(t, err)
// Check for resource existence
decorated := grpcCatalogSourceDecorator{tt.in.catsrc, runAsUser}
pod := decorated.Pod(tt.in.catsrc.GetName())
listOptions := metav1.ListOptions{LabelSelector: labels.SelectorFromSet(labels.Set{CatalogSourceLabelKey: tt.in.catsrc.GetName()}).String()}
outPods, podErr := client.KubernetesInterface().CoreV1().Pods(pod.GetNamespace()).List(context.TODO(), listOptions)
require.NoError(t, podErr)
require.Len(t, outPods.Items, 1)
outPod := outPods.Items[0]
require.Equal(t, tt.priorityclass, outPod.Spec.PriorityClassName)
require.Equal(t, pod.GetLabels()[PodHashLabelKey], outPod.GetLabels()[PodHashLabelKey])
})
}
}
func TestGrpcRegistryChecker(t *testing.T) {
type cluster struct {
k8sObjs []runtime.Object
}
type in struct {
cluster cluster
catsrc *v1alpha1.CatalogSource
}
type out struct {
healthy bool
err error
}
tests := []struct {
testName string
in in
out out
}{
{
testName: "Grpc/ExistingRegistry/Image/Healthy",
in: in{
cluster: cluster{
k8sObjs: objectsForCatalogSource(validGrpcCatalogSource("test-img", "")),
},
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
healthy: true,
},
},
{
testName: "Grpc/NoExistingRegistry/Image/NotHealthy",
in: in{
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
healthy: false,
},
},
{
testName: "Grpc/ExistingRegistry/Image/BadService",
in: in{
cluster: cluster{
k8sObjs: modifyObjName(objectsForCatalogSource(validGrpcCatalogSource("test-img", "")), &corev1.Service{}, "badName"),
},
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
healthy: false,
},
},
{
testName: "Grpc/ExistingRegistry/Image/BadServiceAccount",
in: in{
cluster: cluster{
k8sObjs: modifyObjName(objectsForCatalogSource(validGrpcCatalogSource("test-img", "")), &corev1.ServiceAccount{}, "badName"),
},
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
healthy: false,
},
},
{
testName: "Grpc/ExistingRegistry/Image/BadPod",
in: in{
cluster: cluster{
k8sObjs: setLabel(objectsForCatalogSource(validGrpcCatalogSource("test-img", "")), &corev1.Pod{}, CatalogSourceLabelKey, ""),
},
catsrc: validGrpcCatalogSource("test-img", ""),
},
out: out{
healthy: false,
},
},
{
testName: "Grpc/ExistingRegistry/Image/OldPod/NotHealthy",
in: in{
cluster: cluster{
k8sObjs: objectsForCatalogSource(validGrpcCatalogSource("old-img", "")),
},
catsrc: validGrpcCatalogSource("new-img", ""),
},
out: out{
healthy: false,
},
},
{
testName: "Grpc/NoExistingRegistry/Address/Healthy",
in: in{
catsrc: validGrpcCatalogSource("", "catalog.svc.cluster.local:50001"),
},
out: out{
healthy: true,
},
},
{
testName: "Grpc/ExistingRegistry/AddressAndImage/Healthy",
in: in{
cluster: cluster{
k8sObjs: objectsForCatalogSource(validGrpcCatalogSource("img-catalog", "catalog.svc.cluster.local:50001")),
},
catsrc: validGrpcCatalogSource("img-catalog", "catalog.svc.cluster.local:50001"),
},
out: out{
healthy: true,
},
},
{
testName: "Grpc/NoExistingRegistry/AddressAndImage/NotHealthy",
in: in{
cluster: cluster{},
catsrc: validGrpcCatalogSource("img-catalog", "catalog.svc.cluster.local:50001"),
},
out: out{
healthy: false,
},
},
{
testName: "Grpc/ExistingRegistry/AddressAndImage/BadService/NotHealthy",
in: in{
cluster: cluster{
k8sObjs: modifyObjName(objectsForCatalogSource(validGrpcCatalogSource("test-img", "catalog.svc.cluster.local:50001")), &corev1.Service{}, "badName"),
},
catsrc: validGrpcCatalogSource("test-img", "catalog.svc.cluster.local:50001"),
},
out: out{
healthy: false,
},
},
{
testName: "Grpc/ExistingRegistry/AddressAndImage/OldPod/NotHealthy",
in: in{
cluster: cluster{
k8sObjs: objectsForCatalogSource(validGrpcCatalogSource("old-img", "catalog.svc.cluster.local:50001")),
},
catsrc: validGrpcCatalogSource("new-img", "catalog.svc.cluster.local:50001"),
},
out: out{
healthy: false,
},
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
stopc := make(chan struct{})
defer close(stopc)
factory, _ := fakeReconcilerFactory(t, stopc, withK8sObjs(tt.in.cluster.k8sObjs...))
rec := factory.ReconcilerForSource(tt.in.catsrc)
healthy, err := rec.CheckRegistryServer(tt.in.catsrc)
require.Equal(t, tt.out.err, err)
if tt.out.err != nil {
return
}
require.Equal(t, tt.out.healthy, healthy)
})
}
}
func TestGetPodImageID(t *testing.T) {
var table = []struct {
description string
pod *corev1.Pod
result string
}{
{
description: "pod has status: return status",
pod: &corev1.Pod{Status: corev1.PodStatus{ContainerStatuses: []corev1.ContainerStatus{{ImageID: "xyz123"}}}},
result: "xyz123",
},
{
description: "pod has two containers: return first",
pod: &corev1.Pod{Status: corev1.PodStatus{ContainerStatuses: []corev1.ContainerStatus{
{ImageID: "xyz123"},
{ImageID: "abc456"},
}}},
result: "xyz123",
},
{
description: "pod has no status",
pod: &corev1.Pod{Status: corev1.PodStatus{}},
result: "",
},
}
for i, tt := range table {
require.Equal(t, tt.result, imageID(tt.pod), table[i].description)
}
}
func TestUpdatePodByDigest(t *testing.T) {
var table = []struct {
description string
updatePod *corev1.Pod
servingPods []*corev1.Pod
result bool
}{
{
description: "pod image ids match: not update from the registry: return false",
updatePod: &corev1.Pod{Status: corev1.PodStatus{ContainerStatuses: []corev1.ContainerStatus{{ImageID: "xyz123"}}}},
servingPods: []*corev1.Pod{{Status: corev1.PodStatus{ContainerStatuses: []corev1.ContainerStatus{{ImageID: "xyz123"}}}}},
result: false,
},
{
description: "pod image ids do not match: update on the registry: return true",
updatePod: &corev1.Pod{Status: corev1.PodStatus{ContainerStatuses: []corev1.ContainerStatus{{ImageID: "abc456"}}}},
servingPods: []*corev1.Pod{{Status: corev1.PodStatus{ContainerStatuses: []corev1.ContainerStatus{{ImageID: "xyz123"}}}}},
result: true,
},
}
for i, tt := range table {
require.Equal(t, tt.result, imageChanged(tt.updatePod, tt.servingPods), table[i].description)
}
}
|
package main
import (
"golab/packages-example/net/tcp_sticky_package/proto"
"log"
"net"
)
func main() {
conn, err := net.Dial("tcp", ":8080")
if err != nil {
log.Fatalf("Dial error:%v\n", err)
}
defer conn.Close()
for i := 0; i < 20; i++ {
msg := `Hello Golang`
data, err := proto.Encode(msg)
if err != nil {
log.Fatalf("Encode error:%v\n", err)
return
}
conn.Write(data)
// conn.Write([]byte(msg))
}
}
|
package gocrypt
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/hex"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"strconv"
"strings"
)
//FillFiles ...
func FillFiles(path string, crypttype string) []string {
var files []string
root := path
err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if !info.IsDir() {
if crypttype == "encrypt" {
if filepath.Ext(path) != ".gocrypt" {
files = append(files, path)
}
} else {
if filepath.Ext(path) == ".gocrypt" {
files = append(files, path)
}
}
}
return nil
})
if err != nil {
fmt.Println("fail")
}
return files
}
//Goencrypt ...
func Goencrypt(file string, keyString string) {
key, _ := hex.DecodeString(keyString)
plaintext, fileerror := ioutil.ReadFile(file)
if fileerror != nil || len(plaintext) == 0 {
fmt.Println(file, "error empty file")
return
}
block, err := aes.NewCipher(key)
if err != nil {
panic(err.Error())
}
aesGCM, err := cipher.NewGCM(block)
if err != nil {
panic(err.Error())
}
nonce := make([]byte, aesGCM.NonceSize())
if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
panic(err.Error())
}
ciphertext := aesGCM.Seal(nonce, nonce, plaintext, nil)
errorr := ioutil.WriteFile(file, ciphertext, 0644)
if errorr != nil {
fmt.Println(file, "ERROR")
return
}
os.Rename(file, file+".gocrypt")
fmt.Println("Encrypt successfull")
}
//Godecrypt ...
func Godecrypt(file string, keyString string) {
key, _ := hex.DecodeString(keyString)
enc, fileerror := ioutil.ReadFile(file)
if fileerror != nil {
fmt.Println(file, "error")
}
block, err := aes.NewCipher(key)
if err != nil {
panic(err.Error())
}
aesGCM, err := cipher.NewGCM(block)
if err != nil {
panic(err.Error())
}
nonceSize := aesGCM.NonceSize()
nonce, ciphertext := enc[:nonceSize], enc[nonceSize:]
plaintext, err := aesGCM.Open(nil, nonce, ciphertext, nil)
if len(plaintext) == 0 {
fmt.Println("ERROR wrong password?", file)
return
}
if err != nil {
fmt.Println(file, "ERROR")
return
}
rrorr := ioutil.WriteFile(file, plaintext, 0644)
if rrorr != nil {
fmt.Println(file, "ERROR")
return
}
res1 := strings.ReplaceAll(file, ".gocrypt", "")
os.Rename(file, res1)
fmt.Println("Decrypt successfull")
}
//GenertateSecurePassword ...
func GenertateSecurePassword(pw string) []byte {
s := strings.Split(pw, "")
if len(pw) >= 32 {
pw = strings.Join(s[:32], "")
return []byte(pw)
}
counter := 0
for len(pw) < 32 {
if counter%4 == 0 {
pw += strconv.Itoa(counter)
} else {
pw += s[counter]
}
counter++
if counter >= 9 || counter >= len(s) {
counter = 0
}
}
//fmt.Println("internal PW used: ", pw)
return []byte(pw)
}
|
package main
import (
"fmt"
"log"
"net/http"
"net/url"
)
func main() {
resp, err := http.PostForm("http://www.vipidea.dd/api/v1/login", url.Values{"username": {"18611439826"}, "password": {"111111"}})
if err != nil {
log.Fatal(err)
}
var buf []byte
defer resp.Body.Close()
n, err := resp.Body.Read(buf)
if err != nil {
log.Fatal(err)
}
fmt.Println(n)
log.Println(string(buf))
fmt.Println(resp.StatusCode)
}
|
package http_handlers
import (
"github.com/go-martini/martini"
"net/http"
)
func GetSession() func(
martini.Context,
martini.Params,
http.ResponseWriter,
*http.Request,
) {
return HttpHandler(
[]string{
AUTH_REQUIRED,
},
func(h *Http) {
h.SetResponse(
map[string]interface{}{
"key": h.session.Key,
"caches": h.session.Caches,
},
)
},
)
}
func RegisterSession() func(
martini.Context,
martini.Params,
http.ResponseWriter,
*http.Request,
) {
return HttpHandler(
[]string{
IGNORE_PAYLOAD,
},
func(h *Http) {
session := S.Signup()
h.SetResponseCreatedObject(
map[string]interface{}{
"key": session.Key,
},
)
},
)
}
|
package main
import (
"context"
"encoding/json"
"fmt"
"net/http"
"strings"
"github.com/dgrijalva/jwt-go"
)
type Middleware func(http.HandlerFunc) http.HandlerFunc
type Error struct {
Message string `json:"message"`
Description string `json:"description"`
}
func applyMiddleware(h http.HandlerFunc, m ...Middleware) http.HandlerFunc {
if len(m) < 1 {
return h
}
current := h
for i := len(m) - 1; i >= 0; i-- {
current = m[i](current)
}
return current
}
func validateToken(h http.HandlerFunc) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var er Error
if auth := r.Header.Get("Authorization"); auth != "" {
if authorizationKey := strings.SplitN(auth, " ", 2); authorizationKey[1] != "" {
authToken := authorizationKey[1]
token, _ := jwt.Parse(authToken, func(token *jwt.Token) (interface{}, error) {
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
}
return getSecretKey(), nil
})
if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
user := claims["user"]
ctx := context.WithValue(r.Context(), "user", user)
r.WithContext(ctx)
h.ServeHTTP(w, r)
return
} else {
er.Description = "Tokenmu gak valid"
}
}
} else {
er.Description = "Endi Tokenmu?"
}
w.WriteHeader(http.StatusForbidden)
json.NewEncoder(w).Encode(er)
})
}
|
package hello
var BuildNum = "undefined"
|
package p2p
import (
"context"
)
type Context struct {
context.Context
Cancel context.CancelFunc
}
func newContext(context context.Context, cancel context.CancelFunc) Context {
return Context{
Context: context,
Cancel: cancel,
}
}
|
package transport
import (
"github.com/yekhlakov/gojsonrpc/common"
)
type Http struct {
Logged
PreProcessingStages []common.Stage
PostProcessingStages []common.Stage
}
func (t *Http) PerformRequest(rc *common.RequestContext) error {
rc.ApplyPipeline(&t.PreProcessingStages)
// TODO: http processing
rc.ApplyPipeline(&t.PostProcessingStages)
return nil
}
func (t *Http) AddPreProcessingStage(stage common.Stage) {
t.PreProcessingStages = append(t.PreProcessingStages, stage)
}
func (t *Http) AddPostProcessingStage(stage common.Stage) {
t.PostProcessingStages = append(t.PostProcessingStages, stage)
}
|
package main
import "fmt"
type Person struct {
First string
Last string
Age int
Phone Phone
}
type Phone struct {
AreaCode string
Prefix string
Suffix string
}
func main() {
pt := struct {
X int
Y int
}{
X: 10,
Y: 20,
}
fmt.Println(pt)
// p := Person{
// First: "John",
// Last: "Doe",
// Age: 30,
// Phone: Phone{
// AreaCode: "123",
// Prefix: "345",
// Suffix: "0123",
// },
// }
// q := &Person{"Jane", "Doe", 25}
// fmt.Println(p.First)
// fmt.Println((*q).Age)
// fmt.Println(p)
}
|
package main
import (
"fmt"
"github.com/igor-ferreira-almeida/goarea"
)
func main() {
fmt.Println(goarea.Circle(6.0))
}
|
package decoder
import (
"encoding/json"
"errors"
"time"
"github.com/Tanibox/tania-core/src/growth/storage"
"github.com/mitchellh/mapstructure"
)
type CropActivityTypeWrapper InterfaceWrapper
func (w *CropActivityTypeWrapper) UnmarshalJSON(b []byte) error {
wrapper := InterfaceWrapper{}
err := json.Unmarshal(b, &wrapper)
if err != nil {
return err
}
mapped, ok := wrapper.Data.(map[string]interface{})
if !ok {
return errors.New("error type assertion")
}
f := mapstructure.ComposeDecodeHookFunc(
UIDHook(),
TimeHook(time.RFC3339),
CropContainerHook(),
)
switch wrapper.Name {
case storage.SeedActivityCode:
a := storage.SeedActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.MoveActivityCode:
a := storage.MoveActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.HarvestActivityCode:
a := storage.HarvestActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.DumpActivityCode:
a := storage.DumpActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.WaterActivityCode:
a := storage.WaterActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.PhotoActivityCode:
a := storage.PhotoActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.TaskCropActivityCode:
a := storage.TaskCropActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.TaskNutrientActivityCode:
a := storage.TaskNutrientActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.TaskPestControlActivityCode:
a := storage.TaskPestControlActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.TaskSafetyActivityCode:
a := storage.TaskSafetyActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
case storage.TaskSanitationActivityCode:
a := storage.TaskSanitationActivity{}
_, err := Decode(f, &mapped, &a)
if err != nil {
return err
}
w.Data = a
}
return nil
}
|
/*
Copyright © 2020 David Hu <coolbor@gmail.com>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package cmd
import (
"bytes"
"errors"
"fmt"
"log"
"net/http"
"sort"
"ssrmonitor/ssr"
"strings"
"sync"
"github.com/fatih/color"
"github.com/logrusorgru/aurora"
"github.com/rodaine/table"
"github.com/spf13/cobra"
"github.com/spf13/viper"
"github.com/vbauerster/mpb"
"github.com/vbauerster/mpb/decor"
)
// pingCmd represents the feng command
var pingCmd = &cobra.Command{
Use: "ping [ssr subscribe url]",
Short: "Ping all SSR servers and sorting them",
Long: `Ping all SSR servers and sorting them.`,
Args: func(cmd *cobra.Command, args []string) error {
c := len(args)
if c == 1 {
return nil
} else if c > 1 {
return fmt.Errorf("accepts 1 arg(s), received %d\n", c)
}
err := viper.ReadInConfig()
if err != nil {
return err
}
feedUrls := viper.GetStringSlice("urls")
if len(feedUrls) < 1 {
return errors.New("missing configuration for 'configPath'")
}
return nil
},
Run: func(cmd *cobra.Command, args []string) {
var feedURLs []string
if len(args) == 1 {
feedURLs = args
} else {
feedURLs = viper.GetStringSlice("urls")
}
for _, feedURL := range feedURLs {
feeds, err := getFengHostFeed(feedURL)
if err != nil {
cmd.PrintErrf("Error: %s\n", err)
if err := cmd.Usage(); err != nil {
return
}
}
var wg sync.WaitGroup
var ss ssr.SSRs
log.Println("pinging ...")
for _, strFeed := range feeds {
s, err := ssr.Parse(strFeed)
if err != nil {
continue
}
wg.Add(1)
go func() {
st, err := s.Ping()
if err != nil {
fmt.Println(s.EmojiFlag()+" ", aurora.Red(s.Remarks), aurora.Red(s.Server), aurora.Red(err))
} else {
if int(st.PacketLoss) == 100 {
fmt.Printf("%s "+aurora.Red("%s %s los:%d\n").String(), s.EmojiFlag()+" ", s.Remarks, s.Server, int(st.PacketLoss))
} else {
fmt.Println(s.EmojiFlag()+" ", s.Remarks, s.Server, "AvgRtt:", aurora.Green(st.AvgRtt), "StdDevRtt:", st.StdDevRtt, "los:", int(st.PacketLoss))
s.AvgRtt, s.StdDevRtt, s.PacketLoss = st.AvgRtt, st.StdDevRtt, st.PacketLoss
ss = append(ss, *s)
}
}
wg.Done()
}()
}
wg.Wait()
log.Println("sorting ...")
sort.Sort(ss)
headerFmt := color.New(color.FgGreen, color.Underline).SprintfFunc()
columnFmt := color.New(color.FgYellow).SprintfFunc()
tbl := table.New("#", "Flag", "Server", "AvgRtt", "StdDevRtt", "PacketLoss", "Remarks")
tbl.WithHeaderFormatter(headerFmt).WithFirstColumnFormatter(columnFmt).WithPadding(1)
for i, s := range ss {
tbl.AddRow(i, s.EmojiFlag(), s.Server, fmt.Sprintf("%5dms ", s.AvgRtt.Milliseconds()), s.StdDevRtt, fmt.Sprintf("%4d%%", int(s.PacketLoss)), s.Remarks)
}
tbl.Print()
}
},
}
func getFengHostFeed(url string) ([]string, error) {
fmt.Printf("Downloading...\n%s\n", url)
p := mpb.New(mpb.WithWidth(64))
var total int64
bar := p.AddBar(
total,
mpb.PrependDecorators(decor.Counters(decor.UnitKiB, "% .1f / % .1f")),
mpb.AppendDecorators(decor.Percentage()),
)
res, err := http.Get(url)
if err != nil {
return nil, err
}
buf := make([]byte, 1024)
var f bytes.Buffer
for {
n, err := res.Body.Read(buf)
if err != nil || n == 0 {
break
}
f.Write(buf[:n])
total += int64(n)
bar.SetTotal(total+1024, false)
bar.IncrBy(n)
}
bar.SetTotal(total, true)
p.Wait()
defer res.Body.Close()
strurls := ssr.Decode(f.String())
return strings.Split(strurls, "\n"), nil
}
func init() {
rootCmd.AddCommand(pingCmd)
// Here you will define your flags and configuration settings.
// Cobra supports Persistent Flags which will work for this command
// and all subcommands, e.g.:
// fengCmd.PersistentFlags().String("foo", "", "A help for foo")
// Cobra supports local flags which will only run when this command
// is called directly, e.g.:
// fengCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}
|
package internal
import (
"fmt"
"io/ioutil"
"os/exec"
"strings"
)
type Terraform struct {
init *exec.Cmd
defaultArgs []string
workdir string
states string
InitError *strings.Builder
}
func CreateTerraform(workdir string, conf string) *Terraform {
terraform := new(Terraform)
terraform.InitError = new(strings.Builder)
terraform.states = "states"
terraform.workdir = workdir
terraform.defaultArgs = make([]string, 3)
terraform.defaultArgs[0] = "-input=false"
terraform.defaultArgs[1] = "-auto-approve"
terraform.defaultArgs[2] = fmt.Sprintf("-var-file=%s", conf)
terraform.init = exec.Command("terraform", "init", "-input=false")
terraform.init.Dir = workdir
terraform.init.Stdout = ioutil.Discard
terraform.init.Stderr = terraform.InitError
return terraform
}
func (terraform *Terraform) Init() error {
terraform.InitError.Reset()
return terraform.init.Run()
}
func (terraform *Terraform) Apply(index int) (*exec.Cmd, error) {
stateArg := fmt.Sprintf("-state=%s/state-%d.tfstate", terraform.states, index)
trainingArg := fmt.Sprintf("Training=%d", index)
args := []string{"apply", "-var", trainingArg, stateArg}
args = append(args, terraform.defaultArgs...)
command := exec.Command("terraform", args...)
command.Stdout = ioutil.Discard
command.Stderr = new(strings.Builder)
command.Dir = terraform.workdir
return command, command.Start()
}
func (terraform *Terraform) Destroy(index int) (*exec.Cmd, error) {
stateArg := fmt.Sprintf("-state=%s/state-%d.tfstate", terraform.states, index)
trainingArg := fmt.Sprintf("Training=%d", index)
args := []string{"destroy", "-var", trainingArg, stateArg}
args = append(args, terraform.defaultArgs...)
command := exec.Command("terraform", args...)
command.Stdout = ioutil.Discard
command.Stderr = new(strings.Builder)
command.Dir = terraform.workdir
return command, command.Start()
}
func GetStderr(cmd *exec.Cmd) string {
if stdErr, ok := cmd.Stderr.(*strings.Builder); ok {
return stdErr.String()
}
return ""
} |
package main
import "fmt"
type vertex struct {
lat, lon float64
}
func main() {
m := make(map[string]vertex)
m["Nokia Bell Labs"] = vertex{
40.68433, -74.39967,
}
fmt.Println(m["Nokia Bell Labs"])
}
|
package rest
import (
"net/http"
"github.com/parsaakbari1209/Chatapp-oauth-api/domain"
"github.com/gin-gonic/gin"
"github.com/parsaakbari1209/Chatapp-oauth-api/service"
"github.com/parsaakbari1209/Chatapp-oauth-api/utils"
)
var (
s = service.NewOAuth()
)
func create(c *gin.Context) {
// 1. Get user_id from the request url.
userID := c.Query("user_id")
if userID == "" {
restErr := utils.BadRequest("user_id is not specified.")
c.JSON(restErr.Status, restErr)
return
}
// 2. Create access and refresh tokens.
accessToken, refreshToken, err := s.Create(userID)
if err != nil {
restErr := utils.InternalServerErr("can't operate creation.")
c.JSON(restErr.Status, restErr)
return
}
// 3. Set access and refresh tokens as cookies.
c.SetCookie("access_token", accessToken, 900, "/", "localhost", false, true)
c.SetCookie("refresh_token", refreshToken, 604800, "/", "localhost", false, true)
c.JSON(http.StatusOK, gin.H{})
return
}
func refresh(c *gin.Context) {
// 1. Get refresh token from the cookies.
refreshToken, err := c.Cookie("refresh_token")
if err != nil {
restErr := utils.BadRequest("refresh_token cookie is not set.")
c.JSON(restErr.Status, restErr)
return
}
// 2. Create new access and refresh tokens.
newAccessToken, newRefreshToken, err := s.Refresh(refreshToken)
if err != nil {
restErr := utils.BadRequest("can't operate refreshing.")
c.JSON(restErr.Status, restErr)
return
}
// 3. Override the cookies.
c.SetCookie("access_token", newAccessToken, 900, "/", "localhost", false, true)
c.SetCookie("refresh_token", newRefreshToken, 604800, "/", "localhost", false, true)
// 4. Return the results.
c.JSON(http.StatusOK, gin.H{})
return
}
func verify(c *gin.Context) {
// 1. Get access token from cookies.
accessToken, err := c.Cookie("access_token")
if err != nil {
restErr := utils.BadRequest("access_token cookie is not set.")
c.JSON(restErr.Status, restErr)
return
}
// 2. Verify the access token.
_, _, err = s.Verify(accessToken)
if err == domain.ErrParseToken {
restErr := utils.BadRequest("can't operate verification.")
c.JSON(restErr.Status, restErr)
return
}
if err == domain.ErrInvalidToken {
c.JSON(http.StatusOK, gin.H{"is_valid": false})
return
}
// 3. Return the results.
c.JSON(http.StatusOK, gin.H{"is_valid": true})
return
}
func revoke(c *gin.Context) {
// 1. Get the refresh token from cookies.
refreshToken, err := c.Cookie("refresh_token")
if err != nil {
restErr := utils.BadRequest("refresh_token cookie is not set.")
c.JSON(restErr.Status, restErr)
return
}
// 2. Get the access token from cookies.
accessToken, err := c.Cookie("access_token")
if err != nil {
restErr := utils.BadRequest("access_token cookie is not set.")
c.JSON(restErr.Status, restErr)
return
}
// 3. Revoke the tokens.
if err := s.Revoke(accessToken, refreshToken); err != nil {
restErr := utils.BadRequest("can't operate revokation.")
c.JSON(restErr.Status, restErr)
return
}
c.JSON(http.StatusOK, gin.H{"succeed": true})
return
}
|
package db
import (
"database/sql"
_ "fmt"
_ "github.com/go-sql-driver/mysql"
)
type mySQLDB struct {
db *sql.DB
}
func (d *mySQLDB) InitDB(params map[string]string) {
db, err := sql.Open("mysql", params["Username"]+":" + params["Password"] + "@tcp(" + params["Host"] + ")/"+params["Db"])
if err != nil {
panic(err.Error()) // Just for example purpose. You should use proper error handling instead of panic
}
// Open doesn't open a connection. Validate DSN data:
err = db.Ping()
if err != nil {
panic(err.Error()) // proper error handling instead of panic in your app
}
d.db = db
}
func (d *mySQLDB) ReadFromDB(id string) (string, error) {
stmt, err := d.db.Prepare("SELECT * FROM testtab WHERE id= ?")
if err != nil {
panic(err.Error())
}
var tmp1 int
var tmp2 int
var url string
err = stmt.QueryRow(id).Scan(&tmp1, &tmp2, &url)
return url, err
}
func (d *mySQLDB) AddToDB(key string, val string) {
stmt, err := d.db.Prepare("INSERT INTO testtab (url, id) VALUES(?,?)") // ? = placeholder
if err != nil {
panic(err.Error()) // proper error handling instead of panic in your app
}
_, err = stmt.Exec(key, val)
if err != nil {
panic(err.Error())
}
}
|
package auth0
import (
"regexp"
"github.com/hashicorp/terraform/helper/schema"
"github.com/hashicorp/terraform/helper/validation"
auth0 "github.com/yieldr/go-auth0"
"github.com/yieldr/go-auth0/management"
)
var ruleNameRegexp = regexp.MustCompile("^[^\\s-][\\w -]+[^\\s-]$")
func newRule() *schema.Resource {
return &schema.Resource{
Create: createRule,
Read: readRule,
Update: updateRule,
Delete: deleteRule,
Importer: &schema.ResourceImporter{
State: schema.ImportStatePassthrough,
},
Schema: map[string]*schema.Schema{
"name": {
Type: schema.TypeString,
Required: true,
ValidateFunc: validation.StringMatch(
ruleNameRegexp,
"Can only contain alphanumeric characters, spaces and '-'. "+
"Can neither start nor end with '-' or spaces."),
},
"script": {
Type: schema.TypeString,
Required: true,
},
"order": {
Type: schema.TypeInt,
Optional: true,
Computed: true,
},
"enabled": {
Type: schema.TypeBool,
Optional: true,
},
},
}
}
func createRule(d *schema.ResourceData, m interface{}) error {
c := buildRule(d)
api := m.(*management.Management)
if err := api.Rule.Create(c); err != nil {
return err
}
d.SetId(auth0.StringValue(c.ID))
return readRule(d, m)
}
func readRule(d *schema.ResourceData, m interface{}) error {
api := m.(*management.Management)
c, err := api.Rule.Read(d.Id())
if err != nil {
return err
}
d.Set("name", c.Name)
d.Set("script", c.Script)
d.Set("order", c.Order)
d.Set("enabled", c.Enabled)
return nil
}
func updateRule(d *schema.ResourceData, m interface{}) error {
c := buildRule(d)
api := m.(*management.Management)
err := api.Rule.Update(d.Id(), c)
if err != nil {
return err
}
return readRule(d, m)
}
func deleteRule(d *schema.ResourceData, m interface{}) error {
api := m.(*management.Management)
return api.Rule.Delete(d.Id())
}
func buildRule(d *schema.ResourceData) *management.Rule {
return &management.Rule{
Name: String(d, "name"),
Script: String(d, "script"),
Order: Int(d, "order"),
Enabled: Bool(d, "enabled"),
}
}
|
package controller
import (
"github.com/therecipe/qt/core"
_ "github.com/therecipe/qt/internal/examples/showcases/wallet/files/dialog/controller"
)
var ButtonController *buttonController
type buttonController struct {
core.QObject
_ func() `constructor:"init"`
_ func(string) `signal:"clicked,->(controller.Controller.Show)"`
}
func (c *buttonController) init() {
ButtonController = c
}
|
package main
import (
"fmt"
"net/http"
)
func handleRoot(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Hi there!!!")
}
func main() {
http.HandleFunc("/", handleRoot)
http.ListenAndServe(":3001", nil)
}
|
/*
It can be proven that there's exactly one string of infinite length that remain same after base64 encoding Vm0wd2QyUXlVWGxWV0d4V1YwZ...
Given a position, output the character on that position.
Your program would be run on AMD Ryzen 5 5500U@4GHz given 4GB memory and 1 minute (may decrease if RAM turns out to be hard limit). You can take input in any base, but not one number in two different bases. No multithread allowed. Largest handled range wins.
Test cases: (Position 3^k+b, 0-base. Notice that 3^0=1 so b starts at -1)
\b - 111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999
k\ 10123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
0 Vm0wd2QyUXlVWGxWV0d4V1YwZDRWMVl3WkRSV01WbDNXa1JTVjAxV2JETlhhMUpUVmpBeFYySkVUbGhoTVVwVVZtcEJlRll5U2tWV
1 0wd2QyUXlVWGxWV0d4V1YwZDRWMVl3WkRSV01WbDNXa1JTVjAxV2JETlhhMUpUVmpBeFYySkVUbGhoTVVwVVZtcEJlRll5U2tWVWJ
2 UXlVWGxWV0d4V1YwZDRWMVl3WkRSV01WbDNXa1JTVjAxV2JETlhhMUpUVmpBeFYySkVUbGhoTVVwVVZtcEJlRll5U2tWVWJHaG9UV
3 RWMVl3WkRSV01WbDNXa1JTVjAxV2JETlhhMUpUVmpBeFYySkVUbGhoTVVwVVZtcEJlRll5U2tWVWJHaG9UVlZ3VlZadGNFSmxSbGw
4 TVVwVVZtcEJlRll5U2tWVWJHaG9UVlZ3VlZadGNFSmxSbGw1VTJ0V1ZXSkhhRzlVVmxaM1ZsWmFkR05GU214U2JHdzFWVEowVjFaW
5 ZOcmFHaFNlbXhXVm0xNFlVMHhXbk5YYlVaclVqQTFSMVV5TVRSVk1rcElaSHBHVjFaRmIzZFdha1poVjBaT2NtRkhhRk5sYlhoWFZ
6 MUdVMkpWYkRaWGExcHJZVWRGZUdOSE9WZGhhMHBvVmtSS1QyUkdTbkpoUjJoVFlYcFdlbGRYZUc5aU1XUkhWMjVTVGxOSGFGQlZiV
7 djSE5WYlRGVFRWWlZlV042UmxoU2EzQmFWVmMxYjFZeFdYcGhTRXBWWVRKU1NGVnFSbUZYVm5CSVlVWk9WMVpHV2xkV2JHTjRUa2R
8 YUZwaE1YQXpWRlphY21ReFpIUmtSMmhPWVROQ1NWZFhkRk5VTVZsM1RWaEdWMkV6YUdGWlZFWjNWRVp3Umxkc1pHdFdNSEJJV1ZWa
9 V4V1JsWmhXVmROZUdFemNHaFNiVkpQVm14a00wMUdaRlZSYkdScVRWWnNOVlV5ZEd0aGJFNUdVMnhvVlZaV2NHaFdSVnBoWXpGa2R
10 aDNWbGQ0YjFFd05WZFhiazVXWVRBMWIxUldXbGRPUm1SeVZtMTBhRlpyTlVkWk1GcHpWMjFLV1ZSWWFGZFdWbkJZV2tWVmVGWXhVb
11 lhelF3Vm0xNFlWbFhUWGhqUldSVllYcFdUMVpzWXpWT1ZscHhVbTFHVjAxWGVGaFdSelZUVmpKS1NHRkdVbHBXUlZvelZsWmFZV1J
12 Y21GSGNHeGlSbkIyVm0weE1HTXdOWE5pUmxwWVlsUnNXVlZ0ZUhkbGJGbDVUbFYwVjJKVldubFdNalZMVm1zeFIyTkdRbHBsYTFwe
13 pGWVZXNXdXR0V4V25wV1Z6RkxVMGRHUjJKR1pHbFhSMmQ2VjFSS05GbFhUbGRUYmxKVFlsaFNWRlJXVm5kVFZscHlXa2h3VGxac2J
14 TldWa3AwVW14a1RsWnJjRmxXYWtsNFRVWlZkMDFXV2s5V1JWcFlWV3BPYjJOc2JGZFhiSEJzWWxWYVNGbHJXbXRoUjBWM1kwWnNWM
15 9WbXRzTkZrd1ZtRlpWa3AwVld4c1ZtRnJjSFphUjNoaFZsWkdkR1JHV2s1V01VcEpWMWQwYjFReFdYbFRibEpXWWtaYVYxbHNhRzl
16 VjBaV2RFMVVVbXhXYlhoWFZtMXpOVlpWTVhKalJXaGFUVWRvZGxadGMzaFhSMFpKVjJ4a1YxSlZXVEJYVkVvMFlUSlNXRk5yWkZka
17 tWYU1sZHNXbUZaVjA1WFVtNVNhMUpzY0U5V2JGSlhVMVphVlZOVVJsWk5hMVkwVlRKNFYxWXlTbFZpUmxwWFlsUkdkbFZyV2xabFY
18 RkdUbWxTYTNCVlZrWmFWMlF4V1hoWGJrcFlZbFZhV0ZsWWNFZFdNVkpYVm0xMFdGSXdjSHBWTWpWTFZtMUdjazVXVWxwaGExcDZXV
19 NXbFpYYUROV2FrcExVMFpXY2xwSFJsZGlTRUpaVjFod1MxSXhTWGxVYTJocFVtMW9WRlJYTVc5VU1WcHhVbXhPVTAxWGVGbFdWbWh
20 VmxaclRrWlZlVk5zYkdoU2VteFlXV3hvYjJOc1dsVlNhemxUVFZkU01WWkhlRzloVmxwWFkwaG9WMUp0VWpaVVZscExZekZhYzJGS
21 FFeFduUlRiR3hvVW0xb1dGVnVjRWRVUmxaMFRWVTVVMDFyY0VoWGEyUnZWRzFHTmxKVVFsZGlXR2hVVlhwR1NtVldVbGxoUmxacFl
22 Sm9XVlpyVmt0aFJteHhVbTEwYTFKck5YbFpWV1J2VlRKS1JtTkdiRmhXYlZGM1YxWmFZVkl4WkZsYVIwWlRZWHBXVlZaR1pIcE5Wa
23 JiRmROVm5CWVYxWmtSbVZHV2xsYVJUVlVVakpvVmxkV1pEQmtNV1JIWWtoT1ZtRXdOVkJWYlhoYVRXeFZlV042Vm1oaGVrWllWVEp
24 V1RCV2JYaGhZVEExU0ZWWWFGaFhSMmhWV1cxek1XTldWblJOVnpsWVZteHdNRlJXV2s5V1ZrcHpWMjVvVm1KVVJYZFdNRnBoWkZaR
25 xOV1dFSk1WbXBLTUZZeFduSk5WbVJZVjBkNFZWbHRkSGRXVm14VlZHdE9XRkpzU2xoWGExcExZVEF4V0ZWc2FGaGhNVnBvV1d0YVN
26 WlRZekpHU0dKR1pGZGlSM1F6Vm0weGQxTXlVWGhWV0doWVYwZFNUMVpzWkZOalZsWjBUVmM1V2xadVFsbGFSV1JIWVcxS1NWRnJhR
27 xSemxZWWtac05sWlhjRTlXVjBwWllVUk9WMkpZYUhKWk1qRlBVMGRXUjFwSGJGTlhSVVY0Vm0weGQxTnRWa1pPVldSWFYwZDRWVmx
28 VkZkSVFsaFpWRVpMVkVaVmVVMVdaRk5OYXpWSFZqSXhSMVV3TVhWaFJsWllWak5TYUZwRVJtRldNWEJIWVVkNFUyVnRlRmhXUm1SN
29 JSdlZHMUtSbU5IUmxkTlYxRjNXVlJCTVZOR1RsbGhSbVJwWWtWd1VGWnROWGRqTWs1SFZXeGtXR0V6VWxsVmJURTBWakZhZEdONlZ
30 SmpSWGhXWVd0YWNsa3hXa2RqTVZwMFlrWk9UbFpXYkRaV2FrWmhXVlpzVjFSdVVsWlhSM2hXV1ZSR2QySXhWblJsU0dSVlRWZDRNR
31 pWMnhvYVZkR1NsbFdiVEV3V1ZkV2MxcElTbUZTZW14V1dXeFdWMDVHYTNkV2JrNVhUVlp3UjFZeU5XRlpWa3BHVjIxb1lWSldjRkJ
32 WlVab1YwMVhhSHBaVkVaTFpFWldjMXBHVmxkaVJuQlpWa2QwWVZkdFZsaFdhMmhUWWtaYWNGVnROVU5PYkdSVlVXMDVVMDFXY0RCV
33 Fad1YySklRWGRXUmxwVFVUSkdSazFWVmxOaE1taGhXVlJHZDJOc1duUmxSM1JVVWpCYVNGbHJXbXRVYkVsNFVsaGtXRll6UWtoV2F
34 WlhhRVJXUmxwaFpFVXhWVkZzY0ZkaVdHaFpWbXBHYjJFeFVuTlhiR2hXWWtkb1dGUlZaRk5XUmxwRlVteHdhMDFXY0RGWGExcGhWV
35 9TRk5yWkZWaVIyaFVWbXhvUTFSV1duUk5XR1JUVFZaV05GVnNhRzlYUm1SSVpVWldWMDFIVVRCV2JGcHpWbFpPYzFSc1pGZGlSM2Q
36 Vm14V1lVVjBXbFpyY0ZoWk1GWTBWMjFXY21ORmFGWmhhMW96VlRCa1MxSXhWbk5VYkdSWFRURkdObFp0TUhkbFJUVkhZa1pvVTFkS
37 xkV1ZsWk9WbGw0VjJ0b2JGSnVRbGhXYWs1RFVrWndSVkp0ZEZkTmF6VklWako0YjJGWFJqWldiR3hZVmpOb1dGcEVSazlTTVZwWll
38 ZDBVMVF4V2xkWGJrNXFVakpvWVZacVRtOVZSbFY0VjJ0a2FrMXJXa2hXYlhocllrZEtSMkl6YkZkaVZFVjNWMVphYzFkR1ZuSlhhe
39 hSbGRUYmxKclRUTkNXRmxYZEhOT1JsSldWMnh3YTAxRVJsaFpWVnBoWVZkS2NsTnRhRmRTYkZweVZsZHplRkl4WkhWU2JGSm9UVEZ
40 VG05aFJsWnhVbTVrVTFac1ducFdWM014VmpBeFZtSjZTbGRoYTI5M1YxWmtTbVZXU2xsaFJsSllVakZLV2xkWGVGZFpWbVJIWWtoT
41 ZsaFIyaFVVakZLVmxaR1dtRlNNRFZIVmxoc2JGSXpVbGRVVjNSM1pXeFZlV1ZHVGxoaVZWWTFWbGQ0VTFZd01VZGpTSEJoVWxkU1Z
42 cHpWbXBTVmsxWGFIWldiR1JMWTJzMVdHRkdXazVTYkc5NlYxWldZVll5VG5OYVNFcHJVbTFTVDFadGRIZFhWbHB4VTFSR2FFMVdjR
43 tSMVpKV2tkd2FWSnNiM2RYYkZaclVqSkdjMU51VGxoaGEwcFdXV3RhWVZSR2JGVlJXR2hYVFdzMVNsa3dXbTloUlRGV1kwWldWMkp
44 TUZaSGRHRlpWa3B6WTBVNVdsWXpVbWhVVjNoaFpFVXhTV0ZHVWs1V1ZGWkpWbTB3TVZZeFpFaFRhMnhTWVhwc1lWbHNVa2RrYkZKM
45 FKNVZteFNWMkZHV25KalJFWldWak5DVkZacVNrdFdWa3BWVVd4d1YxSldjRmhYYTFKQ1pVWk9XRk5yYUdoU2F6VnpXV3hvYjFsV1d
46 ZE5WbkF3VlRKNGMxWnRSbkpPVmxwWFlrWndNMVJVUm1Ga1IxWkpXa1pTVjJKRmNEWldha3A2VFZkR1JrMUlaRlJXUlZwWVdXdGFTM
47 RWMFphY2xacmRHaFNiWFExVkZaYVMySkdTblJWYm5CWFlsaG9jbGxXV2twbFYwWkpXa1prYVZkSGFHOVdha3A2WlVaSmVHTkZaRmR
48 VmtWVmQxWnNVa2RYYlZaSFZXNU9ZVkp0YUhCWldIQlhZakZhV0dSSFJsUk5hMncwVmxkNGExZEhTa2hWYkVKV1lsaG9lbFJzV2xOa
49 VaYWNscEhSbE5XYmtKU1ZtMHdlRlV4WkZkaVJteHFVbTFTV1ZWdE1UUk5SbkJHVm1wQ1YxSXdjRWhaTUZKRFYyc3hSMWRZWkZkU1J
50 UldXazlYUmtwMFpVaHdWMkpVVm5KWmEyUkxVMGRTUlZSc1pFNWhhMFY0Vm1wQ2ExTXhTWGxUYTFaWVlrZFNXRlJVUWt0VlZscDBZM
51 9UMkZHU25WUmJrSldZV3R3ZGxSWGVHRmpiRnAwVW14b2FWWnJXVEJXTW5SdlV6SkdjMU5ZY0doU2JFcGhWakJvUTFkR1VuUmxSM1J
52 Um14VlRWWktVRll3V21Gak1VNXlZVVpvVjJKSVFtOVhWRXA2WlVaWmVHTkZhRk5pUlRWUFZGVldkMVpzV1hoWGJFNVNUV3hHTlZWd
53 xkRlNrbFdiR040WXpKR1YxTnVWbEppUmxwWVZGWmFkMVpHVmpaVGEzQnNVbTVDU0ZkcldtOWhWMFY2VVd4c1dGWnNTbEJXVkVwS1p
54 SkdTRTlXWkdsV1dFSlhWbTB3TVZNeFdYaFhhMXBxVWxkb1ZsbHNhRzloUm13MlUydDBWRkpyY0hwWGExcHJZVmRGZDJKNlJsZGhhM
55 llR3RXUjBWNVpVWm9XbFl6VWpKVVZWcHpZMVpPY21SR1RrNVdWRlkwVm1wSmVHTXhWWGxXYmxKc1VtMVNXRmxzVWtaTlJtUlhXa1p
56 U2tkVGJuQlhWbnBHZWxaVVFYaFdiVW8yVTJ4a2FWWkZTWHBYYkZaV1pVWkplRmRzYkdGU1ZGWllXV3hrYjFkR1pGaE5SRVpTVFZkU
57 1GWFIwNDJWbXhrVG1FelFrbFhWRUp2WXpGc1YxTnJXbGhpVjJoaFZGWmFkMVZHYTNoWGEyUnJVakJ3UjFSc1dtdGhSVEZZWkVST1Y
58 WnJUV3R3U1ZWc2FHOWhiRXAwWlVac1YwMUhhRVJWTUZwM1VsWktjbU5IZUZkaE0wSTFWakowWVZZeVJsZFhXSEJvVW01Q1dGWnFUa
59 dNR1JUV1Zad1dHUkZXbXhTYkhCNFZXMHhNR0Z0U2xaWGEyeGhVbFp3VkZaVVJtRlNNV1J4VTJ4a1RsWXhSak5XYlhCTFZXMVJkMDF
60 ZUZkV1JuTmFSbWhYVFRGS2IxWlljRXRVTVVsNFYyNVdWbUY2YkZoV2JGSlhWbXhrV0dSSGRGWk5iRnA2VmpJMVUxUnNXa1pUYkZwY
61 hSVFZteHdNRlZ0ZUd0V01rcHlVMnhhVjJKWVFreFVhMXB6VmpGT2RWTnJPVmRpU0VKWVYxZDBZVmxYVGtkWFdHUmhVbnBzY0ZSV1p
62 ZFVWM1IzVjBaVmVXTkdUbGROVm5CSFdXNXdRMVl5Um5KWGJVWmhWbFp3Y2xwR1dtRmpNVTUwWVVkc1ZGSlZjR2hXYlRCNFRVWlplR
63 pWbXBHZDFZeGNFZGFSbEpUVmtkNFdsZFdWbUZoTWtaWFZHdGFWR0pJUWxoVVZscExVa1prVjFkc2NHeFNia0pIVjJ0YWIyRkhTa2x
64 Vm10a05HVldXa2RYYlhSV1RXeGFXRlpYZUd0V01rcFZZa2M1Vm1KWVRYaFZNbmhYVjBkV1NFOVdaRmRpUnpoNVZtMHhORkV4V2xoU
65 dwR2EyTXlSa2RqUm1ST1RXMW9kbFp0Y0VOWlZsVjRXa1ZhVDFadFVsWlpiR1J2Vmtac2NtRkZUbE5OVm5CV1ZUSndRMkZGTVZkalJ
66 TkdiSEpYYm1SWFRWWndNVlZYZUVkWFJscHpWMjVLVjJGcmNFOWFWVnAzVTFaT2RHUkdUbWxXYTNBelZtMXdRMkV5U1hsV2JHUllZV
67 NTMVpXV205aE1WbDVVMnRvVlZkSGFGbFdiWGgzWTJ4cmVXTXphRmhXYkhBd1dWVmFVMVpHU2xaalJuQlhZVEZ3V0ZsVVJsWmxSbkJ
68 VkZWM1YydFdWazFXVlhoVGJHUnFVbTVDV0ZsWGRIWmtNV3hWVW10d2JGSnNjRnBaYTFwVFlWWkplV0ZJV2xkV1JVcHlWbFJHYTFZe
69 ZSc1pFNWhNMEpYVm0weE1GVXhXWGxTYmtwWVlsVmFhRlp0ZUZabFJsbDNXa1pPVkZJd1draFhhMlJ2VkdzeFJtRXpiRmRoYTFwVVZ
70 eG9WbUp1UWtkVVZWcHJWakZ3Ums5V1pFNVdhM0EyVm0weE5GUXlSbGRUYmxaU1lrVktXVlp0ZUV0VlJsWlZVbXM1VjAxWFVucFdiW
71 dOREJXUmxaaFUyMVJkMDFWYkdoU2JXaHdXVlJPUTFkc1pGaGxSbVJhVm14c05GWlhlR3RYUjBwSVZXeENWMkpZYUdoVVZWcDNWbXh
72 VmxoU01taFlWMWN4TUdReFZrZFhibEpPVm1zMWNWVnRlR0ZOUmxKWFZXdE9WV0Y2UmxoWk1GSkRXVlphVjJOR1FsZFdSVVkwV1RJe
73 5KV1ZFRjRWMGRTUlZSc2NGZFdNVXBKVm0xd1FtVkhUbk5YYmtaV1lraENUMVZxUmt0VFZsbDRWMjFHVkUxVmNIcFhhMmhIVmxkS1I
74 aGhXVlJHWVUweFVuTlhiWFJZVWpGS1NWcEZaSGRVYkZwelYxUkdWMVpGYnpCWlZFWmhVMFpPY2xkc1VtbFNNMmhaVjFjd01WRXhTW
75 lSbkJYV2xWYVlXTXlUa1phUjBaVFlsWktVRlpVUWxkVE1VNVhWMWhvVm1Fd05WaFVWM1JYVGtaWmVVNVZkRlZpUm5Bd1ZsZDRWMWR
76 ZUZSc1pGZGliRXBRVm14b1UxWnNVbGRYYms1T1RWWnNOVnBWWkVkV01ERnlZMFZvV2sxR1NsQldiRnBoVW14a2RXTkdaR2xYUjJoN
77 xaMFRsVk9WMDFXY0ZaVk1uQkRWR3hLYzJKRVRsVldiSEJvVmtSR1lWSnNaSE5oUmxaWFpXeGFNbGRyWkRSWlYwNVhWRzVLYTFKck5
78 ZGtNVXBYVW01T2FsSnRVazlWYlRWRFUyeGFkR1ZIY0U1V2JGWTFWVEowYTFaSFNraGxSbVJhWVRKU2RsWXdXbk5qTWtaSFZHMW9VM
79 9VbnBzV1ZWcVFuZGxWbGw1WlVoT1dHSlZWalJXYkdodlYyc3hSMk5HYUZwbGExcFlXWHBHZDFOSFZrZGFSMnhVVWxWd2FGWnRkR0Z
80 VmtkS1NHRkdhRmRoYXpWMlZsVmFZV05XU25Ka1JtUlhZVE5CZUZkWGRHRldNVmw1VTJ0YWFsSnNXbGhaYkdoRFZFWldObEp0UmxkT
81 xob2FGWkhlR0ZrVmtaelkwWmtWMDB5YURKWFdIQkxVekZKZUZWdVNsaGlSMmh3VldwR1MyRkdaRmhrUjBaVVRWVTFTRll5TlV0WFI
82 TnNWbE5XUlVwWVZGVmFkMVpHV1hkYVJUbFRZa1UxZVZSc1dtdGhWbVJJWVVac1YySllRa3RhVlZwS1pWWktkVlZzVW1sU2JrSlJWb
83 9WRkpzV25oV01uaFBZVlpKZUZOc2JGZFNiRXBNV1dwQmVHTXhjRWRoUjNCVFZqRktkbFpHV2xaTlZrNUhWMnRvVDFaVWJHOVZiWFJ
84 YlhoTFpXeFplV042Vm1oU2JIQXdWbGQwYzFkc1dsZGpTRnBYWVd0d1RGVnFSazlqYlZaSVVteGtUazFFVVhkV2JYQkRXVlpSZVZSd
85 ZOSFZraFBWbkJYWWtkM01GWnFTVEZVTWtaelUxaHNhRkl5YUZkWmEyUlRWa1paZDFkc1dtdE5XRUpJVmtkNFQxUnNXWGhUYWxaWFV
86 QldOVlZ0ZUd0V1JtUklZVVpXV21KVVJsUldNRnB6WXpKR1JsUnNWbE5pV0dnMFZsY3hOR0V5Um5KTlZtaFdZV3RhV0ZadWNFWk5Sb
87 VaRmhTYlhoWldrVmtSMVpXU25OWGFrSlZWbXhWTVZaVVNrdFdiR1J5WWtaYWFWZEhhRkZXYlhCTFV6Sk9jMVJ1VGxSaVIxSlBWbTE
88 VW5CV01GWkxWVlphYzFWcmRGTk5WV3cwV1RCV2ExbFdTblJoU0VKWFlrWndNMXBWV21GU01XUjBaRVphVGxKRldsbFdiVEF4VlRKS
89 xaaGExcFBXbFphVjJOc2NFZGFSMnhUVFRKb00xWnNZM2hPUm14WVUxaG9WbUpIYUU5V2JuQnpWakZzY2xkdVpFNVNiRXBYV1ZWak5
90 SlhaREZrUjFkdVNsZGlWVnB4Vm0weE5HVldXWGxPVjNSVllrVndNVlZYZUd0WFIwVjRWMjVLV2xac2NFdGFSRXBQVW0xR1IyTkZOV
91 dia3BvVW0xU2NGWnJXbUZXVmxwelZtMUdXbFl3TVRWV1IzUnpWVzFLU0ZWck9WWmhhMXBNVkZaYWEyTXhjRVZWYkhCWFlUSjNNRlp
92 VmsxcmNGcFpWVnB2VmpKR2NtRXphRnBXUlhCSVZXcEdUMk14V25OVWJXeFVVbFZ3V1ZadE1IZGxSMGwzVFVob1dHSnJXbFJaVkU1V
93 ZwM1kyeGFjMWRyWkdwTlYxSXdXbFZhVDJGV1NYcFpNMmhYWWtkUk1GbHFTa3BsUm1SeVlVWk9XRk5GU25aV1Z6QjRZakZaZUdKSVV
94 VlNiRkpvWVRCd2RsWkdaSHBsUlRWWFZtNVNiRkl6VWxoVmFrSjNVMVp3Vmxkck9WaGlWVlkwVmpKd1QxWXdNVWRqU0hCYVpXdGFXR
95 JVbXhvVjFKdGFIWlhWbHBQVW1zMVYySkdjR2hOYkVwVlZtcENZV014WkVoV2ExcHJVbTVDV0ZsdGRFdFhiR1J5Vm0xMFUwMVdjSHB
96 VDFkd1RsWnNiM2RXUmxwcVRsWmtSMWR1VG1wU1JVcG9WbXhhV21ReFduSlhhM1JyVm10YWVWWXllR0ZVYlVwelUyNXNWMkpHU2tOY
97 d4b1YySlVWa1JhVmxwaFkyeHdTV05IZUZOaVNFRjNWbXRrTUdNeFpFaFRhMmhXWW10S1YxbFhkSGRrVm5CWVpVZEdXRll3TlVkWGE
98 SldjR2hYYkZaaFZESk9jMXBJVW1wU2F6VlpWVzEwZDJSc1duUk5TR2hQVWpGR05GWXlkR3RoYkVwWVZXeHNXbUV4VlhoWk1uaFhZM
99 tTVlJzV21oTlJGWlJWbGN4TkdReFduTldXR3hyVWpOU1YxUlZVa2RYUm10M1ZXdGtWMkpWY0ZwWlZWcHZWMnhhVjFacVVsWmlSbkJ
*/
package main
import (
"bytes"
"encoding/base64"
)
func main() {
var c Gen
for i := 0; i < len(ENC); i++ {
assert(c.Next() == true)
}
assert(c.String() == ENC)
}
func assert(x bool) {
if !x {
panic("assertion failed")
}
}
type Gen struct {
buf []byte
enc []byte
}
func (c *Gen) Next() bool {
c.buf = append(c.buf, 0)
c.enc = append(c.enc, 0, 0, 0, 0)
n := len(c.buf)
for i := 0; i < 256; i++ {
c.buf[n-1] = byte(i)
base64.StdEncoding.Encode(c.enc, c.buf)
if bytes.Compare(c.buf, c.enc[:n]) == 0 {
return true
}
}
return false
}
func (c *Gen) String() string {
return string(c.buf)
}
// https://gist.github.com/epitron/4736881
const ENC = `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`
|
package main
import (
ec "crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/sha256"
"fmt"
"io"
"log"
)
/*
type Taction struct {
PrivateKey1 string //Payer
PrivateKey2 string //Payee
Amount float64
Timestamp string
}
*/
//yeah.. ill do something more secure later
//const privatekey = "5DB0633DDD43355F97CC15A190660A7453737BE343E503F8882D62D6C927C6DA"
var block_reward = 1
func generateKeys() * ec.PrivateKey {
privateKey,_ := ec.GenerateKey(elliptic.P256(), rand.Reader)
return privateKey
}
func getPublicKey (key *ec.PrivateKey) string {
pubkey := key.PublicKey.X.String() + key.PublicKey.Y.String()
return pubkey
}
func getThisPublicKey () string {
pubkey := privateKey.PublicKey.X.String() + privateKey.PublicKey.Y.String()
return pubkey
}
type tactionOut struct {
Address string
Amount float64
}
type tactionIn struct {
Address string
PrevOutId string
PrevOutIndex int
Signature string
}
type Taction struct {
ID string
TOut tactionOut
TIn tactionIn
}
func (t * Taction) SignTaction() (rs string ){
hash := sha256.New()
io.WriteString(hash, t.ID)
r, _, err := ec.Sign(rand.Reader, privateKey, hash.Sum(nil))
if err != nil {
log.Println("bad sign")
return ""
}
return r.String()
}
func (t * Taction)generateTransactionId() {
temp1 := fmt.Sprintf("%f", t.TIn.PrevOutIndex)
temp2 := fmt.Sprintf("%f", t.TOut.Amount)
t.ID = (t.TIn.PrevOutId + temp1 + t.TOut.Address + temp2)
}
type availableCoin struct {
tactionOutId string
tactionOutIndex int
address string
amount float64
}
var availableCoins []availableCoin
func (B * Block) updateNewOwnership () {
for i:=0 ; i< len(B.Transactions); i++{
newCoin := availableCoin{B.Transactions[i].ID,B.Transactions[i].TIn.PrevOutIndex,
B.Transactions[i].TOut.Address, B.Transactions[i].TOut.Amount}
availableCoins = append(availableCoins,newCoin)
//println("NEW ADDRESS OF OWNER ", B.Transactions[i].TOut.Address)
}
}
func (B* Block) deleteOldOwnership () {
for i:=0 ; i< len(B.Transactions); i++ {
temp_sum := 0.0
//newCoin := availableCoin{B.Transactions[i].ID,B.Transactions[i].TOut,
//B.Transactions[i].TOut.Address, B.Transactions[i].TOut.Amount}
for j:=0 ; j< len(availableCoins); j++ {
//so far just assuming everything is in increments of 1
if (availableCoins[j].address == B.Transactions[i].TIn.Address){
temp_sum += availableCoins[j].amount
//dirty way to delete this for now
availableCoins[j].address = "-1"
}
if (temp_sum == B.Transactions[i].TOut.Amount){
break
}
//implement finding right owner and taking away right Amount of coins,
//how to consolidate multiple availablecoin for same owners
//can implement validation
}
}
}
func findLastUnspent (address string) availableCoin {
//newCoin := availableCoin{B.Transactions[i].ID,B.Transactions[i].TOut,
//B.Transactions[i].TOut.Address, B.Transactions[i].TOut.Amount}
for j:=0 ; j< len(availableCoins); j++ {
//so far just assuming everything is in increments of 1
if (availableCoins[j].address == address){
//dirty way to delete this for now
return availableCoins[j]
}
}
return availableCoin{}
}
func showBalance (address string) {
var temp = 0.0
//newCoin := availableCoin{B.Transactions[i].ID,B.Transactions[i].TOut,
//B.Transactions[i].TOut.Address, B.Transactions[i].TOut.Amount}
for j:=0 ; j< len(availableCoins); j++ {
//so far just assuming everything is in increments of 1
if (availableCoins[j].address == address){
//dirty way to delete this for now
temp+= availableCoins[j].amount
}
}
println("This node has: " , temp)
}
//maybe implement transaction ID
//needed for checks
/*
func (t *Taction) equals(otherTaction Taction) bool {
if t.PrivateKey1 != otherTaction.PrivateKey1 {
return false
}
if t.PrivateKey2 != otherTaction.PrivateKey2 {
return false
}
if t.Amount != otherTaction.Amount {
return false
}
if t.Timestamp != otherTaction.Timestamp {
return false
}
return true
}
*/
func (t *Taction) equals(otherTaction Taction) bool {
if t.ID != otherTaction.ID {
return false
}
return true
}
func (t *Taction) isValid(payerWallet float64) bool {
if (payerWallet-t.TOut.Amount < 0) {
return false
}
return true
}
|
package leetcode
/**
* LeetCode T146. LRU缓存机制
* https://leetcode-cn.com/problems/lru-cache/
*
* 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。
* 它应该支持以下操作： 获取数据 get 和 写入数据 put 。
*/
// 参考题解 1：https://mp.weixin.qq.com/s/Q8Mg_EhDvPVRIaDv6m0Nlg
// 参考题解 2：https://leetcode-cn.com/problems/lru-cache/solution/lru-ce-lue-xiang-jie-he-shi-xian-by-labuladong/
// 方法：hash 表 + 双链表
// cache 这个数据结构必要的条件：查找快，插入快，删除快，有顺序之分。
// 在 O(1) 的时间找到节点，所以使用 hash 表
// 支持节点快速的移动、增删，所以使用双链表
// 当缓存容量已满，我们不仅仅要删除最后一个 Node 节点，还要把 map 中映射到该节点的 key 同时删除，
// 而这个 key 只能由 Node 得到。如果 Node 结构中只存储 val，那么我们就无法得知 key 是什么，就无法删除 map 中的键，造成错误。
// 这就是“为什么要在链表中同时存储 key 和 val，而不是只存储 val”
type Node struct {
key int
val int
prev *Node
next *Node
}
type LRUCache struct {
cache map[int]*Node
// 在双向链表的实现中，使用一个伪头部（dummy head）和伪尾部（dummy tail）标记界限，
// 这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在。
head *Node
tail *Node
capacity int // 容量
size int // 目前有多少元素
}
func NewLRUCache(capacity int) LRUCache {
l := LRUCache{
make(map[int]*Node),
&Node{},
&Node{},
capacity,
0,
}
l.head.next = l.tail
l.tail.prev = l.head
return l
}
func (l *LRUCache) Get(key int) int {
node, ok := l.cache[key]
if !ok {
return -1
}
// 更新访问到的节点到头部
l.moveToHead(node)
return node.val
}
func (l *LRUCache) Put(key int, value int) {
node, ok := l.cache[key]
if ok { // 如果能找到 key，把它移动到头部
node.val = value
l.moveToHead(node)
return
}
// 否则，新建一个节点
// cache 中有空位置时，可以直接加到头部
// 否则，从尾部踢掉最老的节点
node = &Node{
key: key,
val: value,
}
l.addToHead(node)
if l.size > l.capacity {
l.removeTail()
return
}
}
func (l *LRUCache) remove(node *Node) {
node.prev.next = node.next
node.next.prev = node.prev
delete(l.cache, node.key)
l.size--
}
// cache 满了以后，从尾部删除
func (l *LRUCache) removeTail() *Node {
tailNode := l.tail.prev
l.remove(tailNode)
return tailNode
}
// 新加或者访问到的元素放到头部
func (l *LRUCache) moveToHead(node *Node) {
l.remove(node) // 先删掉
l.addToHead(node) // 再加到头部
}
func (l *LRUCache) addToHead(node *Node) {
node.prev = l.head
node.next = l.head.next
l.head.next.prev = node
l.head.next = node
l.cache[node.key] = node
l.size++
}
|
package ntp
import (
"encoding/binary"
"errors"
"fmt"
"net"
"time"
"github.com/authelia/authelia/v4/internal/configuration/schema"
"github.com/authelia/authelia/v4/internal/logging"
)
// NewProvider instantiate a ntp provider given a configuration.
func NewProvider(config *schema.NTP) *Provider {
return &Provider{
config: config,
log: logging.Logger(),
}
}
// StartupCheck implements the startup check provider interface.
func (p *Provider) StartupCheck() (err error) {
var offset time.Duration
if offset, err = p.GetOffset(); err != nil {
p.log.WithError(err).Warnf("Could not determine the clock offset due to an error")
return nil
}
if offset > p.config.MaximumDesync {
return errors.New("the system clock is not synchronized accurately enough with the configured NTP server")
}
return nil
}
// GetOffset returns the current offset for this provider.
func (p *Provider) GetOffset() (offset time.Duration, err error) {
var conn net.Conn
if conn, err = net.Dial(p.config.Address.Network(), p.config.Address.NetworkAddress()); err != nil {
return offset, fmt.Errorf("error occurred during dial: %w", err)
}
defer func() {
if closeErr := conn.Close(); closeErr != nil {
p.log.WithError(err).Error("Error occurred closing connection with NTP sever")
}
}()
if err = conn.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
return offset, fmt.Errorf("error occurred setting connection deadline: %w", err)
}
version := ntpV4
if p.config.Version == 3 {
version = ntpV3
}
req := &ntpPacket{LeapVersionMode: ntpLeapVersionClientMode(version)}
if err = binary.Write(conn, binary.BigEndian, req); err != nil {
return offset, fmt.Errorf("error occurred writing ntp packet request to the connection: %w", err)
}
now := time.Now()
resp := &ntpPacket{}
if err = binary.Read(conn, binary.BigEndian, resp); err != nil {
return offset, fmt.Errorf("error occurred reading ntp packet response to the connection: %w", err)
}
ntpTime := ntpPacketToTime(resp)
return calcOffset(now, ntpTime), nil
}
|
package lnksutils
import "syscall"
// UnameMachine return the `uname -m"
func UnameMachine() string {
var uname syscall.Utsname
syscall.Uname(&uname)
arr := uname.Machine[:]
b := make([]byte, 0, len(arr))
for _, v := range arr {
if v == 0x00 {
break
}
b = append(b, byte(v))
}
return string(b)
}
|
package main
import (
"fmt"
"strconv"
)
/*
an arguments passing tester
*/
func main() {
var nums=[]int{0,1,2}
i := 0
fmt.Printf("address of int : %p\n", &i)
fmt.Printf("value of int : %d\n",i)
updatePassingInt(i)
fmt.Printf("address of int : %p\n", &i)
fmt.Printf("value of int : %d\n",i)
fmt.Println("---------------------------------------")
fmt.Printf("address of nums : %p\n", &nums)
var str string
for i,num := range nums{
str+=strconv.Itoa(num)
if i< len(nums)-1{
str+=","
}
}
fmt.Println("value of int array :"+str)
updatePassingArr(nums)
fmt.Printf("address of nums : %p\n", &nums)
var str2 string
for i,num := range nums{
str2+=strconv.Itoa(num)
if i< len(nums)-1{
str2+=","
}
}
fmt.Println("value of int array :"+str2)
}
func updatePassingArr(nums []int) {
fmt.Printf("address of int array : %p\n", &nums)
nums[1] = 3
var str string
for i,num := range nums{
str+=strconv.Itoa(num)
if i< len(nums)-1{
str+=","
}
}
fmt.Println("value of int array :"+str)
}
func updatePassingInt(i int){
fmt.Printf("address of int : %p\n", &i)
i=3
fmt.Printf("value of int : %d\n",i)
}
|
package stream
import (
"context"
"reflect"
)
func MergeChannels(ctx context.Context, bufferLen int, inCh ...chan Sample) chan []Sample {
mergedCh := make(chan []Sample, bufferLen)
go func() {
for {
v := make([]Sample, len(inCh))
selectMap := make([]int, len(inCh))
cases := make([]reflect.SelectCase, len(inCh)+1)
cases[0] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ctx.Done())}
for i, ch := range inCh {
cases[i+1] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ch)}
selectMap[i] = i
}
for len(cases) > 1 {
// create select cases, starting with one for context completion channel
chosen, value, ok := reflect.Select(cases)
if chosen == 0 || !ok {
// Done
close(mergedCh)
return
}
chIdx := selectMap[chosen-1]
v[chIdx] = value.Interface().(Sample)
cases = append(cases[:chosen], cases[chosen+1:]...)
selectMap = append(selectMap[:chosen-1], selectMap[chosen:]...)
}
mergedCh <- v
}
}()
return mergedCh
}
|
package main
import (
tl "github.com/JoelOtter/termloop"
)
// Bullet represents a bullet fired from the Ship
type Bullet struct {
*tl.Entity
IsTainted bool // If tainted, object will be removed during the next draw cycle
}
func newBullet(startX int, startY int) *Bullet {
const width, height = 1, 1
// Create the bullet
bullet := &Bullet{
Entity: tl.NewEntity(startX, startY, width, height),
}
for y := 0; y < height; y++ {
for x := 0; x < width; x++ {
bullet.SetCell(x, y, &tl.Cell{Fg: tl.RgbTo256Color(180, 180, 150), Bg: tl.ColorBlack, Ch: '='})
}
}
return bullet
}
// Draw will draw the object to the screen
func (bullet *Bullet) Draw(screen *tl.Screen) {
screenX, _ := screen.Size()
x, y := bullet.Position()
// Bullet advances!
x++
// Off screen means its no longer needed, taint it
if x >= screenX {
bullet.IsTainted = true
}
if bullet.IsTainted {
screen.Level().RemoveEntity(bullet)
return
}
bullet.SetPosition(x, y)
bullet.Entity.Draw(screen)
}
// Collide is triggered whenever the entity runs into something
func (bullet *Bullet) Collide(collision tl.Physical) {
// Check if it's evil Text we're colliding with
if _, ok := collision.(*BuzzWord); ok {
bullet.IsTainted = true
}
}
|
package main
import "fmt"
type person struct {
firstName string
lastName string
}
type secretAgent struct {
person
ltk bool
}
type human interface {
speak()
}
func bar(h human) {
switch h.(type) {
case person:
fmt.Println("Person was passed through bar")
case secretAgent:
fmt.Println("SecretAgent was passed through bar")
}
fmt.Println("Bar")
}
func (p person) speak() {
fmt.Println("Person speak")
fmt.Println(p.firstName)
}
func (sa secretAgent) speak() {
fmt.Println("SecretAgent Speak")
fmt.Println(sa.firstName)
}
func main() {
sa := secretAgent{
person: person{
firstName: "selva",
lastName: "Mohandoss",
},
ltk: true,
}
sa.speak()
bar(sa)
p1 := person{
firstName: "Selva",
lastName: "Senthilnathan",
}
bar(p1)
}
|
package yadisk
import (
"net/http"
"net/url"
"strings"
)
// Get the status of an asynchronous operation.
func (yad *yandexDisk) GetOperationStatus(operationID string, fields []string) (s *OperationStatus, e error) {
values := url.Values{}
values.Add("fields", strings.Join(fields, ","))
req, e := yad.client.request(http.MethodGet, "/disk/operations/"+operationID+"?"+values.Encode(), nil)
if e != nil {
return
}
s = new(OperationStatus)
_, e = yad.client.getResponse(req, &s)
if e != nil {
return nil, e
}
return
}
|
package main
import (
"encoding/json"
"fmt"
"github.com/hashicorp/go-version"
"github.com/pkg/errors"
"io"
"io/ioutil"
"net/http"
"os"
"sort"
)
const terraformReleaseUrl = "https://releases.hashicorp.com/terraform/index.json"
type terraformRelease struct {
Name string `json:"name"`
Versions map[string]struct {
Name string `json:"name"`
Version string `json:"version"`
Shasums string `json:"shasums"`
ShasumsSignature string `json:"shasums_signature"`
Builds []terraformBuild `json:"builds"`
} `json:"versions"`
}
type terraformBuild struct {
Name string `json:"name"`
Version string `json:"version"`
Os string `json:"os"`
Arch string `json:"arch"`
Filename string `json:"filename"`
Url string `json:"url"`
}
func returnTerraformUrlLinuxAmd64(builds []terraformBuild) (string, error) {
for _, b := range builds {
if b.Os == "linux" && b.Arch == "amd64" {
return b.Url, nil
}
}
return "", errors.Errorf("couldn't find a valid url for `linux:amd64`")
}
func downloadTerraformReleases(out io.Writer) (*terraformRelease, error) {
res, err := http.Get(terraformReleaseUrl)
if err != nil {
return nil, err
}
defer func() { _ = res.Body.Close() }()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
_, _ = fmt.Fprintf(out, "terraform releases downloaded\n")
var tfR *terraformRelease
err = json.Unmarshal(body, &tfR)
if err != nil {
return nil, err
}
return tfR, nil
}
func returnLatestTerraformVersion(tfR *terraformRelease) (string, error) {
var versions version.Collection
for k := range tfR.Versions {
v, err := version.NewVersion(k)
if err != nil {
return "", err
}
versions = append(versions, v)
}
sort.Sort(sort.Reverse(versions))
if len(versions) == 0 {
return "", errors.Errorf("no terraform versions found")
}
return versions[0].String(), nil
}
func downloadTerraformReleaseFromUrl(out io.Writer, url string) (string, error) {
_, _ = fmt.Fprintf(out, "download file from url: %s\n", url)
res, err := http.Get(url)
if err != nil {
return "", err
}
defer func() { _ = res.Body }()
zipf, err := ioutil.TempFile(os.TempDir(), "terraform-*.zip")
if err != nil {
return "", err
}
defer func() { _ = zipf.Close() }()
_, err = io.Copy(zipf, res.Body)
if err != nil {
return "", err
}
return zipf.Name(), nil
}
func downloadTerraform(out io.Writer) error {
tfR, err := downloadTerraformReleases(out)
v, err := returnLatestTerraformVersion(tfR)
_, _ = fmt.Fprintf(out, "the latest terraform release is: %s\n", v)
builds := tfR.Versions[v].Builds
if len(builds) == 0 {
return errors.Errorf("no builds found for version %s", v)
}
url, err := returnTerraformUrlLinuxAmd64(builds)
if err != nil {
return err
}
filePath, err := downloadTerraformReleaseFromUrl(out, url)
if err != nil {
return err
}
fmt.Printf("%s\n", filePath)
return nil
}
func main() {
var out io.Writer
if v := os.Getenv("DT_LOG"); v != "" {
out = os.Stdout
} else {
out = ioutil.Discard
}
if err := downloadTerraform(out); err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
os.Exit(1)
}
}
|
package resources
import (
"github.com/caos/orbos/mntr"
"github.com/caos/orbos/pkg/kubernetes"
"github.com/caos/orbos/pkg/tree"
"github.com/pkg/errors"
)
type AdaptFuncToEnsure func(monitor mntr.Monitor, desired *tree.Tree, current *tree.Tree) (QueryFunc, error)
type AdaptFuncToDelete func(monitor mntr.Monitor, desired *tree.Tree, current *tree.Tree) (DestroyFunc, error)
type EnsureFunc func(kubernetes.ClientInt) error
type DestroyFunc func(kubernetes.ClientInt) error
type QueryFunc func(kubernetes.ClientInt) (EnsureFunc, error)
func WrapFuncs(monitor mntr.Monitor, query QueryFunc, destroy DestroyFunc) (QueryFunc, DestroyFunc, error) {
return func(client kubernetes.ClientInt) (ensureFunc EnsureFunc, err error) {
monitor.Info("querying...")
ensure, err := query(client)
if err != nil {
err := errors.Wrapf(err, "error while querying")
monitor.Error(err)
return nil, err
}
monitor.Info("queried")
return func(k8sClient kubernetes.ClientInt) error {
monitor.Info("ensuring...")
if err := ensure(k8sClient); err != nil {
return errors.Wrap(err, "error while destroying")
}
monitor.Info("ensured")
return nil
}, nil
}, func(client kubernetes.ClientInt) error {
monitor.Info("destroying...")
err := destroy(client)
if err != nil {
err := errors.Wrapf(err, "error while destroying")
monitor.Error(err)
return err
}
monitor.Info("destroyed")
return nil
}, nil
}
|
// shared structs between client wrappers and server
package rpc
// aka namespace for GO RPC
type PPTRpc string
// empty args (nil isn't good)
type EmptyArgs struct{}
// arg to describe remove node params
type RemoveNodeArgs struct {
// Host to remove
Host string
}
// arg to describe status node params
type GetStatusArgs struct {
// print out errors while analyzing status
// default: false
Errors bool
}
|
package main
import (
"github.com/jinxing3114/xtrie"
)
//创建XTrie
var XT = new(xtrie.XTrie)
//基本配置信息
var storeFile,dictFile = "data/dat.data", "data/darts.txt"
/**
入口函数
*/
func main(){
XT.InitHandle(storeFile, dictFile)
//example()
//开始监听请求
startServe(":8888")
}
/**
例子
*/
func example(){
//index, level, err := XT.Match("番", false)
//fmt.Println(index, level, err)
//level, err, _, _ = dat.match("中", false)
//fmt.Println(level, err)
//sk := "我要测试一下"
//contentRune := []rune(sk)
//result := dat.search(sk)
//fmt.Println(result)
//for i:=0;i<len(result);i++{
// fmt.Println("str:", string(contentRune[result[i][0]:result[i][1] + 1]), "level", result[i][2])
//}
}
|
package pocket2rm
// APIOriginPocket contains the destination
const APIOriginPocket = "pocket"
// APIOriginMercury is the origin host for the Mercury API
const APIOriginMercury = "mercury"
// APIOriginRemarkable is the origin host for the reMarkable API
const APIOriginRemarkable = "remarkable"
// APIOrigin maps each origin host name
var APIOrigin = map[string]string{
APIOriginPocket : "https://getpocket.com",
APIOriginMercury : "https://mercury.postlight.com",
APIOriginRemarkable : "",
}
|
package db
import (
"strconv"
"strings"
"cloud.google.com/go/datastore"
"github.com/steam-authority/steam-authority/helpers"
)
type PlayerApp struct {
PlayerID int64 `datastore:"player_id"`
AppID int `datastore:"app_id,noindex"`
AppName string `datastore:"app_name"`
AppIcon string `datastore:"app_icon,noindex"`
AppTime int `datastore:"app_time"`
AppPrice int `datastore:"app_price"`
AppPriceHour float64 `datastore:"app_price_hour"`
}
func (p PlayerApp) GetKey() (key *datastore.Key) {
return datastore.NameKey(KindPlayerApp, strconv.FormatInt(p.PlayerID, 10)+"-"+strconv.Itoa(p.AppID), nil)
}
func (p PlayerApp) GetIcon() string {
if p.AppIcon == "" {
return "/assets/img/no-player-image.jpg" // todo, fix to right image
}
return "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/apps/" + strconv.Itoa(p.AppID) + "/" + p.AppIcon + ".jpg"
}
func (p PlayerApp) GetTimeNice() string {
return helpers.GetTimeShort(p.AppTime, 2)
}
func (p PlayerApp) GetPriceHourFormatted() string {
x := p.AppPriceHour
if x == -1 {
return "∞"
}
return strconv.FormatFloat(helpers.DollarsFloat(x), 'f', 2, 64)
}
func (p PlayerApp) GetPriceHourSort() string {
x := p.AppPriceHour
if x == -1 {
return "1000000"
}
return strconv.FormatFloat(helpers.DollarsFloat(x), 'f', 2, 64)
}
func (p *PlayerApp) SetPriceHour() {
if p.AppPrice == 0 {
return
}
if p.AppTime == 0 {
return
}
p.AppPriceHour = (float64(p.AppPrice) / 100) / (float64(p.AppTime) / 60)
}
func ParsePlayerAppKey(key datastore.Key) (playerID int64, appID int, err error) {
parts := strings.Split(key.Name, "-")
playerID, err = strconv.ParseInt(parts[0], 10, 64)
if err != nil {
return
}
appID, err = strconv.Atoi(parts[1])
if err != nil {
return
}
return
}
|
package router
import (
"github.com/bearname/videohost/internal/common/infrarstructure/profile"
"github.com/bearname/videohost/internal/common/infrarstructure/transport/handler"
"github.com/bearname/videohost/internal/common/infrarstructure/transport/middleware"
"github.com/bearname/videohost/internal/stream-service/app"
"github.com/bearname/videohost/internal/stream-service/infrastructure/controller"
"github.com/gorilla/mux"
httpSwagger "github.com/swaggo/http-swagger"
"net/http"
)
// @title Swagger Example API
// @version 1.0
// @description This is a sample server Petstore server.
// @termsOfService http://swagger.io/terms/
// @contact.name API Support
// @contact.url http://www.swagger.io/support
// @contact.email support@swagger.io
// @license.name Apache 2.0
// @license.url http://www.apache.org/licenses/LICENSE-2.0.html
// @host petstore.swagger.io
// @BasePath /api/v1/
func Router() http.Handler {
router := mux.NewRouter()
router.HandleFunc("/swagger/{id}", httpSwagger.Handler(httpSwagger.URL("http://localhost:8020/swagger/doc.json"))).Methods(http.MethodGet)
router.HandleFunc("/health", handler.HealthHandler).Methods(http.MethodGet)
router.HandleFunc("/ready", handler.ReadyHandler).Methods(http.MethodGet)
streamController := controller.NewStreamController(app.NewStreamService())
router.HandleFunc("/media/{videoId}/stream/", streamController.StreamHandler).Methods(http.MethodGet, http.MethodOptions)
router.HandleFunc("/media/{videoId}/{quality}/stream/", streamController.StreamHandler).Methods(http.MethodGet, http.MethodOptions)
router.HandleFunc("/media/{videoId}/{quality}/stream/{segName:index-[0-9]+.ts}", streamController.StreamHandler).Methods(http.MethodGet, http.MethodOptions)
var imgServer = http.FileServer(http.Dir("C:\\Users\\mikha\\go\\src\\videohost\\bin\\videoserver\\content"))
router.PathPrefix("/content/").Handler(http.StripPrefix("/content/", imgServer))
return middleware.LogMiddleware(profile.BuildHandlers(router))
}
|
package git
/*
#include <git2.h>
*/
import "C"
import (
"runtime"
)
type CherrypickOptions struct {
Mainline uint
MergeOptions MergeOptions
CheckoutOptions CheckoutOptions
}
func cherrypickOptionsFromC(c *C.git_cherrypick_options) CherrypickOptions {
opts := CherrypickOptions{
Mainline: uint(c.mainline),
MergeOptions: mergeOptionsFromC(&c.merge_opts),
CheckoutOptions: checkoutOptionsFromC(&c.checkout_opts),
}
return opts
}
func populateCherrypickOptions(copts *C.git_cherrypick_options, opts *CherrypickOptions, errorTarget *error) *C.git_cherrypick_options {
C.git_cherrypick_options_init(copts, C.GIT_CHERRYPICK_OPTIONS_VERSION)
if opts == nil {
return nil
}
copts.mainline = C.uint(opts.Mainline)
populateMergeOptions(&copts.merge_opts, &opts.MergeOptions)
populateCheckoutOptions(&copts.checkout_opts, &opts.CheckoutOptions, errorTarget)
return copts
}
func freeCherrypickOpts(copts *C.git_cherrypick_options) {
if copts == nil {
return
}
freeMergeOptions(&copts.merge_opts)
freeCheckoutOptions(&copts.checkout_opts)
}
func DefaultCherrypickOptions() (CherrypickOptions, error) {
c := C.git_cherrypick_options{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_cherrypick_options_init(&c, C.GIT_CHERRYPICK_OPTIONS_VERSION)
if ecode < 0 {
return CherrypickOptions{}, MakeGitError(ecode)
}
defer freeCherrypickOpts(&c)
return cherrypickOptionsFromC(&c), nil
}
func (v *Repository) Cherrypick(commit *Commit, opts CherrypickOptions) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var err error
cOpts := populateCherrypickOptions(&C.git_cherrypick_options{}, &opts, &err)
defer freeCherrypickOpts(cOpts)
ret := C.git_cherrypick(v.ptr, commit.cast_ptr, cOpts)
runtime.KeepAlive(v)
runtime.KeepAlive(commit)
if ret == C.int(ErrorCodeUser) && err != nil {
return err
}
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
func (r *Repository) CherrypickCommit(pick, our *Commit, opts CherrypickOptions) (*Index, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
cOpts := populateMergeOptions(&C.git_merge_options{}, &opts.MergeOptions)
defer freeMergeOptions(cOpts)
var ptr *C.git_index
ret := C.git_cherrypick_commit(&ptr, r.ptr, pick.cast_ptr, our.cast_ptr, C.uint(opts.Mainline), cOpts)
runtime.KeepAlive(pick)
runtime.KeepAlive(our)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newIndexFromC(ptr, r), nil
}
|
package empop
import "interfaces/slcalc"
// EmployeeOperations interface
type EmployeeOperations interface {
slcalc.LeaveCalculator
slcalc.SalaryCalculator
} |
package aoc2020
import (
"fmt"
"strconv"
"strings"
aoc "github.com/janreggie/aoc/internal"
"github.com/pkg/errors"
)
// mask represents a bitmask that can force bits to be zero or one.
type mask struct {
ones uint64
zeroes uint64
}
// newMask generates a mask object from a string of length 32
func newMask(mm string) (mask, error) {
if len(mm) != 36 {
return mask{}, errors.Errorf("could not parse %v since not length 32", mm)
}
var ones, zeroes uint64
for ii := range mm {
switch mm[ii] {
case '1':
ones += 1 << (35 - ii)
case '0':
zeroes += 1 << (35 - ii)
}
}
return mask{ones: ones, zeroes: zeroes}, nil
}
func (mm mask) String() string {
var sb strings.Builder
for ii := 0; ii < 36; ii++ {
switch mm.at(ii) {
case 1:
sb.WriteByte('1')
case 0:
sb.WriteByte('0')
default:
sb.WriteByte('X')
}
}
return sb.String()
}
// at checks the value of mm at some index.
// Returns 0, 1, or -1 (X).
// If index is oob return -2.
func (mm mask) at(ind int) int {
if ind < 0 || ind >= 36 {
return -2
}
if mm.ones|1<<(35-ind) == mm.ones {
return 1
}
if mm.zeroes|1<<(35-ind) == mm.zeroes {
return 0
}
return -1
}
// apply maps a value using the mask
func (mm mask) apply(val uint64) uint64 {
return (val | mm.ones) &^ mm.zeroes
}
// v2floaters returns a slice of uint64's that represent the possible addresses when addr is masked by mm
func (mm mask) v2floaters(addr uint64) []uint64 {
// addrAt returns addr at some index. Note that ind=0 means leftmost
addrAt := func(ind int) uint64 {
return addr & (1 << (35 - ind))
}
// recurse recurses. Note that ind=0 means leftmost
var recurse func(int) []uint64
recurse = func(ind int) []uint64 {
if ind >= 36 {
return []uint64{}
}
if ind == 35 {
switch mm.at(ind) {
case 1:
return []uint64{1}
case 0:
return []uint64{addrAt(35)}
case -1:
return []uint64{0, 1}
}
}
result := make([]uint64, 0)
switch mm.at(ind) {
case 1:
result = recurse(ind + 1)
for ii := range result {
result[ii] += 1 << (35 - ind)
}
case 0:
result = recurse(ind + 1)
aa := addrAt(ind)
for ii := range result {
result[ii] += aa
}
case -1:
result = recurse(ind + 1)
// this will not loop indefinitely
for ii := range result {
result = append(result, result[ii]+1<<(35-ind))
}
}
return result
}
return recurse(0)
}
// ferryInstruction refers to an instruction for the ferry
type ferryInstruction struct {
setMask bool // set the mask or just write to memory?
mask mask
writeAddr uint64
writeVal uint64
}
// newFerryInstruction reads from a string and evaluates the appropriate ferryInstruciton
func newFerryInstruction(instr string) (ferryInstruction, error) {
var rawMask string
if _, e := fmt.Sscanf(instr, "mask = %36s", &rawMask); e == nil {
mask, err := newMask(rawMask)
if err != nil {
return ferryInstruction{}, errors.Wrapf(err, "couldn't read mask val %s", rawMask)
}
return ferryInstruction{setMask: true, mask: mask}, nil
}
var d1, d2 uint64
if _, e := fmt.Sscanf(instr, "mem[%d] = %d", &d1, &d2); e == nil {
return ferryInstruction{
setMask: false,
writeAddr: d1,
writeVal: d2,
}, nil
}
return ferryInstruction{}, errors.Errorf("couldn't read instruction `%s`", instr)
}
// readFerryInstructions reads a slice of ferryInstruction and returns the state of the memory as a map
func readFerryInstructions(instrs []ferryInstruction) map[uint64]uint64 {
mem := make(map[uint64]uint64)
msk := mask{ones: 0, zeroes: 0} // blank mask
for _, instr := range instrs {
if instr.setMask {
msk = instr.mask
} else {
mem[instr.writeAddr] = msk.apply(instr.writeVal)
}
}
return mem
}
// readFerryV2 reads a slice of ferryInstruction in accordance to version 2.0 and returns the state of the memory as a map
func readFerryV2(instrs []ferryInstruction) map[uint64]uint64 {
mem := make(map[uint64]uint64)
msk := mask{ones: 0, zeroes: 0}
for _, instr := range instrs {
if instr.setMask {
msk = instr.mask
} else {
for _, addr := range msk.v2floaters(instr.writeAddr) {
mem[addr] = instr.writeVal
}
}
}
return mem
}
// Day14 solves the fourteenth day puzzle "Docking Data"
//
// Input
//
// An initialization program that updates the bitmask or inserts a value into memory.
// For example:
//
// mask = 1100X10X01001X111001X00010X00100X011
// mem[24821] = 349
// mem[34917] = 13006
// mem[53529] = 733
// mem[50289] = 245744
// mem[23082] = 6267
// mask = 011X1X00X100100XXXX11100X0000100X010
// mem[21316] = 14188354
// mem[53283] = 7137
// mem[57344] = 62358
// mem[63867] = 9443
//
// It is guaranteed that the mask represents a 36-bit number.
func Day14(input string) (answer1, answer2 string, err error) {
instrs := make([]ferryInstruction, 0)
for _, line := range aoc.SplitLines(input) {
instr, e := newFerryInstruction(line)
if e != nil {
err = errors.Wrapf(e, "couldn't read ferryInstructions from scanner")
return
}
instrs = append(instrs, instr)
}
mem := readFerryInstructions(instrs)
var sum uint64
for _, vv := range mem {
sum += vv
}
answer1 = strconv.FormatUint(sum, 10)
mem = readFerryV2(instrs)
sum = 0
for _, vv := range mem {
sum += vv
}
answer2 = strconv.FormatUint(sum, 10)
return
}
|
package scraper
type (
Game struct {
ID string `json:"id"`
BasePrice float32 `json:"base_price"`
PricesURLs []price `json:"prices_urls"`
}
price struct {
From string `json:"from"`
URL string `json:"url"`
}
)
|
package runner
import (
"context"
"fmt"
"os"
"path/filepath"
"time"
"github.com/chromedp/cdproto/network"
"github.com/chromedp/chromedp"
"github.com/dkorittki/loago/internal/pkg/worker/executor/browser"
"github.com/rs/zerolog/log"
)
const (
// CacheDirName is the name of the global directory used for runner caches.
CacheDirName = "loago_runner"
// Size of network event channel buffer.
networkEventChanSize = 300
)
// A ChromeRunner implements the runner interface.
// It interacts with a chrome browser via chromedp.
// See: https://github.com/chromedp/chromedp
type ChromeRunner struct {
// ID of this runner.
ID int
// Browser cache directory path.
CacheDir string
// Executor interface for interacting with a browser communication library.
Executor browser.Executor
// Buffer for storing network events received from devtools protocols.
networkEventChan chan *network.EventResponseReceived
}
// NewChromeRunner creates a new chrome runner instance.
func NewChromeRunner(id int, e browser.Executor) *ChromeRunner {
r := &ChromeRunner{
ID: id,
Executor: e,
networkEventChan: make(chan *network.EventResponseReceived, networkEventChanSize),
}
return r
}
// WithContext derives a new context from ctx associated with both a runner and
// chromedp configuration. This context can be used as a context to call the Run() method.
// It also creates a new goroutine in background waiting for the context to be closed to
// clean up ressources such as the cache dir.
func (r *ChromeRunner) WithContext(ctx context.Context) context.Context {
cachedir := filepath.Join(os.TempDir(), CacheDirName, fmt.Sprintf("%d", r.ID))
opts := append(chromedp.DefaultExecAllocatorOptions[:],
chromedp.DisableGPU,
chromedp.UserDataDir(cachedir),
)
allocCtx, _ := chromedp.NewExecAllocator(ctx, opts...)
chromedpCtx, _ := chromedp.NewContext(allocCtx)
r.CacheDir = cachedir
runnerCtx := context.WithValue(chromedpCtx, contextKey{}, r)
// Watch context and clean up browser cache once it's canceled
f := cancel(runnerCtx)
go f()
// Create a network event listener and send them into the runner buffer.
// The Call() method will read and parse from it.
r.Executor.ListenTarget(chromedpCtx, func(ev interface{}) {
if netEv, ok := ev.(*network.EventResponseReceived); ok {
if netEv.Type == network.ResourceTypeDocument {
r.networkEventChan <- netEv
}
}
})
return runnerCtx
}
func cancel(ctx context.Context) func() {
return func() {
v := FromContext(ctx)
r := v.(*ChromeRunner)
<-ctx.Done()
// close network event buffer.
close(r.networkEventChan)
log.Debug().
Str("component", "runner").
Int("id", r.ID).
Str("cachedir", r.CacheDir).
Msg("delete cache")
var err error
for i := 0; i < 10; i++ {
err = os.RemoveAll(r.CacheDir)
if err == nil {
return
}
time.Sleep(200 * time.Millisecond)
}
log.Warn().
Str("component", "runner").
Int("id", r.ID).
Err(err).
Msg("can't delete cache")
}
}
|
// Command whenchange monitors for changes on files, directories,
// and optionally watching sub-directories, and when a change
// happens, executes a command.
//
//
// Installation
//
// go get ronoaldo.gopkg.net/whenchange
//
//
// Usage
//
// whenchange -p source.go go build
//
// The above command will monitor all go files in the current
// directory for changes, and trigger go build.
//
// whenchange -p ./src/ mvn test-compile
//
// The above command will monitor recursivelly the src folder,
// and execute the maven test compile target.
package main // import "ronoaldo.gopkg.net/whenchange"
import (
"flag"
"fmt"
"log"
"os"
"os/exec"
"path"
"path/filepath"
"strings"
"sync"
"time"
"gopkg.in/fsnotify.v0"
)
var (
// List of paths to watch
patternList Patterns
// Watch directory recursively
recursive bool
// Command to execute on changes
cmd []string
// verbose options
verbose bool
// fsnotify.Watcher to monitor changes
watcher *Watcher
// Shell to use when running the command
shell string
// Delay between repeated executions of command
delaySpec string
delay time.Duration
)
// Type Patterns represents a set of paths to watch for.
type Patterns []string
// Method String implements the flags.Value interface.
func (p *Patterns) String() string {
return fmt.Sprint(*p)
}
// Method Set implements the flags.Value interface.
func (p *Patterns) Set(value string) error {
*p = append(*p, value)
return nil
}
type Watcher struct {
*fsnotify.Watcher
list map[string]time.Time
listMu sync.Mutex
}
// Watch starts monitoring a file path. It also monitors the
// directory for changes, so attribute changes are also visible.
func (w *Watcher) Watch(file string) {
w.listMu.Lock()
defer w.listMu.Unlock()
towatch := []string{file}
// Also monitors the directory, if file, so attrib changes
// and timestamp changes are visible as well.
if !IsDir(file) {
towatch = append(towatch, path.Dir(file))
}
for _, file := range towatch {
if _, ok := w.list[file]; ok {
verbosef("Path %s already in watch list", file)
return
}
verbosef("Watching [%s]", file)
err := w.Watcher.Watch(file)
if err != nil {
log.Fatal(err)
}
// To prevent ignoring the very first change, use a time machine and
// go back in time :D
w.list[file] = time.Now().Add(-5 * time.Second)
}
}
// WatchPatterns lookup all gob matches from patterns and watch them.
// If -r/--recursive is true, walks all sub-trees recursivelly.
func (w *Watcher) WatchPatterns(patterns []string) {
for _, p := range patterns {
if glob, err := filepath.Glob(p); err == nil {
for _, fname := range glob {
watcher.Watch(fname)
if recursive {
for _, s := range SubDirs(fname) {
watcher.Watch(s)
}
}
}
}
}
}
func init() {
flag.StringVar(&delaySpec, "delay", "5s", "Delay between repeated executions of command")
flag.StringVar(&delaySpec, "d", "5s", "Delay between repeated executions of command (shorthand)")
flag.BoolVar(&recursive, "recursive", true, "Watch directories recursively")
flag.BoolVar(&recursive, "r", true, "Watch directories recursively (shorthand)")
flag.BoolVar(&verbose, "verbose", false, "Output verbose information")
flag.BoolVar(&verbose, "v", false, "Output verbose information (shorthand)")
flag.Var(&patternList, "pattners", "Files and directories to watch, as a gob pattern")
flag.Var(&patternList, "p", "Files and directories to watch, as a gob pattern (shorthand)")
flag.StringVar(&shell, "shell", "bash", "The shell to use when running the command")
flag.Usage = func() {
w := os.Stderr
fmt.Fprintf(w, "Usage: whenchange [options] commands\n")
fmt.Fprintf(w, "All positional arguments will compose the resulting command to execute\n")
fmt.Fprintf(w, "Options can be:\n")
flag.PrintDefaults()
}
}
func main() {
// Parse and print help
flag.Parse()
cmd = flag.Args()
verbosef("Command to execute: %v", cmd)
var err error
fsw, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
watcher = &Watcher{Watcher: fsw, list: make(map[string]time.Time)}
defer watcher.Close()
if len(patternList) < 1 {
patternList.Set("./")
}
delay, err = time.ParseDuration(delaySpec)
if err != nil {
log.Printf("Invalid duration: %s. Using 5s instead", delaySpec)
delay = 5 * time.Second
}
verbosef("Path list %v", patternList)
watcher.WatchPatterns(patternList)
for {
select {
case ev := <-watcher.Event:
HandleEvent(ev)
case err := <-watcher.Error:
HandleError(err)
}
}
}
// Func HandleEvent monitors for changes, executes the specified command
// and keep monitoring for new folders when added.
func HandleEvent(ev *fsnotify.FileEvent) {
path := filepath.Clean(ev.Name)
if ev.IsCreate() {
// New file added, check if it matches the patterns
watcher.WatchPatterns(patternList)
return
}
// Locking, because we will change the path map
watcher.listMu.Lock()
defer watcher.listMu.Unlock()
now := time.Now()
wtime, watching := watcher.list[path]
if !watching {
return
}
if now.Sub(wtime) < delay {
verbosef("File %s changed too fast. Ignoring this change.", path)
return
}
verbosef("%s changed (%s)", path, ev)
watcher.list[path] = now
// Run command
if len(cmd) > 0 {
c := strings.Join(cmd, " ")
log.Printf("Running command '%s' ...", c)
cmd := exec.Command(shell, "-c", c)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err := cmd.Run()
if err != nil {
log.Printf("Error: %s", err)
}
log.Printf("Done.")
} else {
log.Printf("No command to run.")
}
}
func IsDir(path string) bool {
s, err := os.Stat(path)
if err != nil {
log.Printf("Unable to stat %s: %v", path, err)
return false
}
return s.IsDir()
}
// Handle any errors when they happend.
func HandleError(err error) {
log.Printf(err.Error())
}
// Given a file path, all sub directories are returned.
func SubDirs(path string) []string {
var paths []string
filepath.Walk(path, func(newPath string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
paths = append(paths, newPath)
}
return nil
})
return paths
}
func verbosef(f string, args ...interface{}) {
if verbose {
log.Printf(f, args...)
}
}
|
package main
import (
"log"
"os/exec"
"runtime"
"github.com/atotto/clipboard"
"github.com/jroimartin/gocui"
"github.com/ryo-ma/coronaui/lib"
"github.com/ryo-ma/coronaui/ui"
)
var client *lib.Client
var countryPanel *ui.CountryPanel
var textPanel *ui.TextPanel
var statusPanel *ui.StatusPanel
var searchPanel *ui.SearchPanel
var loadingPanel *ui.LoadingPanel
var cursor *ui.Cursor
func main() {
g, err := gocui.NewGui(gocui.OutputNormal)
if err != nil {
log.Panicln(err)
}
defer g.Close()
g.SetManagerFunc(layout)
client, _ = lib.NewClient()
countryPanel, _ = ui.NewCountryPanel()
textPanel, _ = ui.NewTextPanel()
statusPanel, _ = ui.NewStatusPanel()
searchPanel, _ = ui.NewSearchPanel()
loadingPanel, _ = ui.NewLoadingPanel()
cursor = &ui.Cursor{}
countries, _ := client.GetCountries()
countryPanel.Countries = countries
countryPanel.DrawView(g)
textPanel.DrawView(g)
statusPanel.DrawView(g)
textPanel.DrawText(g, &countryPanel.Countries[0])
g.SetCurrentView(countryPanel.ViewName)
if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
log.Panicln(err)
}
if err := g.SetKeybinding(countryPanel.ViewName, 'q', gocui.ModNone, quit); err != nil {
log.Panicln(err)
}
if err := g.SetKeybinding(countryPanel.ViewName, 'k', gocui.ModNone, cursorMovement(-1)); err != nil {
log.Panicln(err)
}
if err := g.SetKeybinding(countryPanel.ViewName, 'j', gocui.ModNone, cursorMovement(1)); err != nil {
log.Panicln(err)
}
if err := g.SetKeybinding(countryPanel.ViewName, 'c', gocui.ModNone, copyLineData); err != nil {
log.Panicln(err)
}
if err := g.SetKeybinding(countryPanel.ViewName, 't', gocui.ModNone, openTwitter); err != nil {
log.Panicln(err)
}
if err := g.SetKeybinding("", gocui.KeyCtrlU, gocui.ModNone, cursorMovement(-5)); err != nil {
log.Panicln(err)
}
if err := g.SetKeybinding("", gocui.KeyCtrlD, gocui.ModNone, cursorMovement(5)); err != nil {
log.Panicln(err)
}
// if err := g.SetKeybinding("", gocui.KeyCtrlF, gocui.ModNone, drawSearchEditor); err != nil {
// log.Panicln(err)
// }
// if err := g.SetKeybinding(searchPanel.ViewName, gocui.KeyEnter, gocui.ModNone, searchCountry); err != nil {
// log.Panicln(err)
// }
if err := g.SetKeybinding("", gocui.KeyArrowUp, gocui.ModNone, cursorMovement(-1)); err != nil {
log.Panicln(err)
}
if err := g.SetKeybinding("", gocui.KeyArrowDown, gocui.ModNone, cursorMovement(1)); err != nil {
log.Panicln(err)
}
if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
log.Panicln(err)
}
}
func layout(g *gocui.Gui) error {
render(g)
return nil
}
func render(g *gocui.Gui) {
countryPanel.DrawView(g)
statusPanel.DrawView(g)
textPanel.DrawView(g)
}
func cursorMovement(d int) func(g *gocui.Gui, v *gocui.View) error {
return func(g *gocui.Gui, v *gocui.View) error {
cursor.Move(g, v, d, func(yOffset int, yCurrent int) error {
if g.CurrentView().Name() == countryPanel.ViewName {
if yOffset+yCurrent >= len(countryPanel.Countries) {
return nil
}
textPanel.DrawText(g, &countryPanel.Countries[yOffset+yCurrent])
}
return nil
})
return nil
}
}
func copyLineData(g *gocui.Gui, _ *gocui.View) error {
yOffset, yCurrent, _ := cursor.FindPosition(g, countryPanel.ViewName)
currentCountry := countryPanel.Countries[yCurrent+yOffset]
err := clipboard.WriteAll(currentCountry.ToJSON())
if err != nil {
statusPanel.DrawText(g, "Failed to copy. Please copy \033[32m"+currentCountry.ToJSON()+"033[0m")
return nil
}
statusPanel.DrawText(g, "\033[32mCopied successfully JSON data!\033[0m")
return nil
}
func openTwitter(g *gocui.Gui, _ *gocui.View) error {
yOffset, yCurrent, _ := cursor.FindPosition(g, countryPanel.ViewName)
currentCountry := countryPanel.Countries[yCurrent+yOffset]
url := "http://twitter.com/share?url=https://github.com/ryo-ma/coronaui&text=COVID-19 Information" + currentCountry.String() + "&hashtags=coronaui"
var err error
switch runtime.GOOS {
case "linux":
err = exec.Command("xdg-open", url).Start()
case "windows":
err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
case "darwin":
err = exec.Command("open", url).Start()
default:
statusPanel.DrawText(g, "Failed to open URL. Unsupported platform.")
}
if err != nil {
statusPanel.DrawText(g, "Failed to open Twitter.")
}
statusPanel.DrawText(g, "\033[32mSuccess to open Twitter.\033[0m")
return nil
}
func drawSearchEditor(g *gocui.Gui, _ *gocui.View) error {
err := searchPanel.DrawView(g)
if err != nil {
return err
}
return nil
}
func searchCountry(g *gocui.Gui, v *gocui.View) error {
topic, _ := v.Line(0)
if topic == "" {
g.DeleteView(searchPanel.ViewName)
g.SetCurrentView(countryPanel.ViewName)
return nil
}
vr, err := g.View(countryPanel.ViewName)
if err != nil {
return err
}
//g.DeleteView(searchPanel.ViewName)
//loadingPanel.ShowLoading(g, func() {
// countryPanel.Result, err = client.Searchcountry(topic)
// if err != nil {
// statusPanel.DrawText(g, "Failed to search repositories.")
// } else {
// vr.Clear()
// vr.Title = " Search [" + topic + "]"
// countryPanel.Result.Draw(vr)
// g.SetCurrentView(countryPanel.ViewName)
// if len(countryPanel.Result.Items) != 0 {
// textPanel.DrawText(g, &countryPanel.Result.Items[0])
// }
// }
//})
cursor.MoveToFirst(g, vr)
return nil
}
func exit(g *gocui.Gui, v *gocui.View) error {
if v.Name() == textPanel.ViewName {
cursor.MoveToFirst(g, v)
v.Highlight = false
g.SetCurrentView(countryPanel.ViewName)
}
return nil
}
func quit(g *gocui.Gui, v *gocui.View) error {
return gocui.ErrQuit
}
|
package lambdas_test
import (
"errors"
"testing"
"github.com/life4/genesis/lambdas"
"github.com/matryer/is"
)
func panics(is *is.I, f func()) {
defer func() {
r := recover()
is.True(r != nil)
}()
f()
}
func TestMust(t *testing.T) {
is := is.New(t)
f := func() (int, error) { return 13, nil }
res := lambdas.Must(f())
is.Equal(res, 13)
f = func() (int, error) { return 13, errors.New("oh no") }
panics(is, func() { lambdas.Must(f()) })
}
func TestEnsure(t *testing.T) {
f := func() error { return nil }
lambdas.Ensure(f())
is := is.New(t)
f = func() error { return errors.New("oh no") }
panics(is, func() { lambdas.Ensure(f()) })
}
func TestSafe(t *testing.T) {
is := is.New(t)
f1 := func() (int, error) { return 13, nil }
is.Equal(lambdas.Safe(f1()), 13)
f2 := func() (int, error) { return 13, errors.New("hi") }
is.Equal(lambdas.Safe(f2()), 0)
}
func TestDefaultTo(t *testing.T) {
is := is.New(t)
f1 := func() (int, error) { return 13, nil }
is.Equal(lambdas.DefaultTo(4)(f1()), 13)
f2 := func() (int, error) { return 13, errors.New("hi") }
is.Equal(lambdas.DefaultTo(4)(f2()), 4)
}
|
package main
import "fmt"
func RequestEbay(config conf) []string {
fmt.Println("Checking ebay ...")
results := []string{"www.ebay.de/0", "www.ebay.de/1"}
return results
}
|
package isaac
const (
eventsBasePath = "/api/v1/events"
)
type EventsService interface {
Add(NewEvent) (Event, error)
Get(ID) (Event, error)
List() ([]Event, error)
Remove(Event) error
Update(Event) (Event, error)
}
type EventsServiceOp struct {
client *Client
}
type NewEvent struct {
DisplayName string `json:"displayName"`
Description string `json:"description"`
SubsystemExternalID string `json:"subsystemExternalId"`
ExternalRef string `json:"externalRef"`
Command string `json:"command"`
}
type Event struct {
NewEvent `json:",inline"`
ID ID `json:"_id"`
SubsystemID ID `json:"subsystemId"`
}
func (item Event) ref() string {
return item.ID.String()
}
func (s *EventsServiceOp) Add(alert NewEvent) (Event, error) {
var respStruct Event
err := s.client.genericPost(eventsBasePath, alert, &respStruct)
return respStruct, err
}
func (s *EventsServiceOp) Get(id ID) (Event, error) {
var respStruct Event
err := s.client.genericGetID(eventsBasePath, id, &respStruct)
return respStruct, err
}
func (s *EventsServiceOp) List() ([]Event, error) {
var respStruct []Event
err := s.client.genericGet(eventsBasePath, &respStruct)
return respStruct, err
}
func (s *EventsServiceOp) Remove(alert Event) error {
err := s.client.genericDeleteID(eventsBasePath, alert, nil)
return err
}
func (s *EventsServiceOp) Update(alert Event) (Event, error) {
var respStruct Event
err := s.client.genericPutID(eventsBasePath, alert, &respStruct)
return respStruct, err
}
|
package cmd
import (
"context"
"github.com/abilioesteves/metrics-generator/generator"
"github.com/abilioesteves/metrics-generator/hook"
"github.com/abilioesteves/metrics-generator/metrics"
"github.com/labbsr0x/goh/gohcmd"
)
func Run() {
ctx, cancel := context.WithCancel(context.Background())
g := generator.NewGeneratorTabajara(metrics.Init(), generator.GetDefaultEntropy())
go g.Init(ctx) // fire metrics generator
go hook.NewDefaultHook(g).Init() // fire webhook
go gohcmd.GracefulStop(cancel)
select {} // keep-alive magic
}
|
package main
import (
"context"
"encoding/json"
"io/ioutil"
"log"
"os"
"os/signal"
"strings"
"sync"
"github.com/chromedp/cdproto/cdp"
"github.com/chromedp/cdproto/network"
"github.com/chromedp/chromedp"
)
func main() {
if len(os.Args) != 2 {
log.Fatalln("provide a url or JSON file to download")
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
var downloadURLs []DownloadURL
if strings.HasPrefix(os.Args[1], "http://") || strings.HasPrefix(os.Args[1], "https://") {
var err error
downloadURLs, err = collectDownloadURLs(ctx, os.Args[1])
if err != nil {
log.Fatalf("fail to collect download urls: %v", err)
}
bs, err := json.MarshalIndent(downloadURLs, "", " ")
if err != nil {
log.Fatalf("fail to marshal json: %v", err)
}
if err := ioutil.WriteFile(downloadURLs[0].Title+".json", bs, 0644); err != nil {
log.Fatalf("fail to write file: %v", err)
}
} else {
bs, err := ioutil.ReadFile(os.Args[1])
if err != nil {
log.Fatalf("fail to read file: %v", err)
}
if err := json.Unmarshal(bs, &downloadURLs); err != nil {
log.Fatalf("fail to unmarshal json: %v", err)
}
}
svr := NewServer(downloadURLs)
go func() {
log.Print("listening " + svr.URL())
if err := svr.Start(); err != nil {
log.Printf("fail to start server: %v", err)
}
}()
go func() {
dpCtx, cancel := newChromedp(ctx, false)
defer cancel()
if err := chromedp.Run(dpCtx, chromedp.Navigate(svr.URL())); err != nil {
log.Printf("fail to open server url: %v", err)
}
<-ctx.Done()
}()
download(ctx, downloadURLs, 5)
signChan := make(chan os.Signal, 1)
signal.Notify(signChan, os.Interrupt)
<-signChan
}
func download(ctx context.Context, downloadURLs []DownloadURL, nParallel int) {
var wg sync.WaitGroup
downloadingChan := make(chan bool, nParallel)
for _, du := range downloadURLs {
wg.Add(1)
downloadingChan <- true
go func(du DownloadURL) {
if err := du.Download(ctx); err != nil {
log.Fatalf("fail to download %s: %v", du.Title, err)
}
<-downloadingChan
wg.Done()
}(du)
}
wg.Wait()
close(downloadingChan)
}
func collectDownloadURLs(ctx context.Context, startURL string) ([]DownloadURL, error) {
var (
baseURL = strings.Split(startURL, ".com/")[0] + ".com"
mp4URLChan = make(chan string, 2)
titleChan = make(chan string, 2)
quit = make(chan struct{})
downloadURLs []DownloadURL
)
ctx, cancel := newChromedp(ctx, true)
defer cancel()
chromedp.ListenTarget(ctx, func(ev interface{}) {
switch ev := ev.(type) {
case *network.EventRequestWillBeSent:
url := ev.Request.URL
if strings.HasSuffix(url, ".m3u8") {
mp4URLChan <- url
}
}
})
sendTitle := chromedp.ActionFunc(func(ctx context.Context) error {
var title string
if err := chromedp.Text(".video-title > h1", &title, chromedp.NodeVisible).Do(ctx); err != nil {
return err
}
title = strings.TrimRight(title, " 正在观看")
titleChan <- title
return nil
})
appendDownloadURL := func(url string) chromedp.Action {
return chromedp.ActionFunc(func(ctx context.Context) error {
downloadURLs = append(downloadURLs, DownloadURL{
URL: url,
Title: <-titleChan,
Mp4URL: <-mp4URLChan,
})
return nil
})
}
var nodes []*cdp.Node
err := chromedp.Run(ctx,
network.Enable(),
chromedp.Navigate(startURL),
sendTitle,
appendDownloadURL(startURL),
chromedp.Nodes(".play-list > .zhwli_1 > a", &nodes, chromedp.AtLeast(0)),
chromedp.ActionFunc(func(ctxt context.Context) error {
var playURLs []string
for _, node := range nodes {
playURL := baseURL + node.AttributeValue("href")
if playURL == startURL {
continue
}
playURLs = append(playURLs, playURL)
}
go func() {
for _, playURL := range playURLs {
_ = appendDownloadURL(playURL).Do(ctxt)
}
close(mp4URLChan)
close(quit)
}()
for _, playURL := range playURLs {
if err := (chromedp.Tasks{chromedp.Navigate(playURL), sendTitle}).Do(ctxt); err != nil {
return err
}
}
return nil
}),
)
if err != nil {
return nil, err
}
<-quit
return downloadURLs, nil
}
func newChromedp(ctx context.Context, headless bool) (context.Context, context.CancelFunc) {
var opts []chromedp.ExecAllocatorOption
for _, opt := range chromedp.DefaultExecAllocatorOptions {
opts = append(opts, opt)
}
if !headless {
opts = append(opts,
chromedp.Flag("headless", false),
chromedp.Flag("hide-scrollbars", false),
chromedp.Flag("mute-audio", false),
)
}
allocCtx, allocCancel := chromedp.NewExecAllocator(ctx, opts...)
ctx, cancel := chromedp.NewContext(allocCtx, chromedp.WithLogf(log.Printf))
return ctx, func() {
cancel()
allocCancel()
}
}
|
// Copyright 2016-2019 Alex Stocks, Wongoo
//
// 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 hessian
import (
"io"
"reflect"
)
import (
perrors "github.com/pkg/errors"
)
/////////////////////////////////////////
// List
/////////////////////////////////////////
// # list/vector
// ::= x55 type value* 'Z' # variable-length list
// ::= 'V' type int value* # fixed-length list
// ::= x57 value* 'Z' # variable-length untyped list
// ::= x58 int value* # fixed-length untyped list
// ::= [x70-77] type value* # fixed-length typed list
// ::= [x78-7f] value* # fixed-length untyped list
func (e *Encoder) encUntypedList(v interface{}) error {
var (
err error
)
value := reflect.ValueOf(v)
// check ref
if n, ok := e.checkRefMap(value); ok {
e.buffer = encRef(e.buffer, n)
return nil
}
value = UnpackPtrValue(value)
e.buffer = encByte(e.buffer, BC_LIST_FIXED_UNTYPED) // x58
e.buffer = encInt32(e.buffer, int32(value.Len()))
for i := 0; i < value.Len(); i++ {
if err = e.Encode(value.Index(i).Interface()); err != nil {
return err
}
}
return nil
}
/////////////////////////////////////////
// List
/////////////////////////////////////////
// # list/vector
// ::= x55 type value* 'Z' # variable-length list
// ::= 'V' type int value* # fixed-length list
// ::= x57 value* 'Z' # variable-length untyped list
// ::= x58 int value* # fixed-length untyped list
// ::= [x70-77] type value* # fixed-length typed list
// ::= [x78-7f] value* # fixed-length untyped list
func (d *Decoder) readBufByte() (byte, error) {
var (
err error
buf [1]byte
)
_, err = io.ReadFull(d.reader, buf[:1])
if err != nil {
return 0, perrors.WithStack(err)
}
return buf[0], nil
}
func listFixedTypedLenTag(tag byte) bool {
return tag >= _listFixedTypedLenTagMin && tag <= _listFixedTypedLenTagMax
}
// Include 3 formats:
// list ::= x55 type value* 'Z' # variable-length list
// ::= 'V' type int value* # fixed-length list
// ::= [x70-77] type value* # fixed-length typed list
func typedListTag(tag byte) bool {
return tag == BC_LIST_FIXED || tag == BC_LIST_VARIABLE || listFixedTypedLenTag(tag)
}
func listFixedUntypedLenTag(tag byte) bool {
return tag >= _listFixedUntypedLenTagMin && tag <= _listFixedUntypedLenTagMax
}
// Include 3 formats:
// ::= x57 value* 'Z' # variable-length untyped list
// ::= x58 int value* # fixed-length untyped list
// ::= [x78-7f] value* # fixed-length untyped list
func untypedListTag(tag byte) bool {
return tag == BC_LIST_FIXED_UNTYPED || tag == BC_LIST_VARIABLE_UNTYPED || listFixedUntypedLenTag(tag)
}
//decList read list
func (d *Decoder) decList(flag int32) (interface{}, error) {
var (
err error
tag byte
)
if flag != TAG_READ {
tag = byte(flag)
} else {
tag, err = d.readByte()
if err != nil {
return nil, perrors.WithStack(err)
}
}
switch {
case tag == BC_NULL:
return nil, nil
case tag == BC_REF:
return d.decRef(int32(tag))
case typedListTag(tag):
return d.readTypedList(tag)
case untypedListTag(tag):
return d.readUntypedList(tag)
default:
return nil, perrors.Errorf("error list tag: 0x%x", tag)
}
}
// readTypedList read typed list
// Include 3 formats:
// list ::= x55 type value* 'Z' # variable-length list
// ::= 'V' type int value* # fixed-length list
// ::= [x70-77] type value* # fixed-length typed list
func (d *Decoder) readTypedList(tag byte) (interface{}, error) {
listTyp, err := d.decString(TAG_READ)
if err != nil {
return nil, perrors.Errorf("error to read list type[%s]: %v", listTyp, err)
}
isVariableArr := tag == BC_LIST_VARIABLE
length := -1
if listFixedTypedLenTag(tag) {
length = int(tag - _listFixedTypedLenTagMin)
} else if tag == BC_LIST_FIXED {
ii, err := d.decInt32(TAG_READ)
if err != nil {
return nil, perrors.WithStack(err)
}
length = int(ii)
} else if isVariableArr {
length = 0
} else {
return nil, perrors.Errorf("error typed list tag: 0x%x", tag)
}
// return when no element
if length < 0 {
return nil, nil
}
arr := make([]interface{}, length)
aryValue := reflect.ValueOf(arr)
holder := d.appendRefs(aryValue)
for j := 0; j < length || isVariableArr; j++ {
it, err := d.DecodeValue()
if err != nil {
if err == io.EOF && isVariableArr {
break
}
return nil, perrors.WithStack(err)
}
if isVariableArr {
if it != nil {
aryValue = reflect.Append(aryValue, EnsureRawValue(it))
} else {
aryValue = reflect.Append(aryValue, NilValue)
}
holder.change(aryValue)
} else {
arr[j] = it
}
}
return holder, nil
}
//readUntypedList read untyped list
// Include 3 formats:
// ::= x57 value* 'Z' # variable-length untyped list
// ::= x58 int value* # fixed-length untyped list
// ::= [x78-7f] value* # fixed-length untyped list
func (d *Decoder) readUntypedList(tag byte) (interface{}, error) {
isVariableArr := tag == BC_LIST_VARIABLE_UNTYPED
var length int
if listFixedUntypedLenTag(tag) {
length = int(tag - _listFixedUntypedLenTagMin)
} else if tag == BC_LIST_FIXED_UNTYPED {
ii, err := d.decInt32(TAG_READ)
if err != nil {
return nil, perrors.WithStack(err)
}
length = int(ii)
} else if isVariableArr {
length = 0
} else {
return nil, perrors.Errorf("error untyped list tag: %x", tag)
}
ary := make([]interface{}, length)
aryValue := reflect.ValueOf(ary)
holder := d.appendRefs(aryValue)
for j := 0; j < length || isVariableArr; j++ {
it, err := d.DecodeValue()
if err != nil {
if err == io.EOF && isVariableArr {
break
}
return nil, perrors.WithStack(err)
}
if isVariableArr {
if it != nil {
aryValue = reflect.Append(aryValue, EnsureRawValue(it))
} else {
aryValue = reflect.Append(aryValue, NilValue)
}
holder.change(aryValue)
} else {
ary[j] = it
}
}
return holder, nil
}
|
/*
Copyright 2018-2020, Arm Limited and affiliates.
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 offlinemanager
import (
"context"
"fmt"
"io"
"time"
"github.com/golang/glog"
"k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/watch"
"k8s.io/apiserver/pkg/storage"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/tools/cache"
"k8s.io/kube-openapi/pkg/util/sets"
)
const (
NoWatchPollInterval = time.Minute * 5
BackoffStart = time.Second * 1
BackoffMax = time.Minute * 5
)
type Subset struct {
Name string
Set fields.Set
}
func (d Subset) String() string {
return d.Name + "/" + d.Set.String()
}
type depEntry struct {
count uint32
set Subset
}
type Dependencies map[string]*depEntry
func (d *Dependencies) get(group Subset) *depEntry {
if *d == nil {
*d = map[string]*depEntry{}
}
return (*d)[group.String()]
}
func (d *Dependencies) Add(group Subset) {
e := d.get(group)
if e == nil {
e = &depEntry{
set: group,
count: 0,
}
(*d)[group.String()] = e
}
e.count++
}
func (d *Dependencies) Remove(group Subset) bool {
e := d.get(group)
if e == nil {
return false
}
e.count--
if e.count <= 0 {
delete(*d, group.String())
}
return true
}
func (d *Dependencies) Count(group Subset) uint32 {
m := d.get(group)
if m == nil {
return 0
}
return m.count
}
func (d *Dependencies) Has(group Subset) bool {
m := d.get(group)
if m == nil {
return false
}
return true
}
func (d *Dependencies) GetAll() []Subset {
ret := []Subset{}
for _, subset := range *d {
ret = append(ret, subset.set)
}
return ret
}
type DependenciesFunc func(obj runtime.Object) ([]Subset, error)
type ResourceInfo struct {
// Resource "NAME" as returned by 'kubectl api-resources'.
// Example: pods
Name string
// Resource "KIND" as returned by 'kubectl api-resources'.Same as 'kind' used in yaml files.
// Example: Pod
Kind string
Namespaced bool
WatchNotAllowed bool
GetAttr storage.AttrFunc
GetDependencies DependenciesFunc
}
var SupportedResources []ResourceInfo = []ResourceInfo{
{
Kind: "Pod",
Name: "pods",
Namespaced: true,
GetAttr: UnstructuredGetAttr("Pod"),
GetDependencies: GetUnstructuredPodDeps,
},
{
Name: "nodes",
Kind: "Node",
Namespaced: false,
GetAttr: UnstructuredGetAttr("Node"),
},
{
Name: "configmaps",
Kind: "ConfigMap",
Namespaced: true,
GetAttr: UnstructuredGetAttr("ConfigMap"),
},
{
Name: "secrets",
Kind: "Secret",
Namespaced: true,
GetAttr: UnstructuredGetAttr("Secret"),
},
{
Name: "persistentvolumeclaims",
Kind: "PersistentVolumeClaim",
Namespaced: true,
WatchNotAllowed: true,
GetAttr: UnstructuredGetAttr("PersistentVolumeClaim"),
GetDependencies: GetUnstructuredPVCDeps,
},
{
Name: "persistentvolumes",
Kind: "PersistentVolume",
Namespaced: false,
WatchNotAllowed: true,
GetAttr: UnstructuredGetAttr("PersistentVolume"),
},
{
Name: "services",
Kind: "Service",
Namespaced: true,
GetAttr: UnstructuredGetAttr("Service"),
},
}
func GetUnstructuredPodDeps(obj runtime.Object) ([]Subset, error) {
var deps []Subset
// Check parameters
us, ok := obj.(*unstructured.Unstructured)
if !ok {
glog.Error("Unsupported object type")
return nil, fmt.Errorf("Unsupported object type '%T'", obj)
}
if us.GetKind() != "Pod" {
glog.Error("Wrong object type")
return nil, fmt.Errorf("Wrong object type '%T'", obj)
}
// Extract volumes
volumes, found, err := unstructured.NestedSlice(us.Object, "spec", "volumes")
if err != nil {
glog.Error("Invalid object")
return nil, err
} else if !found {
return []Subset{}, nil
}
// Create a dependency for each volume
for _, rawVolume := range volumes {
volume, ok := rawVolume.(map[string]interface{})
if !ok {
glog.Errorf("Volume type '%T' is not a map type", rawVolume)
continue
}
if name, found, err := unstructured.NestedString(volume, "configMap", "name"); err != nil {
glog.Errorf("Error retrieving volume.configMap.name")
} else if found {
deps = append(deps, Subset{
Name: "configmaps",
Set: fields.Set{
"metadata.name": name,
"metadata.namespace": us.GetNamespace(),
},
})
}
if name, found, err := unstructured.NestedString(volume, "secret", "secretName"); err != nil {
glog.Errorf("Error retrieving volume.secret.secretName")
} else if found {
deps = append(deps, Subset{
Name: "secrets",
Set: fields.Set{
"metadata.name": name,
"metadata.namespace": us.GetNamespace(),
},
})
}
if name, found, err := unstructured.NestedString(volume, "persistentVolumeClaim", "claimName"); err != nil {
glog.Errorf("Error retrieving volume.persistentVolumeClaim.claimName")
} else if found {
deps = append(deps, Subset{
Name: "persistentvolumeclaims",
Set: fields.Set{
"metadata.name": name,
"metadata.namespace": us.GetNamespace(),
},
})
}
}
for _, dep := range deps {
glog.V(9).Infof("Resource 'pods/%v/%v' has dependency on '%v'", us.GetNamespace(), us.GetName(), dep)
}
return deps, nil
}
func GetUnstructuredPVCDeps(obj runtime.Object) ([]Subset, error) {
// Check parameters
us, ok := obj.(*unstructured.Unstructured)
if !ok {
glog.Error("Unsupported object type")
return nil, fmt.Errorf("Unsupported object type '%T'", obj)
}
if us.GetKind() != "PersistentVolumeClaim" {
glog.Error("Wrong object type")
return nil, fmt.Errorf("Wrong object type '%T'", obj)
}
// Extract volumes
name, found, err := unstructured.NestedString(us.Object, "spec", "volumeName")
if err != nil {
glog.Error("Invalid object")
return nil, err
} else if !found {
return []Subset{}, nil
}
return []Subset{{
Name: "persistentvolumes",
Set: fields.Set{"metadata.name": name},
}}, nil
}
func UnstructuredGetAttr(resourceKind string) storage.AttrFunc {
return func(obj runtime.Object) (labels.Set, fields.Set, bool, error) {
us, ok := obj.(*unstructured.Unstructured)
if !ok {
return nil, nil, false, fmt.Errorf("Unsupported object type '%T'", obj)
}
if us.GetKind() != resourceKind {
return nil, nil, false, fmt.Errorf("Wrong object type '%T'", obj)
}
ls := us.GetLabels()
fs := fields.Set{
"metadata.name": us.GetName(),
"metadata.namespace": us.GetNamespace(),
}
// Support nodeName as a field selector for Pods
if resourceKind == "Pod" {
node, _, err := unstructured.NestedString(us.Object, "spec", "nodeName")
if err != nil {
return nil, nil, false, err
}
fs["spec.nodeName"] = node
}
// This consideres all objects initialized
return ls, fs, false, nil
}
}
func InterfaceToUnstructuredSlice(slice []interface{}) []unstructured.Unstructured {
ret := make([]unstructured.Unstructured, 0, len(slice))
for _, obj := range slice {
ret = append(ret, *obj.(*unstructured.Unstructured))
}
return ret
}
// Return true if the given SelectionPredicate is a subset of the list formed by the field set
func SetContainsSelection(set fields.Set, sp storage.SelectionPredicate) bool {
for key, value := range set {
requiredValue, found := sp.Field.RequiresExactMatch(key)
if !found {
return false
}
if value != requiredValue {
return false
}
}
return true
}
// Return true if there is at most one object that can be matched by this selector
func SelectorUniquelyIdentifiesObject(selector storage.SelectionPredicate, namespacedResource bool) bool {
fs := selector.Field
_, requiresName := fs.RequiresExactMatch("metadata.name")
if !namespacedResource && requiresName {
return true
}
_, requiresNamespace := fs.RequiresExactMatch("metadata.namespace")
if requiresName && requiresNamespace {
return true
}
return false
}
// Create a new ListWatch for a reflector or other code to use
//
// To maximize compatiblity with authorizers this has the following behavior:
// - The request is always performed in the given namespace when possible.
//
// For example when listing configmaps this is used
// api/v1/namespaces/default/configmaps?fieldSelector=metadata.name%3Dmy-cm%2Cmetadata.namespace%3Ddefault
//
// rather than
// api/v1/configmaps?fieldSelector=metadata.name%3Dmy-cm%2Cmetadata.namespace%3Ddefault
//
// Even though these requests select the same elements, the node authorizer in the api server
// rejects the latter due to insufficient node premissions.
//
// - If a single item is being requested a Get is used rather than a List
//
// For example when listing persistentvolumeclaims this is used
// api/v1/namespaces/default/persistentvolumeclaims/my-pvc
//
// rather than
// api/v1/namespaces/default/persistentvolumeclaims?fieldSelector=metadata.name%3Dmy-pvc
//
// Even though these requests select the get elements, the node authorizer in the api server
// rejects the latter due to insufficient node premissions.
//
// Node permissions can be found in 'plugin/pkg/auth/authorizer/node/node_authorizer.go'.
//
func NewListWatcher(ctx context.Context, client dynamic.Interface, resourceInfo ResourceInfo, fieldSelector fields.Selector) *cache.ListWatch {
grv := schema.GroupVersionResource{
Group: "",
Version: "v1",
Resource: resourceInfo.Name,
}
name, nameSelector := fieldSelector.RequiresExactMatch("metadata.name")
namspace, namespaceSelector := fieldSelector.RequiresExactMatch("metadata.namespace")
var ri dynamic.ResourceInterface
if namespaceSelector {
ri = client.Resource(grv).Namespace(namspace)
} else {
ri = client.Resource(grv)
}
useGet := false
if nameSelector && (!resourceInfo.Namespaced || namespaceSelector) {
useGet = true
}
var listBackoff time.Duration = BackoffStart
list := func(options metav1.ListOptions) (runtime.Object, error) {
options.FieldSelector = fieldSelector.String()
if useGet {
ul := unstructured.UnstructuredList{
Object: map[string]interface{}{
"kind": resourceInfo.Kind + "List",
"apiVersion": grv.Version,
},
Items: []unstructured.Unstructured{},
}
ul.SetResourceVersion("0")
// Perform Get
item, err := ri.Get(name, metav1.GetOptions{ResourceVersion: options.ResourceVersion})
// Return an empty list if it was not found
if errors.IsNotFound(err) {
return &ul, nil
}
// Return the error if there is one
if err != nil {
return nil, err
}
// Check if the object's fields matches the selection filter
_, fs, _, err := resourceInfo.GetAttr(item)
if err != nil {
return nil, err
}
if fieldSelector.Matches(fs) {
ul.Items = append(ul.Items, *item)
}
return &ul, err
}
ul, err := ri.List(options)
// Filter results (only needed for tests)
if err != nil {
return ul, err
}
newItems := make([]unstructured.Unstructured, 0, len(ul.Items))
for _, item := range ul.Items {
_, fs, _, err := resourceInfo.GetAttr(&item)
if err == nil && fieldSelector.Matches(fs) {
newItems = append(newItems, item)
}
}
ul.Items = newItems
return ul, err
}
listWithBackoff := func(options metav1.ListOptions) (runtime.Object, error) {
obj, err := list(options)
if err == nil {
listBackoff = BackoffStart
} else {
glog.Warningf("Failed to list '%v'. Retrying in %v", resourceInfo.Name, listBackoff)
SleepWithContext(ctx, listBackoff)
listBackoff *= 2
if listBackoff > BackoffMax {
listBackoff = BackoffMax
}
}
return obj, err
}
watch := func(options metav1.ListOptions) (watch.Interface, error) {
options.FieldSelector = fieldSelector.String()
if resourceInfo.WatchNotAllowed {
SleepWithContext(ctx, NoWatchPollInterval)
return nil, io.ErrUnexpectedEOF
}
return ri.Watch(options)
}
return &cache.ListWatch{
ListFunc: listWithBackoff,
WatchFunc: watch,
}
}
func SleepWithContext(ctx context.Context, d time.Duration) bool {
t := time.NewTimer(d)
defer t.Stop()
select {
case <-t.C:
return true
case <-ctx.Done():
return false
}
}
func ListImageTags(nodeName string, localCache LocalCache) ([]string, error) {
unstructuredPodList, err := localCache.List("pods", "", metav1.ListOptions{FieldSelector: fmt.Sprintf("spec.nodeName=%s", nodeName)})
if err != nil {
return nil, fmt.Errorf("could not list pods from cache: %s", err)
}
imageTags := sets.NewString()
for _, pod := range unstructuredPodList.Items {
podName, _, err := unstructured.NestedString(pod.Object, "metadata", "name")
if err != nil {
return nil, fmt.Errorf("Error retrieving metadata.name from pod object: %s", err)
}
containers, found, err := unstructured.NestedSlice(pod.Object, "spec", "containers")
if err != nil {
return nil, fmt.Errorf("Error retrieving spec.containers from pod object %s: %s", podName, err)
}
if !found {
glog.Errorf("Pod object %s has no spec.containers field", podName)
continue
}
for i, rawContainer := range containers {
container, ok := rawContainer.(map[string]interface{})
if !ok {
glog.Errorf("Error retrieving spec.containers from pod object %s: %s", podName, err)
continue
}
imageTag, found, err := unstructured.NestedString(container, "image")
if err != nil {
return nil, fmt.Errorf("Error retrieving image from pod object %s container %d: %s", podName, i, err)
}
if !found {
continue
}
imageTags.Insert(imageTag)
}
}
return imageTags.List(), nil
}
|
package main
import (
"bytes"
"encoding/json"
"fmt"
"os"
"strconv"
"strings"
"github.com/apex/log"
nginxFileReader "github.com/massmutual/go-filereader/nginx-filereader"
"github.com/newrelic/infra-integrations-sdk/data/metric"
"github.com/newrelic/infra-integrations-sdk/integration"
)
func readFile(file *os.File) (string, error) {
fileInBytes := make([]byte, 5)
_, err := file.Read(fileInBytes)
if err != nil {
return "", err
}
fileInBytes = bytes.Trim(fileInBytes, "\x00")
return string(fileInBytes[:]), nil
}
func fileExists(filename string) bool {
info, err := os.Stat(filename)
if os.IsNotExist(err) {
return false
}
return !info.IsDir()
}
func getPosition() (int64, error) {
if fileExists(args.PointerPath) == false {
err := putPosition(0)
if err != nil {
return 0, err
}
return 0, nil
}
positionfile, err := os.Open(args.PointerPath)
if err != nil {
return 0, err
}
defer positionfile.Close()
positionString, err := readFile(positionfile)
if err != nil {
return 0, err
}
positionString = strings.TrimSpace(positionString)
position, err := strconv.ParseInt(strings.TrimSpace(positionString), 10, 64)
if err != nil {
return 0, err
}
return position, nil
}
func putPosition(position int64) error {
positionString := strconv.FormatInt(position, 10)
opendedFile, err := os.Create(args.PointerPath)
if err != nil {
return err
}
defer opendedFile.Close()
_, err = opendedFile.Write([]byte(positionString))
if err != nil {
return err
}
return nil
}
func getMetricsData(localEntity *integration.Entity) error {
var nignxlog nginxFileReader.NginxLog
nignxlog.Unmatched = 0
file, err := os.Open(args.AccessLog)
if err != nil {
return err
}
defer file.Close()
position, err := getPosition()
if err != nil {
return err
}
position, err = nginxFileReader.ReadNginxLog(file, position, &nignxlog)
if err != nil {
return err
}
err = putPosition(position)
if err != nil {
return err
}
return populateMetrics(localEntity, nignxlog)
}
func populateMetrics(localEntity *integration.Entity, metrics nginxFileReader.NginxLog) error {
var inInterface map[string]interface{}
inrec, _ := json.Marshal(metrics)
json.Unmarshal(inrec, &inInterface)
metricset := localEntity.NewMetricSet("nginxparsing")
populateRawMetrics(localEntity, metricset, inInterface, "")
return nil
}
func populateRawMetrics(localEntity *integration.Entity, sample *metric.Set, metrics interface{}, prefixname string) {
var metricType metric.SourceType
switch metrics.(type) {
case []interface{}:
if prefixname != "" && strings.HasSuffix(prefixname, ".") == false {
prefixname = prefixname + "."
}
for _, v := range metrics.([]interface{}) {
var metricset *metric.Set
newname := prefixname
if prefixname == "NginxLogLines." {
metricset = localEntity.NewMetricSet("nginxlogline")
newname = ""
} else {
metricset = sample
}
populateRawMetrics(localEntity, metricset, v, newname)
}
return
case map[string]interface{}:
if prefixname != "" && strings.HasSuffix(prefixname, ".") == false {
prefixname = prefixname + "."
}
for k, v := range metrics.(map[string]interface{}) {
populateRawMetrics(localEntity, sample, v, prefixname+k)
}
return
case int, int16, int32, int64, float32, float64:
fmt.Println(prefixname, ": ", metrics)
metricType = metric.GAUGE
case string:
metricType = metric.ATTRIBUTE
default:
log.Warn("Metric type not caught ")
}
err := sample.SetMetric(prefixname, metrics, metricType)
if err != nil {
log.Warn("Error setting value: " + err.Error())
}
}
|
package main
import (
"fmt"
)
type Person struct {
name string
age uint
}
func main() {
var john Person
john.name = "John"
john.age = 23
tom := Person{
age: 31,
name: "Tom",
}
jane := Person{"Jane", 42}
mike := &Person{
name: "Mike",
age: 36,
}
fmt.Println(john, tom, jane, mike)
}
|
// +build !race
package dsstore
import (
"context"
"encoding/json"
"testing"
"time"
"github.com/square/p2/pkg/audit"
"github.com/square/p2/pkg/logging"
"github.com/square/p2/pkg/manifest"
"github.com/square/p2/pkg/store/consul/auditlogstore"
"github.com/square/p2/pkg/store/consul/consulutil"
"github.com/square/p2/pkg/store/consul/transaction"
klabels "k8s.io/kubernetes/pkg/labels"
)
func TestCreateWithAudit(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
ds, err := auditingStore.Create(ctx, testManifest(), 1, "some_name", klabels.Everything(), "some_pod", 0, "some_user")
if err != nil {
t.Fatal(err)
}
// confirm no daemon sets or audit logs exist yet
dsList, err := dsStore.List()
if err != nil {
t.Fatal(err)
}
if len(dsList) != 0 {
t.Errorf("expected 0 daemon sets before committing transaction but there were %d", len(dsList))
}
alMap, err := auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 0 {
t.Errorf("expected 0 audit logs before committing transaction but there were %d", len(alMap))
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
// confirm there's a daemon set and an audit record
dsList, err = dsStore.List()
if err != nil {
t.Fatal(err)
}
if len(dsList) != 1 {
t.Errorf("expected 0 daemon set after committing transaction but there were %d", len(dsList))
}
alMap, err = auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 1 {
t.Errorf("expected 1 audit log after committing transaction but there were %d", len(alMap))
}
for _, v := range alMap {
if v.EventType != audit.DSCreatedEvent {
t.Errorf("expected audit log record with type %q but was %q", audit.DSCreatedEvent, v.EventType)
}
var details audit.DSEventDetails
err = json.Unmarshal([]byte(*v.EventDetails), &details)
if err != nil {
t.Fatal(err)
}
if details.User != "some_user" {
t.Errorf("expected user name on audit record to be %q but was %q", "some_user", details.User)
}
// smoke test the ID matches the details
if details.DaemonSet.ID != ds.ID {
t.Errorf("expected daemon set in audit log record to have ID %s but was %s", ds.ID, details.DaemonSet.ID)
}
}
}
func TestDisableWithAudit(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
ds, err := dsStore.Create(ctx, testManifest(), 1, "some_name", klabels.Everything(), "some_pod", 0)
if err != nil {
t.Fatal(err)
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
if ds.Disabled {
t.Fatal("expected daemon set to start out disabled")
}
ctx, cancel = transaction.New(context.Background())
defer cancel()
_, err = auditingStore.Disable(ctx, ds.ID, "some_user")
if err != nil {
t.Fatal(err)
}
if ds.Disabled {
t.Fatal("daemon set should not have been disabled before the transaction was committed")
}
// confirm no audit log records exist yet
alMap, err := auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 0 {
t.Errorf("expected 0 audit logs before committing transaction but there were %d", len(alMap))
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if !ds.Disabled {
t.Fatal("daemon set should have been disabled after the transaction was committed")
}
alMap, err = auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 1 {
t.Errorf("expected 1 audit log after committing transaction but there were %d", len(alMap))
}
for _, v := range alMap {
if v.EventType != audit.DSDisabledEvent {
t.Errorf("expected audit log record with type %q but was %q", audit.DSDisabledEvent, v.EventType)
}
var details audit.DSEventDetails
err = json.Unmarshal([]byte(*v.EventDetails), &details)
if err != nil {
t.Fatal(err)
}
if details.User != "some_user" {
t.Errorf("expected user name on audit record to be %q but was %q", "some_user", details.User)
}
// smoke test the ID matches the details
if details.DaemonSet.ID != ds.ID {
t.Errorf("expected daemon set in audit log record to have ID %s but was %s", ds.ID, details.DaemonSet.ID)
}
if !details.DaemonSet.Disabled {
t.Errorf("expected daemon set in audit log record to have been disabled (i.e. the daemon set AFTER the operation is what shows up in audit log)")
}
}
}
func TestEnableWithAudit(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
ds, err := dsStore.Create(ctx, testManifest(), 1, "some_name", klabels.Everything(), "some_pod", 0)
if err != nil {
t.Fatal(err)
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
ctx, cancel = transaction.New(context.Background())
defer cancel()
_, err = dsStore.DisableTxn(ctx, ds.ID)
if err != nil {
t.Fatal(err)
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if !ds.Disabled {
t.Fatal("daemon set should have been disabled after the transaction was committed")
}
ctx, cancel = transaction.New(context.Background())
defer cancel()
_, err = auditingStore.Enable(ctx, ds.ID, "some_user")
if err != nil {
t.Fatal(err)
}
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if !ds.Disabled {
t.Fatal("daemon set should not have been enabled before the transaction was committed")
}
// confirm no audit log records were created yet
alMap, err := auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 0 {
t.Errorf("expected 0 audit logs before committing transaction but there were %d", len(alMap))
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if ds.Disabled {
t.Fatal("daemon set should have been enabled after the transaction was committed")
}
alMap, err = auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 1 {
t.Errorf("expected 1 audit log after committing transaction but there were %d", len(alMap))
}
for _, v := range alMap {
if v.EventType != audit.DSEnabledEvent {
t.Errorf("expected audit log record with type %q but was %q", audit.DSEnabledEvent, v.EventType)
}
var details audit.DSEventDetails
err = json.Unmarshal([]byte(*v.EventDetails), &details)
if err != nil {
t.Fatal(err)
}
if details.User != "some_user" {
t.Errorf("expected user name on audit record to be %q but was %q", "some_user", details.User)
}
// smoke test the ID matches the details
if details.DaemonSet.ID != ds.ID {
t.Errorf("expected daemon set in audit log record to have ID %s but was %s", ds.ID, details.DaemonSet.ID)
}
if details.DaemonSet.Disabled {
t.Errorf("expected daemon set in audit log record to have been enabled (i.e. the daemon set AFTER the operation is what shows up in audit log)")
}
}
}
func TestUpdateManifest(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
ds, err := dsStore.Create(ctx, testManifest(), 1, "some_name", klabels.Everything(), "some_pod", 0)
if err != nil {
t.Fatal(err)
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
builder := manifest.NewBuilder()
builder.SetID("some_other_pod_id")
podManifestWithDifferentPodID := builder.GetManifest()
ctx, cancel = transaction.New(context.Background())
defer cancel()
_, err = auditingStore.UpdateManifest(ctx, ds.ID, podManifestWithDifferentPodID, "some_user")
if err == nil {
t.Error("expected an error when changing the pod ID of the manifest")
}
ctx, cancel = transaction.New(context.Background())
defer cancel()
builder.SetID("some_pod")
err = builder.SetConfig(map[interface{}]interface{}{"foo": "bar"})
if err != nil {
t.Fatal(err)
}
newManifest := builder.GetManifest()
_, err = auditingStore.UpdateManifest(ctx, ds.ID, newManifest, "some_user")
if err != nil {
t.Fatal(err)
}
// confirm the manifest hasn't changed yet and also there's no audit log record
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
dsSHA, err := ds.Manifest.SHA()
if err != nil {
t.Fatal(err)
}
testSHA, err := testManifest().SHA()
if err != nil {
t.Fatal(err)
}
if testSHA != dsSHA {
t.Error("the daemon set's manifest shouldn't have changed before committing the transaction")
}
alMap, err := auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 0 {
t.Errorf("expected 0 audit logs before committing transaction but there were %d", len(alMap))
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
// confirm the manifest has now changed
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
dsSHA, err = ds.Manifest.SHA()
if err != nil {
t.Fatal(err)
}
newManifestSHA, err := newManifest.SHA()
if err != nil {
t.Fatal(err)
}
alMap, err = auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 1 {
t.Errorf("expected 1 audit log before committing transaction but there were %d", len(alMap))
}
for _, v := range alMap {
if v.EventType != audit.DSManifestUpdatedEvent {
t.Errorf("expected audit log record with type %q but was %q", audit.DSManifestUpdatedEvent, v.EventType)
}
var details audit.DSEventDetails
err = json.Unmarshal([]byte(*v.EventDetails), &details)
if err != nil {
t.Fatal(err)
}
if details.User != "some_user" {
t.Errorf("expected user name on audit record to be %q but was %q", "some_user", details.User)
}
// smoke test the ID matches the details
if details.DaemonSet.ID != ds.ID {
t.Errorf("expected daemon set in audit log record to have ID %s but was %s", ds.ID, details.DaemonSet.ID)
}
manifestSHA, err := details.DaemonSet.Manifest.SHA()
if err != nil {
t.Fatal(err)
}
if manifestSHA != newManifestSHA {
t.Error("the manifest in the audit log record didn't reflect the manifest change")
}
}
}
func TestUpdateNodeSelector(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
ds, err := dsStore.Create(ctx, testManifest(), 1, "some_name", klabels.Everything(), "some_pod", 0)
if err != nil {
t.Fatal(err)
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
ctx, cancel = transaction.New(context.Background())
defer cancel()
newSelector := klabels.Everything().Add("whatever key", klabels.EqualsOperator, []string{"whatever value"})
_, err = auditingStore.UpdateNodeSelector(ctx, ds.ID, newSelector, "some_user")
if err != nil {
t.Fatal(err)
}
// confirm the node selector hasn't changed yet and also there's no audit log record
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if ds.NodeSelector.String() != klabels.Everything().String() {
t.Error("the daemon set's node selector shouldn't have changed before committing the transaction")
}
alMap, err := auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 0 {
t.Errorf("expected 0 audit logs before committing transaction but there were %d", len(alMap))
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
// confirm the manifest has now changed
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if ds.NodeSelector.String() != newSelector.String() {
t.Error("the daemon set's node selector should have changed after committing the transaction")
}
alMap, err = auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 1 {
t.Errorf("expected 1 audit log before committing transaction but there were %d", len(alMap))
}
for _, v := range alMap {
if v.EventType != audit.DSNodeSelectorUpdatedEvent {
t.Errorf("expected audit log record with type %q but was %q", audit.DSNodeSelectorUpdatedEvent, v.EventType)
}
var details audit.DSEventDetails
err = json.Unmarshal([]byte(*v.EventDetails), &details)
if err != nil {
t.Fatal(err)
}
if details.User != "some_user" {
t.Errorf("expected user name on audit record to be %q but was %q", "some_user", details.User)
}
// smoke test the ID matches the details
if details.DaemonSet.ID != ds.ID {
t.Errorf("expected daemon set in audit log record to have ID %s but was %s", ds.ID, details.DaemonSet.ID)
}
if details.DaemonSet.NodeSelector.String() != newSelector.String() {
t.Errorf("expected the audit log record to have the selector changed to %q but was %q", newSelector, details.DaemonSet.NodeSelector)
}
}
}
func TestDeleteWithAudit(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
ds, err := dsStore.Create(ctx, testManifest(), 1, "some_name", klabels.Everything(), "some_pod", 0)
if err != nil {
t.Fatal(err)
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
ctx, cancel = transaction.New(context.Background())
defer cancel()
err = auditingStore.Delete(ctx, ds.ID, "some_user")
if err != nil {
t.Fatal(err)
}
// confirm he daemon set wasn't deleted yet
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
alMap, err := auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 0 {
t.Errorf("expected 0 audit logs before committing transaction but there were %d", len(alMap))
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
// confirm the daemon set was deleted
_, _, err = dsStore.Get(ds.ID)
switch {
case err == NoDaemonSet:
case err != nil:
t.Fatal(err)
}
alMap, err = auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 1 {
t.Errorf("expected 1 audit log before committing transaction but there were %d", len(alMap))
}
for _, v := range alMap {
if v.EventType != audit.DSDeletedEvent {
t.Errorf("expected audit log record with type %q but was %q", audit.DSDeletedEvent, v.EventType)
}
var details audit.DSEventDetails
err = json.Unmarshal([]byte(*v.EventDetails), &details)
if err != nil {
t.Fatal(err)
}
if details.User != "some_user" {
t.Errorf("expected user name on audit record to be %q but was %q", "some_user", details.User)
}
// smoke test that the details have the daemon set prior to deletion by checking the ID
if details.DaemonSet.ID != ds.ID {
t.Errorf("expected daemon set in audit log record to have ID %s but was %s", ds.ID, details.DaemonSet.ID)
}
}
}
func TestCantDeleteMissingDaemonSetWithAudit(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
err := auditingStore.Delete(ctx, "some_non_existent_ds_id", "some_user")
if err == nil {
t.Fatal("expected an error when deleting a non existent daemon set")
}
}
func TestUpdateMinHealth(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
ds, err := dsStore.Create(ctx, testManifest(), 1, "some_name", klabels.Everything(), "some_pod", 0)
if err != nil {
t.Fatal(err)
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
ctx, cancel = transaction.New(context.Background())
defer cancel()
_, err = auditingStore.UpdateMinHealth(ctx, ds.ID, 23, "some_user")
if err != nil {
t.Fatal(err)
}
// confirm he daemon set didn't have its min health changed yet
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if ds.MinHealth != 1 {
t.Fatal("min health shouldn't have changed prior to committing the transaction")
}
alMap, err := auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 0 {
t.Errorf("expected 0 audit logs before committing transaction but there were %d", len(alMap))
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
// confirm the daemon set was deleted
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if ds.MinHealth != 23 {
t.Fatal("min health should have been updated after comitting the transaction")
}
alMap, err = auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 1 {
t.Errorf("expected 1 audit log before committing transaction but there were %d", len(alMap))
}
for _, v := range alMap {
if v.EventType != audit.DSModifiedEvent {
t.Errorf("expected audit log record with type %q but was %q", audit.DSModifiedEvent, v.EventType)
}
var details audit.DSEventDetails
err = json.Unmarshal([]byte(*v.EventDetails), &details)
if err != nil {
t.Fatal(err)
}
if details.User != "some_user" {
t.Errorf("expected user name on audit record to be %q but was %q", "some_user", details.User)
}
// smoke test that the details have the daemon set prior to deletion by checking the ID
if details.DaemonSet.ID != ds.ID {
t.Errorf("expected daemon set in audit log record to have ID %s but was %s", ds.ID, details.DaemonSet.ID)
}
if details.DaemonSet.MinHealth != 23 {
t.Errorf("expected daemon set in audit log record to have %d min health but was %d", 23, details.DaemonSet.MinHealth)
}
}
}
func TestUpdateTimeout(t *testing.T) {
fixture := consulutil.NewFixture(t)
defer fixture.Stop()
logger := logging.TestLogger()
dsStore := NewConsul(fixture.Client, 0, &logger)
auditLogStore := auditlogstore.NewConsulStore(fixture.Client.KV())
auditingStore := NewAuditingStore(dsStore, auditLogStore)
ctx, cancel := transaction.New(context.Background())
defer cancel()
ds, err := dsStore.Create(ctx, testManifest(), 1, "some_name", klabels.Everything(), "some_pod", 0)
if err != nil {
t.Fatal(err)
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
ctx, cancel = transaction.New(context.Background())
defer cancel()
_, err = auditingStore.UpdateTimeout(ctx, ds.ID, 18*time.Second, "some_user")
if err != nil {
t.Fatal(err)
}
// confirm he daemon set didn't have its timeout changed yet
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if ds.Timeout != 0 {
t.Fatal("timeout shouldn't have changed prior to committing the transaction")
}
alMap, err := auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 0 {
t.Errorf("expected 0 audit logs before committing transaction but there were %d", len(alMap))
}
err = transaction.MustCommit(ctx, fixture.Client.KV())
if err != nil {
t.Fatal(err)
}
// confirm the daemon set was deleted
ds, _, err = dsStore.Get(ds.ID)
if err != nil {
t.Fatal(err)
}
if ds.Timeout != 18*time.Second {
t.Fatal("timeout should have been updated after comitting the transaction")
}
alMap, err = auditLogStore.List()
if err != nil {
t.Fatal(err)
}
if len(alMap) != 1 {
t.Errorf("expected 1 audit log before committing transaction but there were %d", len(alMap))
}
for _, v := range alMap {
if v.EventType != audit.DSModifiedEvent {
t.Errorf("expected audit log record with type %q but was %q", audit.DSModifiedEvent, v.EventType)
}
var details audit.DSEventDetails
err = json.Unmarshal([]byte(*v.EventDetails), &details)
if err != nil {
t.Fatal(err)
}
if details.User != "some_user" {
t.Errorf("expected user name on audit record to be %q but was %q", "some_user", details.User)
}
// smoke test that the details have the daemon set prior to deletion by checking the ID
if details.DaemonSet.ID != ds.ID {
t.Errorf("expected daemon set in audit log record to have ID %s but was %s", ds.ID, details.DaemonSet.ID)
}
if details.DaemonSet.Timeout != 18*time.Second {
t.Errorf("expected daemon set in audit log record to have %s timeout but was %s", 18*time.Second, details.DaemonSet.Timeout)
}
}
}
func testManifest() manifest.Manifest {
builder := manifest.NewBuilder()
builder.SetID("some_pod")
return builder.GetManifest()
}
|
package internal
import (
"log"
"encoding/json"
"strings"
"strconv"
)
func CheckErrWithLog(err error, msg string) {
logger := log.Logger{}
if !CheckErr(err, msg) {
logger.Println(err)
}
}
func IndentedJson(v interface{}) []byte {
indentedJson, err := json.MarshalIndent(v, "", "\t")
CheckErr(err, "couldn't marshal json")
return indentedJson
}
func IndentedString(v interface{}) string {
indentedString := string(IndentedJson(v))
return indentedString
}
func SplitAddress(s string) (string, uint16) {
addr := strings.Split(s, ":")
ip, port := addr[0], "80"
if len(addr) > 1 {
ip, port = addr[0], addr[1]
}
base, bitSize := 10, 16
retPort, _ := strconv.ParseUint(port, base, bitSize)
return ip, uint16(retPort)
} |
package messaging
import (
lib "github.com/k8guard/k8guardlibs"
msg "github.com/k8guard/k8guardlibs/messaging"
"github.com/k8guard/k8guardlibs/messaging/types"
)
var MessageProducer types.MessageProducer
func InitBroker() {
s, err := msg.CreateMessageProducer(
types.MessageBrokerType(lib.Cfg.MessageBroker), types.DISCOVER_CLIENTID, lib.Cfg)
if err != nil {
lib.Log.Error("Creating Messagging Producer ", err)
panic(err)
}
MessageProducer = s
}
func TestBrokerWithTestMessage() error {
// Sending Test Data
err := MessageProducer.SendData(types.TEST_MESSAGE, "Testing")
if err != nil {
lib.Log.Error("Error trying to send test data to broker ", err)
}
return err
}
func SendData(kind types.MessageType, name string, message interface{}) {
lib.Log.Debugf("Sending %s: %v to broker", name, message)
err := MessageProducer.SendData(kind, message)
if err != nil {
lib.Log.Error("Error trying to send message to broker ", err)
}
}
func InitStatsHandler() {
lib.Log.Debug("Initializing stats handler")
if MessageProducer == nil {
InitBroker()
}
MessageProducer.InitStatsHandler()
}
func CloseBroker() {
lib.Log.Debug("Closing broker")
MessageProducer.Close()
}
|
package crawler
import (
"errors"
"fmt"
"log"
"net/http"
"path/filepath"
"github.com/PuerkitoBio/goquery"
)
// LinkScrapeForHuobi .
func LinkScrapeForHuobi() ([]string, error) {
s := make([]string, 0)
doc, err := goquery.NewDocument("https://github.com/huobiapi/API_Docs/wiki")
if err != nil {
log.Println(err)
return s, err
}
t := doc.Find(".wiki-pages a")
for i := 0; i < t.Length(); i++ {
d, _ := t.Eq(i).Attr("href")
// fmt.Println(d)
d = "https://github.com" + d
s = append(s, d)
}
// fmt.Println(s)
return s, nil
}
// FindForHuobi .
func FindForHuobi(url string) (title string, text string, err error) {
// Request the HTML page.
res, err := http.Get(url)
if err != nil {
log.Println(err)
return
}
defer res.Body.Close()
if res.StatusCode != 200 {
log.Printf("status code error: %d %s\n", res.StatusCode, res.Status)
return
}
// Load the HTML document
doc, err := goquery.NewDocumentFromReader(res.Body)
if err != nil {
log.Println(err)
return
}
_, title = filepath.Split(url)
fmt.Println("title: ", title)
text, err = doc.Find("#wiki-body").Find(".markdown-body").Eq(0).Html()
if err != nil {
log.Println(err)
return
}
if len(text) == 0 {
log.Println("error: empty text. ", url)
return title, text, errors.New("empty text")
}
// fmt.Println("text: ", text)
return title, text, nil
}
// CleanDataForHuobi .
func CleanDataForHuobi(title, text string) (string, string) {
return title, text
}
// Huobi API.
func Huobi() error {
s, err := LinkScrapeForHuobi()
if err != nil {
log.Println(err)
return err
}
for i := 0; i < len(s); i++ {
title, text, err := FindForHuobi(s[i])
if err != nil {
log.Println(err)
continue
}
title, text = CleanDataForHuobi(title, text)
if err = SaveForMd(title, text, "./huobi"); err != nil {
log.Println(err)
}
}
return nil
}
|
package lottery
// Config 抽奖程序配置
type Config struct {
PredictPerson int
MaxOnPerson int
Prizes map[int] Prize
} |
package pricingengine
// GeneratePricingRequest is used for generate pricing requests, it holds the
// inputs that are used to provide pricing for a given user.
type GeneratePricingRequest struct {
// TODO: populate me!
}
// GeneratePricingResponse - TODO: please document me :)
type GeneratePricingResponse struct {
// TODO: populate me!
}
|
// An example of the pipeline pattern that I wrote as part of a training course.
package main
import (
"math/rand"
"time"
"golang.org/x/text/message"
)
func main() {
p := message.NewPrinter(message.MatchLanguage("en"))
for x := range pipe(gen(20, 100)) {
p.Printf("%42d\n", x)
}
// // Test the limits of what a uint64 can hold
// for index := 1; index <= 32; index++ {
// p.Printf("%2d!: %37d\n", index, factorial(uint64(index)))
// }
//
// p.Printf("math.MaxUint64: %26d\n", uint64(math.MaxUint64))
}
func pipe(input chan uint64) chan uint64 {
out := make(chan uint64)
go func() {
for j := range input {
out <- factorial(j)
}
close(out)
}()
return out
}
func factorial(in uint64) uint64 {
total := uint64(1)
for i := in; i > 1; i-- {
total *= i
}
return total
}
func gen(max int, num uint64) chan uint64 {
out := make(chan uint64)
go func() {
for index := uint64(0); index < num; index++ {
// Re-roll the random seed each time
r := rand.New(rand.NewSource(time.Now().UnixNano()))
out <- uint64(r.Intn(max) + 1) // Get [1,max] rather than [0,max)
}
close(out)
}()
return out
}
|
package md5_test
import (
"testing"
"github.com/danielfmelo/myhttphash/hash/md5"
)
func TestCreateMD5(t *testing.T) {
m := md5.New()
data := []byte("to.be.hashed")
expectedMd5 := "ff0c1b127f5e1170afb5d053b295d561"
result := m.CreateHash(data)
if result != expectedMd5 {
t.Errorf("expected %s but got %s", expectedMd5, result)
}
}
|
package asset
import (
"fmt"
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
)
type persistAsset struct{}
func (a *persistAsset) Name() string {
return "persist-asset"
}
func (a *persistAsset) Dependencies() []Asset {
return []Asset{}
}
func (a *persistAsset) Generate(Parents) error {
return nil
}
type writablePersistAsset struct {
persistAsset
FileList []*File
}
func (a *writablePersistAsset) Files() []*File {
return a.FileList
}
func (a *writablePersistAsset) Load(FileFetcher) (bool, error) {
return false, nil
}
func TestPersistToFile(t *testing.T) {
cases := []struct {
name string
filenames []string
}{
{
name: "no files",
filenames: []string{},
},
{
name: "single file",
filenames: []string{"file1"},
},
{
name: "multiple files",
filenames: []string{"file1", "file2"},
},
{
name: "new directory",
filenames: []string{"dir1/file1"},
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
dir := t.TempDir()
asset := &writablePersistAsset{
FileList: make([]*File, len(tc.filenames)),
}
expectedFiles := map[string][]byte{}
for i, filename := range tc.filenames {
data := []byte(fmt.Sprintf("data%d", i))
asset.FileList[i] = &File{
Filename: filename,
Data: data,
}
expectedFiles[filepath.Join(dir, filename)] = data
}
err := PersistToFile(asset, dir)
assert.NoError(t, err, "unexpected error persisting state to file")
verifyFilesCreated(t, dir, expectedFiles)
})
}
}
func verifyFilesCreated(t *testing.T, dir string, expectedFiles map[string][]byte) {
dirContents, err := os.ReadDir(dir)
assert.NoError(t, err, "could not read contents of directory %q", dir)
for _, fileinfo := range dirContents {
fullPath := filepath.Join(dir, fileinfo.Name())
if fileinfo.IsDir() {
verifyFilesCreated(t, fullPath, expectedFiles)
} else {
expectedData, fileExpected := expectedFiles[fullPath]
if !fileExpected {
t.Errorf("Unexpected file created: %v", fullPath)
continue
}
actualData, err := os.ReadFile(fullPath)
assert.NoError(t, err, "unexpected error reading created file %q", fullPath)
assert.Equal(t, expectedData, actualData, "unexpected data in created file %q", fullPath)
delete(expectedFiles, fullPath)
}
}
for f := range expectedFiles {
t.Errorf("Expected file %q not created", f)
}
}
|
package ranges
import "fmt"
func main() {
// Range on array
arr := [4]string{"AMar", "Jyoti", "Rekha"}
for k, v := range arr {
fmt.Println("range on array key: ", k, " value: ", v)
}
// Range on slice
slc := []string{"x", "y", "z"}
for k, v := range slc {
fmt.Println("key: ", k, " value: ", v)
}
// Range on map
mp := map[string]string{
"admin": "amar",
"user": "bijay",
}
for key, value := range mp {
fmt.Println(key, value)
}
// Range on map of slices
mapOfSlices := map[string][]string{
"Admins": []string{"bijay", "amar", "jyoti"},
"Users": []string{"pratiksha", "rekha", "pramila"},
}
for key, value := range mapOfSlices {
fmt.Println(key, value)
for k, v := range value {
fmt.Println(k, v)
}
}
}
|
package main
var name = "John"
func init() {
println("Hi! " + name)
}
func main() {
println("Hello! " + name)
}
|
package main
import (
"log"
"github.com/sf1/go-card/smartcard"
)
var (
cardCtx *smartcard.Context
reader *smartcard.Reader
card *smartcard.Card
err error
)
func connectToCard() error {
cardCtx, err = smartcard.EstablishContext()
if err != nil {
return err
}
log.Println("Awaiting a card to be presented.")
reader, err = cardCtx.WaitForCardPresent()
if err != nil {
return err
}
card, err = reader.Connect()
if err != nil {
return err
}
log.Println("Card ATR:", card.ATR())
// Select the given application.
selectApplication()
return nil
}
func selectApplication() error {
log.Println("Finding application to select...")
// Get a list of applications.
getApps, err := sendDesfireCommand(0x6a, []byte{})
if err != nil {
return err
}
// Select the first application.
_, err = sendDesfireCommand(0x5a, getApps.Data()[:3])
return err
}
func safelyCloseCard() {
if cardCtx != nil {
cardCtx.Release()
}
if card != nil {
card.Disconnect()
}
}
func sendDesfireCommand(ins byte, data []byte) (smartcard.ResponseAPDU, error) {
command := smartcard.CommandAPDU{0x90, ins, 0x00, 0x00} // CLA, INS, P1, P2 bytes
if len(data) > 0 {
command = append(command, uint8(len(data)))
command = append(command, data...) // Data
}
command = append(command, 0x00) // Le byte
response, err := card.TransmitAPDU(command)
if debugLogging {
if err != nil {
log.Printf("[ Tx Error ] %s", err)
log.Printf("[ ..cont'd ] Sent APDU Command: %x\n", []byte(command))
} else if response.SW1() != 0x91 || response.SW2() != 0x00 {
log.Printf("[APDU Error] SW1=%x, SW2=%x\n", response.SW1(), response.SW2())
log.Printf("[ ..cont'd ] Sent APDU Command: %x\n", []byte(command))
} else {
log.Printf("[ APDU Res ] SW1=%x, SW2=%x\n", response.SW1(), response.SW2())
log.Printf("[ ..cont'd ] Received APDU Res: %x\n", response.Data())
}
}
return response, err
}
|
package Interpreter
import "strings"
type Expression interface {
Interpret(variables map[string]Expression) int
}
type Integer struct {
interger int
}
func (n *Integer)Interpret(variables map[string]Expression) int {
return n.interger
}
type Plus struct {
leftOperand Expression
rightOperand Expression
}
func (p *Plus) Interpret(variables map[string]Expression) int {
return p.leftOperand.Interpret(variables) + p.rightOperand.Interpret(variables)
}
//解释的方法
func (e Evaluator) Interpret(context map[string]Expression) int{
return e.syntaxTree.Interpret(context)
}
type Variable struct {
name string
}
type Node struct {
value interface{}
next *Node
}
type Stack struct {
top *Node
size int
}
func (s *Stack) Push(value interface{}) {
s.top = &Node{
value:value,
next:s.top,
}
}
func (v *Variable) Interpret(variables map[string]Expression) int{
value,found := variables[v.name]
if !found {
return 0
}
return value.Interpret(variables)
}
func (s *Stack) Pop() interface{} {
if s.size == 0 {
return nil
}
value := s.top.value
s.top = s.top.next
s.size--
return value
}
type Evaluator struct {
syntaxTree Expression
}
func NewEvaluator(expression string) *Evaluator {
expressionStack := new(Stack)
for _,token:= range strings.Split(expression," "){
switch token {
case "+":
right := expressionStack.Pop().(Expression)
left := expressionStack.Pop().(Expression)
subExpression := &Plus{left,right}
expressionStack.Push(subExpression)
default:
expressionStack.Push(&Variable{token})
}
} //将所有需要解释的东西放到一个栈里
syntaxTree := expressionStack.Pop().(Expression)
return &Evaluator{syntaxTree:syntaxTree} //返回
} |
package api
import (
"fmt"
"time"
)
//go:generate msgp
type LocalGetSet interface {
LocalGet(key []byte, includeValue bool) (ki *KeyInv, err error)
LocalSet(ki *KeyInv) error
}
type Peerface interface {
LocalGetSet
BcastGet(key []byte, includeValue bool, timeout time.Duration, who string) (kis []*KeyInv, err error)
GetLatest(key []byte, includeValue bool) (ki *KeyInv, err error)
}
// KeyInv supplies the keys and their
// peer location (Who) and their timestamps
// (When) while optionally (but not necessarily)
// providing their data Val.
//
// The includeValue flag in the
// calls below determines if we return the Val
// on Get calls. Val must always be provided
// on Set.
//
type KeyInv struct {
Key []byte
Who string
When time.Time
Size int64
Blake2b []byte
Val []byte
}
func (ki *KeyInv) String() string {
return fmt.Sprintf(`{Key:"%s", Who:"%s", When:"%s", Size:%v, Blake2b:"%x"}`,
string(ki.Key), ki.Who, ki.When.UTC(), ki.Size, ki.Blake2b)
}
type BcastGetRequest struct {
FromID string
// Key specifies the key to query and return the value of.
Key []byte
// Who should be left empty to get all replies.
// Otherwise only the peer whose name matches will reply.
Who string
// IncludeValue when false returns the timestamp and size without
// the whole (big) value.
IncludeValue bool
ReplyGrpcHost string
ReplyGrpcXPort int
ReplyGrpcIPort int
}
type BcastGetReply struct {
FromID string
Ki *KeyInv
Err string
}
type BcastSetRequest struct {
FromID string
Ki *KeyInv
}
type BcastSetReply struct {
Err string
}
|
package db
import (
"github.com/pkg/errors"
m "github.com/thedevelopnik/netplan/pkg/models"
)
// VPC actions
func (r npRepo) CreateVPC(vpc *m.VPC) error {
// create in the db
if err := r.db.Create(&vpc).Error; err != nil {
return err
}
return nil
}
func (r npRepo) UpdateVPC(vpc *m.VPC) (*m.VPC, error) {
// find the current one matching the one with updated values
var update m.VPC
if err := r.db.Where("id = ?", vpc.ID).First(&update).Error; err != nil {
return nil, err
}
// update the values
update.Name = vpc.Name
update.Access = vpc.Access
update.Location = vpc.Location
update.Provider = vpc.Provider
update.Env = vpc.Env
update.CidrBlock = vpc.CidrBlock
update.Type = vpc.Type
update.NetworkMapID = vpc.NetworkMapID
// save in the db or send error
if err := r.db.Save(&update).Error; err != nil {
return nil, err
}
return &update, nil
}
func (r npRepo) DeleteVPC(id uint) error {
// find db ojbect matching the id
var vpc m.VPC
if err := r.db.Where("id = ?", id).First(&vpc).Error; err != nil {
return err
}
// delete the object
if err := r.db.Delete(vpc).Error; err != nil {
return err
}
return nil
}
func (r npRepo) GetVPCsByNetworkMapID(id uint) ([]m.VPC, error) {
var vpcs []m.VPC
if err := r.db.Where("network_map_id = ?", id).Find(&vpcs).Error; err != nil {
return nil, errors.Wrap(err, "repository could not find vpcs matching the network map id in the db")
}
return vpcs, nil
}
func (r npRepo) GetVPCByID(id uint) (m.VPC, error) {
var vpcs []m.VPC
if err := r.db.Where("id = ?", id).Find(&vpcs).Error; err != nil {
return m.VPC{}, errors.Wrap(err, "repository could not find vpc matching the vpic id")
}
return vpcs[0], nil
}
|
package pkg
import "fmt"
// X ...
var X = "Hello World"
// Main will print stuff to stdout
func Main() {
fmt.Printf("%+v\n", X)
}
// Hello will return a string
func Hello() string {
return X
}
|
// Copyright 2019-2023 The sakuracloud_exporter Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package collector
import (
"context"
"errors"
"testing"
"github.com/prometheus/client_golang/prometheus"
"github.com/sacloud/iaas-api-go"
"github.com/sacloud/iaas-api-go/types"
"github.com/sacloud/sakuracloud_exporter/platform"
"github.com/stretchr/testify/require"
)
type dummyESMEClient struct {
esme []*iaas.ESME
findErr error
logs []*iaas.ESMELogs
logsErr error
}
func (d *dummyESMEClient) Find(ctx context.Context) ([]*iaas.ESME, error) {
return d.esme, d.findErr
}
func (d *dummyESMEClient) Logs(ctx context.Context, esmeID types.ID) ([]*iaas.ESMELogs, error) {
return d.logs, d.logsErr
}
func TestESMECollector_Describe(t *testing.T) {
initLoggerAndErrors()
c := NewESMECollector(context.Background(), testLogger, testErrors, &dummyESMEClient{})
descs := collectDescs(c)
require.Len(t, descs, len([]*prometheus.Desc{
c.ESMEInfo,
c.MessageCount,
}))
}
func TestESMECollector_Collect(t *testing.T) {
initLoggerAndErrors()
c := NewESMECollector(context.Background(), testLogger, testErrors, nil)
cases := []struct {
name string
in platform.ESMEClient
wantLogs []string
wantErrCounter float64
wantMetrics []*collectedMetric
}{
{
name: "collector returns error",
in: &dummyESMEClient{
findErr: errors.New("dummy"),
},
wantLogs: []string{`level=WARN msg="can't list ESME" err=dummy`},
wantErrCounter: 1,
wantMetrics: nil,
},
{
name: "empty result",
in: &dummyESMEClient{},
wantMetrics: nil,
},
{
name: "esme: collecting ESME logs is failed ",
in: &dummyESMEClient{
esme: []*iaas.ESME{
{
ID: 101,
Name: "ESME",
Tags: types.Tags{"tag1", "tag2"},
Description: "desc",
},
},
logsErr: errors.New("dummy"),
},
wantMetrics: []*collectedMetric{
{
desc: c.ESMEInfo,
metric: createGaugeMetric(1, map[string]string{
"id": "101",
"name": "ESME",
"tags": ",tag1,tag2,",
"description": "desc",
}),
},
},
wantLogs: []string{`level=WARN msg="can't collect logs of the esme[101]" err=dummy`},
wantErrCounter: 1,
},
}
for _, tc := range cases {
initLoggerAndErrors()
c.logger = testLogger
c.errors = testErrors
c.client = tc.in
collected, err := collectMetrics(c, "esme")
require.NoError(t, err)
require.Equal(t, tc.wantLogs, collected.logged)
require.Equal(t, tc.wantErrCounter, *collected.errors.Counter.Value)
requireMetricsEqual(t, tc.wantMetrics, collected.collected)
}
}
|
package concurrent
import (
"fmt"
"os"
"os/signal"
"syscall"
"time"
)
// 生产者
func Producer(factor int, out chan<- int) {
for i := 0; ; i++ {
out <- i * factor
}
}
// 消费者
func Consumer(in <-chan int) {
for v := range in {
fmt.Println(v)
}
}
func main0() {
ch := make(chan int, 64)
go Producer(3, ch)
go Producer(5, ch)
go Consumer(ch)
// 休眠无法保证稳定的输出结果
time.Sleep(5 * time.Second)
}
func main_() {
ch := make(chan int, 64)
go Producer(3, ch)
go Producer(5, ch)
go Consumer(ch)
// Ctrl+C exit
sign := make(chan os.Signal, 1)
signal.Notify(sign, syscall.SIGINT, syscall.SIGTERM)
fmt.Printf("quit (%v) \n", <-sign)
}
|
package styles
import (
//"data-manager/types"
"grm-service/common"
"github.com/emicklei/go-restful"
api "github.com/emicklei/go-restful-openapi"
"grm-service/geoserver"
. "grm-service/util"
"data-manager/dbcentral/etcd"
"data-manager/dbcentral/pg"
)
type StyleSvc struct {
SysDB *pg.SystemDB
DynamicDB *etcd.DynamicDB
GeoServer *geoserver.GeoserverUtil
}
// WebService creates a new service that can handle REST requests for resources.
func (s StyleSvc) WebService() *restful.WebService {
ws := new(restful.WebService)
ws.Path("/styles").
//Consumes(restful.MIME_JSON, restful.MIME_JSON).
Produces(restful.MIME_JSON, restful.MIME_JSON)
tags := []string{TR("layer style")}
// 添加样式
ws.Route(ws.POST("").To(s.addStyle).
Doc(TR("add user style")).
Metadata(api.KeyOpenAPITags, tags).
Param(ws.HeaderParameter("auth-session", "user session").DataType("string").Required(true)).
Reads(addStyleReq{}).Writes(common.LayerStyle{}))
// 获取用户样式
ws.Route(ws.GET("").To(s.getStyles).
Doc(TR("get user styles")).
Metadata(api.KeyOpenAPITags, tags).
Param(ws.HeaderParameter("auth-session", "user session").DataType("string").Required(true)).
Param(ws.QueryParameter("style-type", "style type").DataType("string")).
Writes([]common.LayerStyle{}))
// 删除样式
ws.Route(ws.DELETE("/{style-id}").To(s.delStyle).
Doc(TR("get user styles")).
Metadata(api.KeyOpenAPITags, tags).
Param(ws.HeaderParameter("auth-session", "user session").DataType("string").Required(true)).
Param(ws.PathParameter("style-id", "style id").DataType("string").Required(true)))
// 修改样式
ws.Route(ws.PUT("/{style-id}").To(s.updateStyle).
Doc(TR("update user styles")).
Metadata(api.KeyOpenAPITags, tags).
Param(ws.HeaderParameter("auth-session", "user session").DataType("string").Required(true)).
Param(ws.PathParameter("style-id", "style id").DataType("string").Required(true)).
Reads(addStyleReq{}).Writes(common.LayerStyle{}))
// 获取样式sld
ws.Route(ws.GET("/{style-id}").To(s.getStyle).
Doc(TR("get style")).
Metadata(api.KeyOpenAPITags, tags).
Param(ws.HeaderParameter("auth-session", "user session").DataType("string").Required(true)).
Param(ws.PathParameter("style-id", "style id").DataType("string").Required(true)).
Writes(common.LayerStyle{}))
return ws
}
|
package gstypes
type GSArrayDSE struct {
array GSArrayGeneric
}
func (arr *GSArrayDSE) Push(element DataStoreElement) {
arr.array.Push(element)
}
func (arr *GSArrayDSE) Empty() bool {
return arr.array.Empty()
}
func (arr *GSArrayDSE) Length() int {
return arr.array.Length()
}
func (arr *GSArrayDSE) Get(idx int) DataStoreElement {
return arr.array.Get(idx).(DataStoreElement)
}
func (arr *GSArrayDSE) CurrentIndex() int {
return arr.array.CurrentIndex()
}
func (arr *GSArrayDSE) Remove(idx int) bool {
return arr.array.Remove(idx)
}
func (arr *GSArrayDSE) GetSlice() []DataStoreElement {
slice := arr.array.GetSlice()
dataStoreElementArray := make([]DataStoreElement, arr.array.Count)
for idx, element := range slice {
dataStoreElementArray[idx] = element.(DataStoreElement)
}
return dataStoreElementArray
}
func NewGSarrayDSE() GSArrayDSE {
arr := GSArrayDSE{
array: NewGSArray()}
return arr
}
|
package api
import (
"InkaTry/warehouse-storage-be/internal/http/admin/dtos"
"InkaTry/warehouse-storage-be/internal/pkg/http/responder"
"context"
"net/http"
)
func ListWarehouses(handlerfunc func(ctx context.Context) (*dtos.ListWareshousesResponse, error)) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
data, err := handlerfunc(r.Context())
if err != nil {
responder.ResponseError(w, err)
return
}
responder.ResponseOK(w, responder.AdvanceCommonResponse{
Status: 0,
Description: "success",
Data: data,
})
}
}
|
/*
Given two string arrays word1 and word2, return true if the two arrays represent the same string, and false otherwise.
A string is represented by an array if the array elements concatenated in order forms the string.
Example 1:
Input: word1 = ["ab", "c"], word2 = ["a", "bc"]
Output: true
Explanation:
word1 represents string "ab" + "c" -> "abc"
word2 represents string "a" + "bc" -> "abc"
The strings are the same, so return true.
Example 2:
Input: word1 = ["a", "cb"], word2 = ["ab", "c"]
Output: false
Example 3:
Input: word1 = ["abc", "d", "defg"], word2 = ["abcddefg"]
Output: true
Constraints:
1 <= word1.length, word2.length <= 10^3
1 <= word1[i].length, word2[i].length <= 10^3
1 <= sum(word1[i].length), sum(word2[i].length) <= 10^3
word1[i] and word2[i] consist of lowercase letters.
*/
package main
import (
"strings"
)
func main() {
assert(equivalent([]string{"ab", "c"}, []string{"a", "bc"}) == true)
assert(equivalent([]string{"a", "cb"}, []string{"ab", "c"}) == false)
assert(equivalent([]string{"abc", "d", "defg"}, []string{"abcddefg"}) == true)
}
func assert(x bool) {
if !x {
panic("assertion failed")
}
}
func equivalent(a, b []string) bool {
return strings.Join(a, "") == strings.Join(b, "")
}
|
package main
import (
"bufio"
"fmt"
"os"
"runtime"
"github.com/goldeneggg/ipcl/lib/parser"
"github.com/goldeneggg/ipcl/lib/writer"
"github.com/jessevdk/go-flags"
)
const (
Version = "0.3.0"
)
// element names need to Uppercase
type options struct {
Help bool `short:"h" long:"help" description:"Show help message"` // not "help" but "Help", because cause error using "-h" option
File string `short:"f" long:"file" description:"Filepath listed target CIDR"`
IsCsv bool `short:"c" long:"csv" description:"Output format is csv"`
IsTsv bool `short:"t" long:"tsv" description:"Output format is tsv"`
Version bool `short:"v" long:"version" description:"Print version"`
}
type optArgs struct {
opts *options
args []string
}
func main() {
var status int
// handler for return
defer func() { os.Exit(status) }()
// parse option args
opts := &options{}
parser := flags.NewParser(opts, flags.PrintErrors)
args, err := parser.Parse()
if err != nil {
fmt.Fprintln(os.Stderr, err)
printHelp()
status = 1
return
}
// print help
if opts.Help {
printHelp()
return
}
// print version
if opts.Version {
fmt.Fprintf(os.Stderr, "Ipcl: version %s (%s)\n", Version, runtime.GOARCH)
return
}
// get source CIDRs
oa := &optArgs{opts, args}
cidrs, e := getCIDRs(oa)
if e != nil {
fmt.Printf("%s\n", e)
printHelp()
status = 1
return
}
// write
write(cidrs, oa)
}
func getCIDRs(oa *optArgs) ([]parser.CIDRInfo, error) {
var cidrStrs []string
var cidrs []parser.CIDRInfo
ac := len(oa.args)
switch {
case ac == 1:
cidrStrs = append(cidrStrs, oa.args[0])
case ac > 1:
cidrStrs = oa.args
case oa.opts.File != "":
var e error
cidrStrs, e = fromFile(oa)
if e != nil {
return cidrs, e
}
default:
return cidrs, fmt.Errorf("Target CIDR(or CIDR list file) is not assigned\n")
}
for i, cs := range cidrStrs {
c, e := parser.Parse(cs)
if e != nil {
fmt.Fprintf(os.Stderr, "CIDR string[%d] %s validate error: %s\n", i, cs, e)
} else {
cidrs = append(cidrs, c)
}
}
return cidrs, nil
}
func fromFile(oa *optArgs) ([]string, error) {
cidrs := make([]string, 0, 10)
f, err := os.Open(oa.opts.File)
if err != nil {
return cidrs, err
}
defer f.Close()
scanner := bufio.NewScanner(f)
for scanner.Scan() {
cidrs = append(cidrs, scanner.Text())
}
if serr := scanner.Err(); serr != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
return cidrs, err
}
return cidrs, nil
}
func write(cidrs []parser.CIDRInfo, oa *optArgs) {
w := writer.NewWriter(oa.opts.IsCsv, oa.opts.IsTsv)
w.Write(cidrs)
}
func printHelp() {
h := `
Usage:
ipcl [OPTIONS] <CIDR TEXT | -f <FILE>>
Application Options:
-f, --file= Filepath listed target CIDR
-c, --csv= Output format is csv
-t, --tsv= Output format is tsv
-v, --version Print version
Help Options:
-h, --help Show this help message
`
os.Stderr.Write([]byte(h))
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.