text stringlengths 11 4.05M |
|---|
package confsvr
import (
"bufio"
"fmt"
json "github.com/json-iterator/go"
"github.com/oceanho/gw/sdk/confsvr/param"
"io"
"io/ioutil"
"net/http"
"strings"
)
type Client struct {
options *Option
}
type Option struct {
Addr string
Service string
Version string
Proto string
MaxRetries int
QueryStateInterval int
}
func (c *Client) Do(req param.IRequest, output interface{}) (int, error) {
var reader io.Reader
var buffer bufio.ReadWriter
body := req.Body()
if len(body) > 0 {
reader = &buffer
buffer.Write(req.Body())
}
uri := req.Url()
uri = strings.TrimLeft(uri, "/")
uri = strings.TrimRight(uri, "/")
url := fmt.Sprintf("%s/%s/%s/%s", c.options.Addr, c.options.Version, c.options.Service, uri)
oriReq, _ := http.NewRequest(req.Method(), url, reader)
for k, header := range req.Headers() {
oriReq.Header.Set(k, header)
}
client := http.DefaultClient
resp, err := client.Do(oriReq)
if err != nil {
return resp.StatusCode, fmt.Errorf("do http request: %v", err)
}
defer resp.Body.Close()
b, err := ioutil.ReadAll(resp.Body)
if err != nil {
return resp.StatusCode, fmt.Errorf("read resp body: %v", err)
}
if !param.IsHttpSucc(resp.StatusCode) {
return resp.StatusCode, fmt.Errorf("status code [%d] are not excepted, resp text: \"%s\"", resp.StatusCode, string(b))
}
err = json.Unmarshal(b, output)
if err != nil {
return resp.StatusCode, fmt.Errorf("decode str to json: \"%s\", %v", string(b), err)
}
return resp.StatusCode, nil
}
var (
defaultAddr = "https://127.0.0.1:8080"
defaultVersion = "//v1"
defaultService = "confsvr"
defaultProto = "http"
defaultMaxRetries = 10
defaultPullInterval = 15
)
func DefaultOptions() *Option {
return &Option{
Addr: defaultAddr,
Proto: defaultProto,
Service: defaultService,
Version: defaultVersion,
MaxRetries: defaultMaxRetries,
QueryStateInterval: defaultPullInterval,
}
}
func NewClient(opts *Option) *Client {
opts.Addr = strings.TrimRight(opts.Addr, "/")
opts.Version = strings.TrimLeft(opts.Version, "/")
opts.Version = strings.TrimRight(opts.Version, "/")
client := &Client{
options: opts,
}
return client
}
|
package bd
import (
"context"
"time"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func BorroTweet(ID string, UserID string) error {
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel() // me cancela el contexto de arriba pero de ultimo por el defer
db := MongoCN.Database("twittor") //el mongo CN ya lo reconoce por que está en el mismo package
col := db.Collection("tweet") // acá se conecta a la colección de usuario dentro de la database twittor
objID, _ := primitive.ObjectIDFromHex(ID)
condicion := bson.M{
"_id": objID,
"userid": UserID,
}
_, err := col.DeleteOne(ctx, condicion)
return err
}
|
package main
import (
"os"
"log"
"path/filepath"
"github.com/fsnotify/fsnotify"
"sync"
"time"
"strings"
"os/exec"
)
func dataRefreshWatcher(watcher *fsnotify.Watcher, targetDir string) {
waitMutex := &sync.Mutex{}
waitMap := make(map[string]chan bool)
for {
select {
case event := <-watcher.Events:
if event.Op&fsnotify.Write == fsnotify.Write {
if strings.ToLower(event.Name[len(event.Name)-4:len(event.Name)]) != ".png" {
continue
}
var abortCh chan bool
waitMutex.Lock()
// abort previous refresh job
if prevAbortCh, exist := waitMap[event.Name]; exist {
prevAbortCh <- true
abortCh = prevAbortCh
} else {
abortCh = make(chan bool, 1)
waitMap[event.Name] = abortCh
}
waitMutex.Unlock()
go func(abortCh chan bool, filename string) {
select {
case <-abortCh:
// aborted; do nothing
case <-time.After(1 * time.Second):
log.Printf("File modified (stable): %v", filename)
convertFile(filename, targetDir)
waitMutex.Lock()
delete(waitMap, filename)
waitMutex.Unlock()
close(abortCh)
}
}(abortCh, event.Name)
}
case err := <-watcher.Errors:
log.Println("error:", err)
}
}
}
func convertFile(filename string, targetDir string) {
filenameLen := len(filename)
var convertCmd *exec.Cmd
if filename[filenameLen-6:filenameLen] == "-a.png" {
convertCmd = exec.Command(".\\bin\\etcpack.exe", filename, targetDir, "-s", "fast", "-c", "etc1", "-ktx", "-as")
} else if filename[filenameLen-8:filenameLen] == "-mip.png" {
convertCmd = exec.Command(".\\bin\\etcpack.exe", filename, targetDir, "-s", "fast", "-c", "etc1", "-ktx", "-mipmaps")
} else if filename[filenameLen-9:filenameLen] == "-amip.png" {
convertCmd = exec.Command(".\\bin\\etcpack.exe", filename, targetDir, "-s", "fast", "-c", "etc1", "-ktx", "-as", "-mipmaps")
} else {
convertCmd = exec.Command(".\\bin\\etcpack.exe", filename, targetDir, "-s", "fast", "-c", "etc1", "-ktx")
}
err := convertCmd.Run()
if err != nil {
log.Fatal(err)
}
}
const (
ServiceName = "art-watcher"
)
func main() {
// Set default log format
log.SetFlags(log.LstdFlags | log.Lshortfile)
log.SetOutput(os.Stdout)
log.Printf("Greetings from %v service", ServiceName)
if len(os.Args) < 3 {
log.Printf("Should provide resource source directory glob and target directory as first and second argument.")
return
}
sourceDirGlob := os.Args[1]
targetDir := os.Args[2]
log.Printf("Source directory glob: %v", sourceDirGlob)
log.Printf("Target directory: %v", targetDir)
sourceDirs, err := filepath.Glob(os.Args[1])
if err != nil {
log.Fatal(err)
}
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
for _, f := range sourceDirs {
log.Printf("Watching source dir %v", f)
watcher.Add(f)
}
done := make(chan bool)
go dataRefreshWatcher(watcher, targetDir)
<-done
}
|
package plugin
import (
"fmt"
"log"
"sort"
"strings"
"sync"
plugin_v1 "github.com/cyberark/secretless-broker/internal/plugin/v1"
config_v2 "github.com/cyberark/secretless-broker/pkg/secretless/config/v2"
)
// Resolver is used to instantiate providers and resolve credentials
type Resolver struct {
EventNotifier plugin_v1.EventNotifier
ProviderFactories map[string]func(plugin_v1.ProviderOptions) (plugin_v1.Provider, error)
Providers map[string]plugin_v1.Provider
LogFatalf func(string, ...interface{})
}
// NewResolver instantiates providers based on the name and ProviderOptions
func NewResolver(
providerFactories map[string]func(plugin_v1.ProviderOptions) (plugin_v1.Provider, error),
eventNotifier plugin_v1.EventNotifier,
LogFatalFunc func(string, ...interface{}),
) plugin_v1.Resolver {
if LogFatalFunc == nil {
LogFatalFunc = log.Fatalf
}
return &Resolver{
EventNotifier: eventNotifier,
LogFatalf: LogFatalFunc,
ProviderFactories: providerFactories,
Providers: make(map[string]plugin_v1.Provider),
}
}
// Provider finds or creates a named provider.
func (resolver *Resolver) Provider(name string) (provider plugin_v1.Provider, err error) {
mutex := &sync.Mutex{}
mutex.Lock()
defer mutex.Unlock()
if provider = resolver.Providers[name]; provider != nil {
return
}
// If we don't know what this provider is, it's a critical error
if _, ok := resolver.ProviderFactories[name]; !ok {
resolver.LogFatalf("ERROR: Provider '%s' cannot be found", name)
}
providerOptions := plugin_v1.ProviderOptions{
Name: name,
}
providerFactory := resolver.ProviderFactories[name]
log.Printf("Instantiating provider '%s'", name)
provider, err = providerFactory(providerOptions)
if err != nil {
return nil, err
}
resolver.Providers[name] = provider
return
}
func (resolver *Resolver) resolveForProvider(
providerID string,
credentials []*config_v2.Credential,
) (plugin_v1.Provider, map[string]plugin_v1.ProviderResponse, string) {
provider, err := resolver.Provider(providerID)
if err != nil {
resolver.LogFatalf("ERROR: Provider '%s' could not be used! %v", providerID, err)
}
// Create secretIds slice and credentialBySecretId map
secretIds := make([]string, len(credentials))
for idx, cred := range credentials {
secretIds[idx] = cred.Get
}
// Resolves all credentials for current provider
var hasErrors bool
var providerErrStrings []string
providerResponses, err := provider.GetValues(secretIds...)
if err != nil {
hasErrors = true
providerErrStrings = append(
providerErrStrings,
err.Error(),
)
}
// Collect errors from provider responses
for _, providerResponse := range providerResponses {
if providerResponse.Error != nil {
hasErrors = true
providerErrStrings = append(
providerErrStrings,
providerResponse.Error.Error(),
)
continue
}
}
if hasErrors {
// Sort the error strings to provide deterministic output
sort.Strings(providerErrStrings)
errInfo := fmt.Sprintf(
"ERROR: Resolving credentials from provider '%s' failed: %v",
provider.GetName(),
strings.Join(providerErrStrings, ", "),
)
return nil, nil, errInfo
}
return provider, providerResponses, ""
}
// Resolve accepts n list of Providers and a list of Credentials and
// attempts to obtain the value of each Credential from the appropriate Provider.
func (resolver *Resolver) Resolve(credentials []*config_v2.Credential) (map[string][]byte, error) {
if len(credentials) == 0 {
resolver.LogFatalf("ERROR! Credentials not defined in Resolve call!")
}
result := make(map[string][]byte)
errorStrings := make([]string, 0, len(credentials))
var err error
// Group credentials by provider
credentialsByProvider := groupCredentialsByProvider(credentials)
// Resolve credentials by provider
for providerID, credentialsForProvider := range credentialsByProvider {
provider, providerResponses, errStr := resolver.resolveForProvider(
providerID,
credentialsForProvider,
)
if errStr != "" {
log.Println(errStr)
errorStrings = append(errorStrings, errStr)
continue
}
// Set provider responses on result map before returning
for _, credential := range credentialsForProvider {
credentialName := credential.Name
secretValue := providerResponses[credential.Get].Value
result[credentialName] = secretValue
if resolver.EventNotifier != nil {
resolver.EventNotifier.ResolveCredential(
provider,
credentialName,
secretValue,
)
}
}
}
err = nil
if len(errorStrings) > 0 {
// Sort the error strings to provide deterministic output
sort.Strings(errorStrings)
err = fmt.Errorf(strings.Join(errorStrings, "\n"))
}
return result, err
}
func groupCredentialsByProvider(
credentials []*config_v2.Credential,
) map[string][]*config_v2.Credential {
credentialsByProvider := make(map[string][]*config_v2.Credential)
for _, credential := range credentials {
credentialsByProvider[credential.From] = append(
credentialsByProvider[credential.From],
credential,
)
}
return credentialsByProvider
}
|
// Copyright 2020 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package crostini
import (
"context"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"reflect"
"time"
"chromiumos/tast/errors"
"chromiumos/tast/local/chrome"
"chromiumos/tast/local/chrome/uiauto"
"chromiumos/tast/local/chrome/uiauto/filesapp"
"chromiumos/tast/local/chrome/uiauto/nodewith"
"chromiumos/tast/local/chrome/uiauto/role"
"chromiumos/tast/local/crostini"
"chromiumos/tast/local/cryptohome"
"chromiumos/tast/local/input"
"chromiumos/tast/testing"
)
func init() {
testing.AddTest(&testing.Test{
Func: CopyFilesToLinuxFiles,
LacrosStatus: testing.LacrosVariantUnneeded,
Desc: "Tests copying files to Linux files using a pre-built crostini image",
Contacts: []string{"clumptini+oncall@google.com"},
Attr: []string{"group:mainline"},
SoftwareDeps: []string{"chrome", "vm_host"},
Params: []testing.Param{
// Parameters generated by params_test.go. DO NOT EDIT.
{
Name: "buster_stable",
ExtraSoftwareDeps: []string{"dlc"},
ExtraHardwareDeps: crostini.CrostiniStable,
Fixture: "crostiniBuster",
Timeout: 7 * time.Minute,
}, {
Name: "buster_unstable",
ExtraAttr: []string{"informational"},
ExtraSoftwareDeps: []string{"dlc"},
ExtraHardwareDeps: crostini.CrostiniUnstable,
Fixture: "crostiniBuster",
Timeout: 7 * time.Minute,
}, {
Name: "bullseye_stable",
ExtraSoftwareDeps: []string{"dlc"},
ExtraHardwareDeps: crostini.CrostiniStable,
Fixture: "crostiniBullseye",
Timeout: 7 * time.Minute,
}, {
Name: "bullseye_unstable",
ExtraAttr: []string{"informational"},
ExtraSoftwareDeps: []string{"dlc"},
ExtraHardwareDeps: crostini.CrostiniUnstable,
Fixture: "crostiniBullseye",
Timeout: 7 * time.Minute,
},
},
})
}
func CopyFilesToLinuxFiles(ctx context.Context, s *testing.State) {
tconn := s.FixtValue().(crostini.FixtureData).Tconn
cont := s.FixtValue().(crostini.FixtureData).Cont
keyboard := s.FixtValue().(crostini.FixtureData).KB
cr := s.FixtValue().(crostini.FixtureData).Chrome
if err := cont.Cleanup(ctx, "."); err != nil {
s.Fatal("Failed to cleanup the home directory before the test: ", err)
}
// Open Files app.
filesApp, err := filesapp.Launch(ctx, tconn)
if err != nil {
s.Fatal("Failed to open Files app: ", err)
}
testFiles := []string{"testfile1.txt", "testfile2.txt", "testfile3.txt"}
s.Log("Test copying files to Linux files")
downloadsPath, err := cryptohome.DownloadsPath(ctx, cr.NormalizedUser())
if err != nil {
s.Fatal("Failed to get user's Download path: ", err)
}
// Create some files in Downloads.
for _, file := range testFiles {
path := filepath.Join(downloadsPath, file)
if err := ioutil.WriteFile(path, []byte("test"), 0644); err != nil {
s.Fatal("Failed to create file in Downloads: ", err)
}
defer os.Remove(path)
}
// Copy files from Downloads to Linux files.
if err := copyFilesToLinuxfiles(ctx, tconn, filesApp, keyboard, testFiles); err != nil {
s.Fatal("Failed to copy test files to Linux files: ", err)
}
// Check the file list in home directory is equal to the copied file list.
fileList, err := cont.GetFileList(ctx, ".")
if err != nil {
s.Fatal("Failed to get files in home directory in container: ", err)
}
if !reflect.DeepEqual(testFiles, fileList) {
s.Fatalf("Found unexpected files in Linux files; got %q, want %q", fileList, testFiles)
}
}
// copyFilesToLinuxfiles copies all files in Downloads to Linux files.
func copyFilesToLinuxfiles(ctx context.Context, tconn *chrome.TestConn, filesApp *filesapp.FilesApp, keyboard *input.KeyboardEventWriter, testFiles []string) error {
steps := []uiauto.Action{filesApp.OpenDownloads()}
// Steps to wait all files to display.
for _, file := range testFiles {
steps = append(steps, filesApp.SelectFile(file))
}
copyMsg := nodewith.Name(fmt.Sprintf("Copying %d items to %s", len(testFiles), "Linux files")).Role(role.StaticText)
ui := uiauto.New(tconn)
steps = append(steps,
// Select all files.
keyboard.AccelAction("ctrl+A"),
// Copy all files.
keyboard.AccelAction("ctrl+C"),
// Open "Linux files" to paste.
filesApp.OpenLinuxFiles(),
// Paste all files.
keyboard.AccelAction("ctrl+V"))
if err := uiauto.Combine("copy files from Downloads to Linux files", steps...)(ctx); err != nil {
return err
}
if err := filesApp.WithTimeout(10 * time.Second).WaitUntilExists(copyMsg)(ctx); err != nil {
testing.ContextLog(ctx, "Copying message was not found")
}
if err := ui.WithTimeout(time.Minute).WaitUntilGone(copyMsg)(ctx); err != nil {
return errors.Wrap(err, "failed to copy files to Linux files in 1 minute")
}
return nil
}
|
package controllers
import (
"encoding/json"
"github.com/RainerGevers/tasker/config"
"github.com/RainerGevers/tasker/lib/argon"
"github.com/RainerGevers/tasker/models"
"github.com/RainerGevers/tasker/serializers"
"github.com/dgrijalva/jwt-go"
uuid "github.com/satori/go.uuid"
"io/ioutil"
"log"
"net/http"
"os"
"time"
)
type user struct {
User userParams `json:"user"`
}
type userParams struct {
Username string `json:"username"`
Password string `json:"password"`
Email string `json:"email"`
}
type loginParams struct {
Email string `json:"email"`
Password string `json:"password"`
}
type apiError struct {
Reference string `json:"reference"`
Message string `json:"message"`
}
func UsersRegister(env *config.Env, w http.ResponseWriter, r *http.Request) {
var userData user
data, err := ioutil.ReadAll(r.Body)
if err != nil {
return
}
err = json.Unmarshal(data, &userData)
if err != nil {
log.Fatal(err)
return
}
user := models.User{}
dbResult := env.Database.Where("email = ?", userData.User.Email).First(&user)
if dbResult.Error == nil {
err := apiError{Reference: "user_already_registered", Message: "This user email has already registered"}
response, _ := json.Marshal(err)
w.WriteHeader(409)
_, _ = w.Write(response)
return
}
passwordHash, err := argon.GeneratePassword(userData.User.Password)
if err != nil {
err := apiError{Reference: "password_hash_failure", Message: "There was a problem while trying to hash the password."}
response, _ := json.Marshal(err)
w.WriteHeader(422)
_, _ = w.Write(response)
return
}
user = models.User{Password: passwordHash, Username: userData.User.Username, Email: userData.User.Email, Uuid: uuid.NewV4().String()}
dbResult = env.Database.Create(&user)
if dbResult.Error != nil {
err := apiError{Reference: "user_insert_error", Message: "There was a problem inserting the user into the database"}
response, _ := json.Marshal(err)
w.WriteHeader(422)
_, _ = w.Write(response)
return
}
userSerialized := serializers.UserSerializer{Username: user.Username, Email: user.Email, Uuid: user.Uuid}
response, _ := json.Marshal(userSerialized)
w.WriteHeader(201)
_, _ = w.Write(response)
}
func UserLogin(env *config.Env, w http.ResponseWriter, r *http.Request) {
var loginData loginParams
data, err := ioutil.ReadAll(r.Body)
if err != nil {
return
}
err = json.Unmarshal(data, &loginData)
if err != nil {
log.Fatal(err)
return
}
if loginData.Email == "" || loginData.Password == "" {
err := apiError{Reference: "email_or_password_blank", Message: "The email or password appears to be blank."}
response, _ := json.Marshal(err)
w.WriteHeader(422)
_, _ = w.Write(response)
return
}
user := models.User{}
dbResult := env.Database.Where("email = ?", loginData.Email).First(&user)
if dbResult.Error != nil {
err := apiError{Reference: "email_or_password_incorrect", Message: "The email or password appears to be incorrect."}
response, _ := json.Marshal(err)
w.WriteHeader(422)
_, _ = w.Write(response)
return
}
passwordMatch, err := argon.ComparePassword(loginData.Password, user.Password)
if err != nil || passwordMatch == false {
err := apiError{Reference: "email_or_password_incorrect", Message: "The email or password appears to be incorrect."}
response, _ := json.Marshal(err)
w.WriteHeader(422)
_, _ = w.Write(response)
return
}
session := models.Session{User: user, Uuid: uuid.NewV4().String(), ExpiresAt: time.Now().Add(time.Hour * 24), RefreshCode: uuid.NewV4().String()}
env.Database.Create(&session)
token := jwt.New(jwt.SigningMethodHS512)
claims := token.Claims.(jwt.MapClaims)
claims["uuid"] = session.Uuid
claims["exp"] = time.Now().Add(time.Hour * 24).Unix()
t, err := token.SignedString([]byte(os.Getenv("JWT_SECRET")))
if err != nil {
env.Logger.Println(err)
err := apiError{Reference: "token_error", Message: "There was a error while trying to generate token."}
response, _ := json.Marshal(err)
w.WriteHeader(422)
_, _ = w.Write(response)
return
}
refreshToken := jwt.New(jwt.SigningMethodHS512)
refreshClaims := refreshToken.Claims.(jwt.MapClaims)
refreshClaims["uuid"] = session.RefreshCode
refreshClaims["exp"] = time.Now().Add(time.Hour * 24 * 14)
tr, err := refreshToken.SignedString([]byte(os.Getenv("JWT_SECRET")))
if err != nil {
env.Logger.Println(err)
err := apiError{Reference: "token_error", Message: "There was a error while trying to generate token."}
response, _ := json.Marshal(err)
w.WriteHeader(422)
_, _ = w.Write(response)
return
}
loginSerialized := serializers.LoginSerializer{Uuid: user.Uuid, Email: user.Email, Username: user.Username, AuthToken: t, RefreshToken: tr}
response, _ := json.Marshal(loginSerialized)
w.WriteHeader(200)
_, _ = w.Write(response)
}
|
/*
Copyright 2021 The KodeRover 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 service
import (
"github.com/koderover/zadig/lib/microservice/aslan/core/common/dao/models"
"github.com/koderover/zadig/lib/microservice/aslan/core/common/dao/repo"
e "github.com/koderover/zadig/lib/tool/errors"
"github.com/koderover/zadig/lib/tool/xlog"
)
func InsertOperation(args *models.OperationLog, log *xlog.Logger) error {
err := repo.NewOperationLogColl().Insert(args)
if err != nil {
log.Errorf("insert operation log error: %v", err)
return e.ErrCreateOperationLog
}
return nil
}
func UpdateOperation(id string, status int, log *xlog.Logger) error {
err := repo.NewOperationLogColl().Update(id, status)
if err != nil {
log.Errorf("update operation log error: %v", err)
return e.ErrUpdateOperationLog
}
return nil
}
func FindOperation(args *repo.OperationLogArgs, log *xlog.Logger) ([]*models.OperationLog, int, error) {
resp, count, err := repo.NewOperationLogColl().Find(args)
if err != nil {
log.Errorf("find operation log error: %v", err)
return resp, count, e.ErrFindOperationLog
}
return resp, count, err
}
|
package apps
import (
"flag"
"fmt"
"os"
"strconv"
"net"
"github.com/BurntSushi/toml"
)
type DNSServerSetting struct {
Host string
}
type RedisSettings struct {
//Enable bool
Host string
Port int
DB int
Password string
}
func (s RedisSettings) Addr() string {
return s.Host + ":" + strconv.Itoa(s.Port)
}
type CacheSettings struct {
Backend string
Expire int
MaxCount int
}
type ResolvSetting struct {
Nameserver []string
}
func (c *ResolvSetting) DNSServers() []string {
var result []string
for _, nameserver := range c.Nameserver {
result = append(result, net.JoinHostPort(nameserver, "53"))
}
return result
}
type LogSettings struct {
Stdout bool
File string
Level string
}
type Settings struct {
DbType string `toml:"DbType"`
Area string
Version string
Debug bool
Author string
Server DNSServerSetting `toml:"server"`
Redis RedisSettings `toml:"redis"`
Log LogSettings `toml:"log"`
Cache CacheSettings `toml:"cache"`
Resolv ResolvSetting `toml:"resolv"`
}
var (
Config Settings
)
func init() {
var configFile string
flag.StringVar(&configFile, "c", "/Users/fw/go/src/github.com/mefuwei/wdns/etc/dns.conf", "./wdns -c etc/dns.conf")
flag.Parse()
if _, err := toml.DecodeFile(configFile, &Config); err != nil {
fmt.Printf("%s is valid toml config \n", configFile)
fmt.Println(err)
os.Exit(1)
}
}
|
package model
import (
"github.com/caos/zitadel/internal/model"
"time"
)
type IamMemberView struct {
UserID string
IamID string
UserName string
Email string
FirstName string
LastName string
DisplayName string
Roles []string
CreationDate time.Time
ChangeDate time.Time
Sequence uint64
}
type IamMemberSearchRequest struct {
Offset uint64
Limit uint64
SortingColumn IamMemberSearchKey
Asc bool
Queries []*IamMemberSearchQuery
}
type IamMemberSearchKey int32
const (
IamMemberSearchKeyUnspecified IamMemberSearchKey = iota
IamMemberSearchKeyUserName
IamMemberSearchKeyEmail
IamMemberSearchKeyFirstName
IamMemberSearchKeyLastName
IamMemberSearchKeyIamID
IamMemberSearchKeyUserID
)
type IamMemberSearchQuery struct {
Key IamMemberSearchKey
Method model.SearchMethod
Value interface{}
}
type IamMemberSearchResponse struct {
Offset uint64
Limit uint64
TotalResult uint64
Result []*IamMemberView
Sequence uint64
Timestamp time.Time
}
func (r *IamMemberSearchRequest) EnsureLimit(limit uint64) {
if r.Limit == 0 || r.Limit > limit {
r.Limit = limit
}
}
|
package tradfri
import (
"encoding/json"
"fmt"
"github.com/dustin/go-coap"
"github.com/eriklupander/tradfri-go/dtlscoap"
"github.com/eriklupander/tradfri-go/model"
"github.com/sirupsen/logrus"
"strconv"
"strings"
)
// Client provides a declarative API for sending CoAP messages to the gateway over DTLS.
type Client struct {
dtlsclient *dtlscoap.DtlsClient
}
// NewTradfriClient creates a new instance of Client, including initiating the DTLS client.
func NewTradfriClient(gatewayAddress, clientID, psk string) *Client {
client := &Client{}
client.dtlsclient = dtlscoap.NewDtlsClient(gatewayAddress, clientID, psk)
return client
}
// PutDevicePositioning sets the positioning property (0-100) of the specified device.
func (tc *Client) PutDevicePositioning(deviceId string, positioning float32) (model.Result, error) {
payload := fmt.Sprintf(`{ "15015": [{ "5536": %f }] }`, positioning)
logrus.Infof("Payload is: %v", payload)
resp, err := tc.Call(tc.dtlsclient.BuildPUTMessage("/15001/"+deviceId, payload))
if err != nil {
return model.Result{}, err
}
logrus.Infof("Response: %+v", resp)
return model.Result{Msg: resp.Code.String()}, nil
}
// ListGroups lists all groups
func (tc *Client) ListGroups() ([]model.Group, error) {
groups := make([]model.Group, 0)
resp, err := tc.Call(tc.dtlsclient.BuildGETMessage("/15004"))
if err != nil {
logrus.WithError(err).Error("Unable to call Trådfri Gateway")
return groups, err
}
groupIds := make([]int, 0)
err = json.Unmarshal(resp.Payload, &groupIds)
if err != nil {
logrus.Info("Unable to parse groups list into JSON: " + err.Error())
return groups, err
}
for _, id := range groupIds {
group, _ := tc.GetGroup(strconv.Itoa(id))
groups = append(groups, group)
}
return groups, nil
}
// GetGroup gets the JSON representation of the specified group.
func (tc *Client) GetGroup(id string) (model.Group, error) {
resp, err := tc.Call(tc.dtlsclient.BuildGETMessage("/15004/" + id))
group := &model.Group{}
if err != nil {
return *group, err
}
err = json.Unmarshal(resp.Payload, &group)
if err != nil {
return *group, err
}
return *group, nil
}
// GetDevice gets the JSON representation of the specified device.
func (tc *Client) GetDevice(id string) (model.Device, error) {
device := &model.Device{}
resp, err := tc.Call(tc.dtlsclient.BuildGETMessage("/15001/" + id))
if err != nil {
return *device, err
}
err = json.Unmarshal(resp.Payload, &device)
if err != nil {
return *device, err
}
return *device, nil
}
// Get gets whatever is identified by the passed ID string.
func (tc *Client) Get(id string) (coap.Message, error) {
if !strings.HasPrefix(id, "/") {
id = "/" + id
}
return tc.Call(tc.dtlsclient.BuildGETMessage(id))
}
// Put puts the payload for whatever is identified by the passed ID string.
func (tc *Client) Put(id string, payload string) (coap.Message, error) {
if !strings.HasPrefix(id, "/") {
id = "/" + id
}
return tc.Call(tc.dtlsclient.BuildPUTMessage(id, payload))
}
// AuthExchange, see ref: https://community.openhab.org/t/ikea-tradfri-gateway/26135/148?u=kai
func (tc *Client) AuthExchange(clientId string) (model.TokenExchange, error) {
req := tc.dtlsclient.BuildPOSTMessage("/15011/9063", fmt.Sprintf(`{"9090":"%s"}`, clientId))
// Send CoAP message for token exchange
resp, err := tc.Call(req)
if err != nil {
logrus.WithError(err).Fatal("error performing call to Gateway for token exchange")
}
// Handle response and return
token := model.TokenExchange{}
err = json.Unmarshal(resp.Payload, &token)
if err != nil {
logrus.WithError(err).Fatal("error unmarhsalling response from Gateway for token exchange")
}
return token, nil
}
// Call is just a proxy to the underlying DtlsClient Call
func (tc *Client) Call(msg coap.Message) (coap.Message, error) {
return tc.dtlsclient.Call(msg)
}
|
package commands
import (
"strings"
"mvdan.cc/sh/v3/interp"
)
func IsIn(args []string) error {
if len(args) != 2 {
return interp.NewExitStatus(1)
}
values := strings.Split(args[1], " ")
for _, value := range values {
if value == args[0] {
return interp.NewExitStatus(0)
}
}
return interp.NewExitStatus(1)
}
|
// ===================================== //
// author: gavingqf //
// == Please don'g change me by hand == //
//====================================== //
/*you have defined the following interface:
type IConfig interface {
// load interface
Load(path string) bool
// clear interface
Clear()
}
*/
package base
import (
"shared/utility/glog"
"strings"
)
type CfgGraveyardBuildLevel struct {
Id int32
BuildId int32
Level int32
MainTowerLevelLimit int32
LevelUpConsume []string
LevelUpTime int32
LevelUpDropId int32
StoreLimit int32
ProduceLimit int32
ConsumeResource []string
ProduceTime int32
UnitCount []int32
}
type CfgGraveyardBuildLevelConfig struct {
data map[int32]*CfgGraveyardBuildLevel
}
func NewCfgGraveyardBuildLevelConfig() *CfgGraveyardBuildLevelConfig {
return &CfgGraveyardBuildLevelConfig{
data: make(map[int32]*CfgGraveyardBuildLevel),
}
}
func (c *CfgGraveyardBuildLevelConfig) Load(filePath string) bool {
parse := NewParser()
if err := parse.Load(filePath, true); err != nil {
glog.Info("Load", filePath, "err: ", err)
return false
}
// iterator all lines' content
for i := 2; i < parse.GetAllCount(); i++ {
data := new(CfgGraveyardBuildLevel)
/* parse Id field */
vId, _ := parse.GetFieldByName(uint32(i), "id")
var IdRet bool
data.Id, IdRet = String2Int32(vId)
if !IdRet {
glog.Error("Parse CfgGraveyardBuildLevel.Id field error,value:", vId)
return false
}
/* parse BuildId field */
vBuildId, _ := parse.GetFieldByName(uint32(i), "buildId")
var BuildIdRet bool
data.BuildId, BuildIdRet = String2Int32(vBuildId)
if !BuildIdRet {
glog.Error("Parse CfgGraveyardBuildLevel.BuildId field error,value:", vBuildId)
return false
}
/* parse Level field */
vLevel, _ := parse.GetFieldByName(uint32(i), "level")
var LevelRet bool
data.Level, LevelRet = String2Int32(vLevel)
if !LevelRet {
glog.Error("Parse CfgGraveyardBuildLevel.Level field error,value:", vLevel)
return false
}
/* parse MainTowerLevelLimit field */
vMainTowerLevelLimit, _ := parse.GetFieldByName(uint32(i), "mainTowerLevelLimit")
var MainTowerLevelLimitRet bool
data.MainTowerLevelLimit, MainTowerLevelLimitRet = String2Int32(vMainTowerLevelLimit)
if !MainTowerLevelLimitRet {
glog.Error("Parse CfgGraveyardBuildLevel.MainTowerLevelLimit field error,value:", vMainTowerLevelLimit)
return false
}
/* parse LevelUpConsume field */
vecLevelUpConsume, _ := parse.GetFieldByName(uint32(i), "levelUpConsume")
arrayLevelUpConsume := strings.Split(vecLevelUpConsume, ",")
for j := 0; j < len(arrayLevelUpConsume); j++ {
v := arrayLevelUpConsume[j]
data.LevelUpConsume = append(data.LevelUpConsume, v)
}
/* parse LevelUpTime field */
vLevelUpTime, _ := parse.GetFieldByName(uint32(i), "levelUpTime")
var LevelUpTimeRet bool
data.LevelUpTime, LevelUpTimeRet = String2Int32(vLevelUpTime)
if !LevelUpTimeRet {
glog.Error("Parse CfgGraveyardBuildLevel.LevelUpTime field error,value:", vLevelUpTime)
return false
}
/* parse LevelUpDropId field */
vLevelUpDropId, _ := parse.GetFieldByName(uint32(i), "levelUpDropId")
var LevelUpDropIdRet bool
data.LevelUpDropId, LevelUpDropIdRet = String2Int32(vLevelUpDropId)
if !LevelUpDropIdRet {
glog.Error("Parse CfgGraveyardBuildLevel.LevelUpDropId field error,value:", vLevelUpDropId)
return false
}
/* parse StoreLimit field */
vStoreLimit, _ := parse.GetFieldByName(uint32(i), "storeLimit")
var StoreLimitRet bool
data.StoreLimit, StoreLimitRet = String2Int32(vStoreLimit)
if !StoreLimitRet {
glog.Error("Parse CfgGraveyardBuildLevel.StoreLimit field error,value:", vStoreLimit)
return false
}
/* parse ProduceLimit field */
vProduceLimit, _ := parse.GetFieldByName(uint32(i), "produceLimit")
var ProduceLimitRet bool
data.ProduceLimit, ProduceLimitRet = String2Int32(vProduceLimit)
if !ProduceLimitRet {
glog.Error("Parse CfgGraveyardBuildLevel.ProduceLimit field error,value:", vProduceLimit)
return false
}
/* parse ConsumeResource field */
vecConsumeResource, _ := parse.GetFieldByName(uint32(i), "consumeResource")
arrayConsumeResource := strings.Split(vecConsumeResource, ",")
for j := 0; j < len(arrayConsumeResource); j++ {
v := arrayConsumeResource[j]
data.ConsumeResource = append(data.ConsumeResource, v)
}
/* parse ProduceTime field */
vProduceTime, _ := parse.GetFieldByName(uint32(i), "produceTime")
var ProduceTimeRet bool
data.ProduceTime, ProduceTimeRet = String2Int32(vProduceTime)
if !ProduceTimeRet {
glog.Error("Parse CfgGraveyardBuildLevel.ProduceTime field error,value:", vProduceTime)
return false
}
/* parse UnitCount field */
vecUnitCount, _ := parse.GetFieldByName(uint32(i), "unitCount")
if vecUnitCount != "" {
arrayUnitCount := strings.Split(vecUnitCount, ",")
for j := 0; j < len(arrayUnitCount); j++ {
v, ret := String2Int32(arrayUnitCount[j])
if !ret {
glog.Error("Parse CfgGraveyardBuildLevel.UnitCount field error, value:", arrayUnitCount[j])
return false
}
data.UnitCount = append(data.UnitCount, v)
}
}
if _, ok := c.data[data.Id]; ok {
glog.Errorf("Find %d repeated", data.Id)
return false
}
c.data[data.Id] = data
}
return true
}
func (c *CfgGraveyardBuildLevelConfig) Clear() {
}
func (c *CfgGraveyardBuildLevelConfig) Find(id int32) (*CfgGraveyardBuildLevel, bool) {
v, ok := c.data[id]
return v, ok
}
func (c *CfgGraveyardBuildLevelConfig) GetAllData() map[int32]*CfgGraveyardBuildLevel {
return c.data
}
func (c *CfgGraveyardBuildLevelConfig) Traverse() {
for _, v := range c.data {
glog.Info(v.Id, ",", v.BuildId, ",", v.Level, ",", v.MainTowerLevelLimit, ",", v.LevelUpConsume, ",", v.LevelUpTime, ",", v.LevelUpDropId, ",", v.StoreLimit, ",", v.ProduceLimit, ",", v.ConsumeResource, ",", v.ProduceTime, ",", v.UnitCount)
}
}
|
package models
import (
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/mysql"
)
type User struct {
gorm.Model
Username string
Password string
}
|
package main
import (
"image"
_ "image/png"
"math"
"math/rand"
"os"
"time"
"github.com/ByteArena/box2d"
"github.com/faiface/pixel"
"github.com/faiface/pixel/imdraw"
"github.com/faiface/pixel/pixelgl"
"golang.org/x/image/colornames"
)
const (
// Prepare for simulation. Typically we use a time step of 1/60 of a
// second (60Hz) and 10 iterations. This provides a high quality simulation
// in most game scenarios.
velocityIterations = 8
positionIterations = 3
camZoomSpeed = 1.2
)
func loadPicture(path string) (pixel.Picture, error) {
file, err := os.Open(path)
if err != nil {
return nil, err
}
defer file.Close()
img, _, err := image.Decode(file)
if err != nil {
return nil, err
}
return pixel.PictureDataFromImage(img), nil
}
func loadSprites() []*pixel.Sprite {
spritesheet, err := loadPicture("falling/trees.png")
if err != nil {
panic(err)
}
var sprites []*pixel.Sprite
for x := spritesheet.Bounds().Min.X; x < spritesheet.Bounds().Max.X; x += 32 {
for y := spritesheet.Bounds().Min.Y; y < spritesheet.Bounds().Max.Y; y += 32 {
sprites = append(sprites, pixel.NewSprite(spritesheet, pixel.R(x, y, x+32, y+32)))
}
}
return sprites
}
func generateTree(world *box2d.B2World) *box2d.B2Body {
x := rand.Float64()*200 - 100
y := rand.Float64()*80 + 8
bodyDef := box2d.MakeB2BodyDef()
bodyDef.Type = box2d.B2BodyType.B2_dynamicBody
bodyDef.Position.Set(x, y)
bodyDef.LinearDamping = 0.02
body := world.CreateBody(&bodyDef)
dynamicBox := box2d.MakeB2CircleShape()
dynamicBox.SetRadius(1)
fixtureDef := box2d.MakeB2FixtureDef()
fixtureDef.Shape = &dynamicBox
fixtureDef.Density = 1
fixtureDef.Friction = 1
fixtureDef.Restitution = 0.4
body.CreateFixtureFromDef(&fixtureDef)
return body
}
func createWorld() (*box2d.B2World, *imdraw.IMDraw) {
// Define the gravity vector.
gravity := box2d.MakeB2Vec2(0.0, -10.0)
// Construct a world object, which will hold and simulate the rigid bodies.
world := box2d.MakeB2World(gravity)
// Create the ground in the physics model
groundBodyDef := box2d.MakeB2BodyDef()
groundBodyDef.Position.Set(0, 0)
groundBody := world.CreateBody(&groundBodyDef)
groundTriangle := box2d.MakeB2PolygonShape()
vertices := []box2d.B2Vec2{
box2d.MakeB2Vec2(10, 1),
box2d.MakeB2Vec2(0, 10),
box2d.MakeB2Vec2(-10, 1),
}
groundTriangle.Set(vertices, len(vertices))
groundBody.CreateFixture(&groundTriangle, 0.0)
groundBase := box2d.MakeB2PolygonShape()
groundBase.SetAsBox(50, 1)
groundBody.CreateFixture(&groundBase, 0.0)
// Draw the ground directly
imd := imdraw.New(nil)
imd.Color = colornames.Sandybrown
for _, v := range vertices {
imd.Push(pixel.V(v.X, v.Y).Scaled(32))
}
imd.Polygon(0)
imd.Push(
pixel.V(50, 1).Scaled(32),
pixel.V(-50, -1).Scaled(32),
)
imd.Rectangle(0)
return &world, imd
}
func sim() {
cfg := pixelgl.WindowConfig{
Title: "Pixel Rocks!",
Bounds: pixel.R(0, 0, 1024, 768),
VSync: true,
}
win, err := pixelgl.NewWindow(cfg)
if err != nil {
panic(err)
}
// Create a world
sprites := loadSprites()
world, drawableWorld := createWorld()
// Generate random trees
trees := []*box2d.B2Body{}
for i := 0; i < 800; i++ {
// Use the middle tree sprite since it's big and fills circular physics body nicely
trees = append(trees, generateTree(world))
}
camZoom := 0.4
camPos := pixel.V(1024/2, 0)
lastTime := time.Now()
treeSprite := sprites[4] // Big tree that fills the physics body nicely
for !win.Closed() {
// We're v-synced so calculate the time elapsed since the last frame and step the simulation that far
currentTime := time.Now()
dt := currentTime.Sub(lastTime)
lastTime = currentTime
world.Step(dt.Seconds(), velocityIterations, positionIterations)
// Check the mouse wheel to determine camera position
camZoom *= math.Pow(camZoomSpeed, win.MouseScroll().Y)
cam := pixel.IM.Scaled(pixel.ZV, camZoom).Moved(camPos)
if win.Pressed(pixelgl.MouseButtonLeft) {
camPos = win.MousePosition()
}
win.SetMatrix(cam)
// Draw the world and trees
win.Clear(colornames.Whitesmoke)
drawableWorld.Draw(win)
for _, tree := range trees {
// Physics X and Y which are in metres
x := tree.GetPosition().X
y := tree.GetPosition().Y
// Determine the position on screen by scaling so that we get 32 pixels to the metre
pos := pixel.V(x, y).Scaled(32)
// Draw a tree sprite for this physics body
treeSprite.Draw(win, pixel.IM.Scaled(pixel.ZV, 2).Moved(pos))
}
win.Update()
}
}
func main() {
pixelgl.Run(sim)
}
|
package model
import "time"
//Healthcheck
type StatusRequest struct{}
type StatusResponse struct {
Status string `json:"status"`
}
type GetApprovalRequest struct {
ID string `json:"id"`
}
type GetApprovalResponse struct {
ApprovalItem ApprovalItem `json:"approval_items"`
}
type GetApprovalsRequest struct {
Limit *int `json:"limit,omitempty"`
Offset *int `json:"offset,omitempty"`
Default int `json:"default,omitempty"`
//TODO: In future, we can use the following to do proper querying for special cases, like sorting etc.
//Restrict map[string]string `json:"restrict,omitempty"`
//Sort map[string]string `json:"sort,omitempty"`
}
type GetApprovalsResponse struct {
ApprovalItems []ApprovalItem `json:"approval_items"`
}
// Add a new request
type AddApprovalRequest struct {
ID string `json:"id"`
Title string `json:"title"`
Description string `json:"description"`
ServiceRule int `json:"service_rule"`
Deadline time.Time `json:"deadline,omitempty"`
Comment string `json:"comment,omitempty"`
}
type AddApprovalResponse struct {
ApprovalItem ApprovalItem `json:"approval_item,omitempty"`
}
// Update the approval request
type UpdateApprovalRequest struct {
ID string `json:"id"`
Title *string `json:"title"`
Description *string `json:"description"`
ServiceRule *int `json:"service_rule"`
Deadline *time.Time `json:"deadline,omitempty"`
Comment *string `json:"comment,omitempty"`
Status *int `json:"status,omitempty"`
}
// Change priority / status etc.
type UpdateApprovalResponse struct {
ApprovalItem ApprovalItem `json:"approval_item"`
}
type SendChangedApprovalRequest struct {
ID string `json:"id"`
Status int `json:"status"`
}
type SendChangedApprovalResponse struct {
ID string `json: "id"`
Status int `json:"status"`
ErrorCode int `json:"error_code"`
}
|
/*
Copyright 2020 The Skaffold 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 initializer
import (
"bytes"
"context"
"errors"
"fmt"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"github.com/GoogleContainerTools/skaffold/v2/pkg/skaffold/config"
initconfig "github.com/GoogleContainerTools/skaffold/v2/pkg/skaffold/initializer/config"
"github.com/GoogleContainerTools/skaffold/v2/pkg/skaffold/schema"
"github.com/GoogleContainerTools/skaffold/v2/testutil"
)
func TestDoInit(t *testing.T) {
tests := []struct {
name string
shouldSkip bool
dir string
config initconfig.Config
expectedError string
expectedExitCode int
}{
//TODO: mocked kompose test
{
name: "getting-started",
dir: "testdata/init/hello",
config: initconfig.Config{
Force: true,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
},
{
name: "ignore existing tags",
dir: "testdata/init/ignore-tags",
config: initconfig.Config{
Force: true,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
},
{
name: "microservices (backwards compatibility)",
dir: "testdata/init/microservices",
config: initconfig.Config{
Force: true,
CliArtifacts: []string{
"leeroy-app/Dockerfile=gcr.io/k8s-skaffold/leeroy-app",
"leeroy-web/Dockerfile=gcr.io/k8s-skaffold/leeroy-web",
},
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
},
{
name: "microservices",
dir: "testdata/init/microservices",
config: initconfig.Config{
Force: true,
CliArtifacts: []string{
`{"builder":"Docker","payload":{"path":"leeroy-app/Dockerfile"},"image":"gcr.io/k8s-skaffold/leeroy-app"}`,
`{"builder":"Docker","payload":{"path":"leeroy-web/Dockerfile"},"image":"gcr.io/k8s-skaffold/leeroy-web"}`,
},
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
},
{
name: "windows paths use forward slashes",
shouldSkip: runtime.GOOS != "windows",
dir: `testdata\init\windows`,
config: initconfig.Config{
Force: true,
CliArtifacts: []string{
`{"builder":"Docker","context":"apps\\web","payload":{"path":"apps\\web\\build\\Dockerfile"},"image":"gcr.io/k8s-skaffold/leeroy-web"}`,
},
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
},
{
name: "CLI artifacts + manifest placeholders",
dir: "testdata/init/allcli",
config: initconfig.Config{
Force: true,
CliArtifacts: []string{
`{"builder":"Docker","payload":{"path":"Dockerfile"},"image":"passed-in-artifact"}`,
},
CliKubernetesManifests: []string{
"manifest-placeholder1.yaml",
"manifest-placeholder2.yaml",
},
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
},
{
name: "CLI artifacts but no manifests",
dir: "testdata/init/allcli",
config: initconfig.Config{
Force: true,
CliArtifacts: []string{
`{"builder":"Docker","payload":{"path":"Dockerfile"},"image":"passed-in-artifact"}`,
},
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
expectedError: "one or more valid Kubernetes manifests are required to run skaffold",
expectedExitCode: 102,
},
{
name: "error writing config file",
dir: "testdata/init/microservices",
config: initconfig.Config{
Force: true,
CliArtifacts: []string{
`{"builder":"Docker","payload":{"path":"leeroy-app/Dockerfile"},"image":"gcr.io/k8s-skaffold/leeroy-app"}`,
`{"builder":"Docker","payload":{"path":"leeroy-web/Dockerfile"},"image":"gcr.io/k8s-skaffold/leeroy-web"}`,
},
Opts: config.SkaffoldOptions{
// erroneous config file as . is a directory
ConfigurationFile: ".",
},
},
expectedError: "writing config to file: open .: is a directory",
expectedExitCode: 1,
},
{
name: "error no builders",
dir: "testdata/init/no-builder",
config: initconfig.Config{
Force: true,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
expectedError: "please provide at least one build config",
expectedExitCode: 101,
},
{
name: "error no manifests",
dir: "testdata/init/hello-no-manifest",
config: initconfig.Config{
Force: true,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
expectedError: "one or more valid Kubernetes manifests are required to run skaffold",
expectedExitCode: 102,
},
{
name: "existing config",
dir: "testdata/init/hello",
config: initconfig.Config{
Force: false,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml",
},
},
expectedError: "pre-existing skaffold.yaml found",
expectedExitCode: 103,
},
{
name: "builder/image ambiguity",
dir: "testdata/init/microservices",
config: initconfig.Config{
Force: true,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
expectedError: "unable to automatically resolve builder/image pairs",
expectedExitCode: 104,
},
{
name: "kustomize",
dir: "testdata/init/getting-started-kustomize",
config: initconfig.Config{
Force: true,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
},
{
name: "helm init",
dir: "testdata/init/helm-deployment",
shouldSkip: true, // Github Actions CI runners don't have helm. This test should mock helm.
config: initconfig.Config{
Force: true,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
},
}
for _, test := range tests {
testutil.Run(t, test.name, func(t *testutil.T) {
if test.shouldSkip {
t.Logf("Skipped test %q", test.name)
return
}
t.Chdir(test.dir)
err := DoInit(context.TODO(), os.Stdout, test.config)
if test.expectedError != "" {
t.CheckErrorContains(test.expectedError, err)
t.CheckDeepEqual(exitCode(err), test.expectedExitCode)
} else {
t.CheckNoError(err)
checkGeneratedConfig(t, ".")
}
})
}
}
func TestDoInitAnalyze(t *testing.T) {
tests := []struct {
name string
dir string
config initconfig.Config
expectedOut string
}{
{
name: "analyze microservices",
dir: "testdata/init/microservices",
config: initconfig.Config{
Analyze: true,
},
expectedOut: strip(`{
"dockerfiles":["leeroy-app/Dockerfile","leeroy-web/Dockerfile"],
"images":["gcr.io/k8s-skaffold/leeroy-app","gcr.io/k8s-skaffold/leeroy-web"]
}`) + "\n",
},
{
name: "analyze microservices new format",
dir: "testdata/init/microservices",
config: initconfig.Config{
Analyze: true,
EnableNewInitFormat: true,
},
expectedOut: strip(`{
"builders":[
{"name":"Docker","payload":{"path":"leeroy-app/Dockerfile"}},
{"name":"Docker","payload":{"path":"leeroy-web/Dockerfile"}}
],
"images":[
{"name":"gcr.io/k8s-skaffold/leeroy-app","foundMatch":false},
{"name":"gcr.io/k8s-skaffold/leeroy-web","foundMatch":false}]}`) + "\n",
},
{
name: "no error with no manifests in analyze mode with skip-deploy",
dir: "testdata/init/hello-no-manifest",
config: initconfig.Config{
Analyze: true,
SkipDeploy: true,
Opts: config.SkaffoldOptions{
ConfigurationFile: "skaffold.yaml.out",
},
},
expectedOut: strip(`{"dockerfiles":["Dockerfile"]}`) + "\n",
},
}
for _, test := range tests {
testutil.Run(t, test.name, func(t *testutil.T) {
var out bytes.Buffer
t.Chdir(test.dir)
err := DoInit(context.TODO(), &out, test.config)
t.CheckNoError(err)
t.CheckDeepEqual(test.expectedOut, out.String())
})
}
}
func strip(s string) string {
cutString := "\n\t\r"
stripped := ""
for _, r := range s {
if strings.ContainsRune(cutString, r) {
continue
}
stripped = fmt.Sprintf("%s%c", stripped, r)
}
return stripped
}
func checkGeneratedConfig(t *testutil.T, dir string) {
expectedOutput, err := schema.ParseConfig(filepath.Join(dir, "skaffold.yaml"))
t.CheckNoError(err)
output, err := schema.ParseConfig(filepath.Join(dir, "skaffold.yaml.out"))
t.CheckNoError(err)
t.CheckDeepEqual(expectedOutput, output)
}
type ExitCoder interface {
ExitCode() int
}
func exitCode(err error) int {
var exitErr ExitCoder
if ok := errors.As(err, &exitErr); ok {
return exitErr.ExitCode()
}
return 1
}
|
/*
Copyright 2018 The KubeSphere 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 mysql
import (
"testing"
"github.com/gocraft/dbr"
"github.com/gocraft/dbr/dialect"
"github.com/stretchr/testify/assert"
)
// Ref: https://github.com/gocraft/dbr/blob/5d59a8b3aa915660960329efb3af5513e7a0db07/condition_test.go
func TestCondition(t *testing.T) {
for _, test := range []struct {
cond dbr.Builder
query string
value []interface{}
}{
{
cond: Eq("col", 1),
query: "`col` = ?",
value: []interface{}{1},
},
{
cond: Eq("col", nil),
query: "`col` IS NULL",
value: nil,
},
{
cond: Eq("col", []int{}),
query: "0",
value: nil,
},
{
cond: Neq("col", 1),
query: "`col` != ?",
value: []interface{}{1},
},
{
cond: Neq("col", nil),
query: "`col` IS NOT NULL",
value: nil,
},
{
cond: Gt("col", 1),
query: "`col` > ?",
value: []interface{}{1},
},
{
cond: Gte("col", 1),
query: "`col` >= ?",
value: []interface{}{1},
},
{
cond: Lt("col", 1),
query: "`col` < ?",
value: []interface{}{1},
},
{
cond: Lte("col", 1),
query: "`col` <= ?",
value: []interface{}{1},
},
{
cond: And(Lt("a", 1), Or(Gt("b", 2), Neq("c", 3))),
query: "(`a` < ?) AND ((`b` > ?) OR (`c` != ?))",
value: []interface{}{1, 2, 3},
},
} {
buf := dbr.NewBuffer()
err := test.cond.Build(dialect.MySQL, buf)
assert.NoError(t, err)
assert.Equal(t, test.query, buf.String())
assert.Equal(t, test.value, buf.Value())
}
}
|
// Copyright 2018 The gVisor 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 cmd
import (
"context"
"fmt"
"github.com/google/subcommands"
"gvisor.dev/gvisor/runsc/flag"
)
// NewHelp returns a help command for the given commander.
func NewHelp(cdr *subcommands.Commander) *Help {
return &Help{
cdr: cdr,
}
}
// Help implements subcommands.Command for the "help" command. The 'help'
// command prints help for commands registered to a Commander but also allows for
// registering additional help commands that print other documentation.
type Help struct {
cdr *subcommands.Commander
commands []subcommands.Command
help bool
}
// Name implements subcommands.Command.Name.
func (*Help) Name() string {
return "help"
}
// Synopsis implements subcommands.Command.Synopsis.
func (*Help) Synopsis() string {
return "Print help documentation."
}
// Usage implements subcommands.Command.Usage.
func (*Help) Usage() string {
return `help [<subcommand>]:
With an argument, prints detailed information on the use of
the specified topic or subcommand. With no argument, print a list of
all commands and a brief description of each.
`
}
// SetFlags implements subcommands.Command.SetFlags.
func (h *Help) SetFlags(*flag.FlagSet) {}
// Execute implements subcommands.Command.Execute.
func (h *Help) Execute(ctx context.Context, f *flag.FlagSet, args ...any) subcommands.ExitStatus {
switch f.NArg() {
case 0:
fmt.Fprintf(h.cdr.Output, "Usage: %s <flags> <subcommand> <subcommand args>\n\n", h.cdr.Name())
fmt.Fprintf(h.cdr.Output, `runsc is the gVisor container runtime.
Functionality is provided by subcommands. For help with a specific subcommand,
use "%s %s <subcommand>".
`, h.cdr.Name(), h.Name())
h.cdr.VisitGroups(func(g *subcommands.CommandGroup) {
h.cdr.ExplainGroup(h.cdr.Output, g)
})
fmt.Fprintf(h.cdr.Output, "Additional help topics (Use \"%s %s <topic>\" to see help on the topic):\n", h.cdr.Name(), h.Name())
for _, cmd := range h.commands {
fmt.Fprintf(h.cdr.Output, "\t%-15s %s\n", cmd.Name(), cmd.Synopsis())
}
fmt.Fprintf(h.cdr.Output, "\nUse \"%s flags\" for a list of top-level flags\n", h.cdr.Name())
return subcommands.ExitSuccess
default:
// Look for commands registered to the commander and print help explanation if found.
found := false
h.cdr.VisitCommands(func(g *subcommands.CommandGroup, cmd subcommands.Command) {
if f.Arg(0) == cmd.Name() {
h.cdr.ExplainCommand(h.cdr.Output, cmd)
found = true
}
})
if found {
return subcommands.ExitSuccess
}
// Next check commands registered to the help command.
for _, cmd := range h.commands {
if f.Arg(0) == cmd.Name() {
fs := flag.NewFlagSet(f.Arg(0), flag.ContinueOnError)
fs.Usage = func() { h.cdr.ExplainCommand(h.cdr.Error, cmd) }
cmd.SetFlags(fs)
if fs.Parse(f.Args()[1:]) != nil {
return subcommands.ExitUsageError
}
return cmd.Execute(ctx, f, args...)
}
}
fmt.Fprintf(h.cdr.Error, "Subcommand %s not understood\n", f.Arg(0))
}
f.Usage()
return subcommands.ExitUsageError
}
// Register registers a new help command.
func (h *Help) Register(cmd subcommands.Command) {
h.commands = append(h.commands, cmd)
}
|
package handler
import (
"auth/database"
"database/sql"
"encoding/json"
"fmt"
"log"
"net/http"
)
type Handler struct {
DB *sql.DB
}
type data map[string]interface{}
func JSONWriter(w http.ResponseWriter, data interface{}, statusCode int) {
w.WriteHeader(statusCode)
err := json.NewEncoder(w).Encode(data)
if err != nil {
log.Fatal(err.Error())
}
}
func HelloHandler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/home" {
fmt.Fprintf(w, "Welcome!")
return
}
}
func (h *Handler) FindUser(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
JSONWriter(w, data{
"Error": "Method Not Allowed",
}, http.StatusMethodNotAllowed)
return
}
userName := r.Header.Get("username")
if userName == "" {
JSONWriter(w, data{
"Error": "no username found in header",
}, http.StatusInternalServerError)
return
}
getUser, err := database.FindUserByUsername(userName, h.DB)
if err != nil {
JSONWriter(w, data{
"Error": "internal server error",
}, http.StatusNotFound)
return
}
if getUser.Username == "" {
JSONWriter(w, data{
"Response": "User does not exist",
}, http.StatusUnauthorized)
return
} else {
JSONWriter(w, data{
"Response": "User exists",
}, http.StatusOK)
return
}
}
|
package exchange
import (
"fmt"
"net/http"
"github.com/prebid/prebid-server/adapters"
"github.com/prebid/prebid-server/config"
"github.com/prebid/prebid-server/metrics"
"github.com/prebid/prebid-server/openrtb_ext"
)
func BuildAdapters(client *http.Client, cfg *config.Configuration, infos config.BidderInfos, me metrics.MetricsEngine) (map[openrtb_ext.BidderName]AdaptedBidder, []error) {
server := config.Server{ExternalUrl: cfg.ExternalURL, GvlID: cfg.GDPR.HostVendorID, DataCenter: cfg.DataCenter}
bidders, errs := buildBidders(infos, newAdapterBuilders(), server)
if len(errs) > 0 {
return nil, errs
}
exchangeBidders := make(map[openrtb_ext.BidderName]AdaptedBidder, len(bidders))
for bidderName, bidder := range bidders {
info := infos[string(bidderName)]
exchangeBidder := AdaptBidder(bidder, client, cfg, me, bidderName, info.Debug, info.EndpointCompression)
exchangeBidder = addValidatedBidderMiddleware(exchangeBidder)
exchangeBidders[bidderName] = exchangeBidder
}
return exchangeBidders, nil
}
func buildBidders(infos config.BidderInfos, builders map[openrtb_ext.BidderName]adapters.Builder, server config.Server) (map[openrtb_ext.BidderName]adapters.Bidder, []error) {
bidders := make(map[openrtb_ext.BidderName]adapters.Bidder)
var errs []error
for bidder, info := range infos {
if len(info.AliasOf) > 0 {
errs = append(errs, fmt.Errorf("This feature is currently under development"))
continue
}
bidderName, bidderNameFound := openrtb_ext.NormalizeBidderName(bidder)
if !bidderNameFound {
errs = append(errs, fmt.Errorf("%v: unknown bidder", bidder))
continue
}
if len(info.AliasOf) > 0 {
if err := setAliasBuilder(info, builders, bidderName); err != nil {
errs = append(errs, fmt.Errorf("%v: failed to set alias builder: %v", bidder, err))
continue
}
}
builder, builderFound := builders[bidderName]
if !builderFound {
errs = append(errs, fmt.Errorf("%v: builder not registered", bidder))
continue
}
if info.IsEnabled() {
adapterInfo := buildAdapterInfo(info)
bidderInstance, builderErr := builder(bidderName, adapterInfo, server)
if builderErr != nil {
errs = append(errs, fmt.Errorf("%v: %v", bidder, builderErr))
continue
}
bidders[bidderName] = adapters.BuildInfoAwareBidder(bidderInstance, info)
}
}
return bidders, errs
}
func setAliasBuilder(info config.BidderInfo, builders map[openrtb_ext.BidderName]adapters.Builder, bidderName openrtb_ext.BidderName) error {
parentBidderName, parentBidderFound := openrtb_ext.NormalizeBidderName(info.AliasOf)
if !parentBidderFound {
return fmt.Errorf("unknown parent bidder: %v for alias: %v", info.AliasOf, bidderName)
}
builder, builderFound := builders[parentBidderName]
if !builderFound {
return fmt.Errorf("%v: parent builder not registered", parentBidderName)
}
builders[bidderName] = builder
return nil
}
func buildAdapterInfo(bidderInfo config.BidderInfo) config.Adapter {
adapter := config.Adapter{}
adapter.Endpoint = bidderInfo.Endpoint
adapter.ExtraAdapterInfo = bidderInfo.ExtraAdapterInfo
adapter.PlatformID = bidderInfo.PlatformID
adapter.AppSecret = bidderInfo.AppSecret
adapter.XAPI = bidderInfo.XAPI
return adapter
}
// GetActiveBidders returns a map of all active bidder names.
func GetActiveBidders(infos config.BidderInfos) map[string]openrtb_ext.BidderName {
activeBidders := make(map[string]openrtb_ext.BidderName)
for name, info := range infos {
if info.IsEnabled() {
activeBidders[name] = openrtb_ext.BidderName(name)
}
}
return activeBidders
}
func GetDisabledBidderWarningMessages(infos config.BidderInfos) map[string]string {
removed := map[string]string{
"lifestreet": `Bidder "lifestreet" is no longer available in Prebid Server. Please update your configuration.`,
"adagio": `Bidder "adagio" is no longer available in Prebid Server. Please update your configuration.`,
"somoaudience": `Bidder "somoaudience" is no longer available in Prebid Server. Please update your configuration.`,
"yssp": `Bidder "yssp" is no longer available in Prebid Server. If you're looking to use the Yahoo SSP adapter, please rename it to "yahooAds" in your configuration.`,
"andbeyondmedia": `Bidder "andbeyondmedia" is no longer available in Prebid Server. If you're looking to use the AndBeyond.Media SSP adapter, please rename it to "beyondmedia" in your configuration.`,
"oftmedia": `Bidder "oftmedia" is no longer available in Prebid Server. Please update your configuration.`,
"groupm": `Bidder "groupm" is no longer available in Prebid Server. Please update your configuration.`,
"verizonmedia": `Bidder "verizonmedia" is no longer available in Prebid Server. Please update your configuration.`,
"brightroll": `Bidder "brightroll" is no longer available in Prebid Server. Please update your configuration.`,
}
return mergeRemovedAndDisabledBidderWarningMessages(removed, infos)
}
func mergeRemovedAndDisabledBidderWarningMessages(removed map[string]string, infos config.BidderInfos) map[string]string {
disabledBidders := removed
for name, info := range infos {
if info.Disabled {
msg := fmt.Sprintf(`Bidder "%s" has been disabled on this instance of Prebid Server. Please work with the PBS host to enable this bidder again.`, name)
disabledBidders[name] = msg
}
}
return disabledBidders
}
|
// Copyright 2018 Authors of Cilium
//
// 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 monitor
import (
"fmt"
"github.com/cilium/cilium/pkg/proxy/accesslog"
)
// LogRecordNotify is a proxy access log notification
type LogRecordNotify struct {
accesslog.LogRecord
}
func (l *LogRecordNotify) direction() string {
switch l.ObservationPoint {
case accesslog.Ingress:
return "<-"
case accesslog.Egress:
return "->"
default:
return "??"
}
}
func (l *LogRecordNotify) l7Proto() string {
if l.HTTP != nil {
return "http"
}
if l.Kafka != nil {
return "kafka"
}
return "unknown-l7"
}
// DumpInfo dumps an access log notification
func (l *LogRecordNotify) DumpInfo() {
fmt.Printf("%s %s %s from %d (%s) to %d (%s), identity %d->%d, verdict %s",
l.direction(), l.Type, l.l7Proto(), l.SourceEndpoint.ID, l.SourceEndpoint.Labels,
l.DestinationEndpoint.ID, l.DestinationEndpoint.Labels,
l.SourceEndpoint.Identity, l.DestinationEndpoint.Identity,
l.Verdict)
if http := l.HTTP; http != nil {
url := ""
if http.URL != nil {
url = http.URL.String()
}
fmt.Printf(" %s %s => %d\n", http.Method, url, http.Code)
}
if kafka := l.Kafka; kafka != nil {
fmt.Printf(" %s topic %s => %d\n", kafka.APIKey, kafka.Topic.Topic, kafka.ErrorCode)
}
}
|
package db
import (
"go.m3o.com/client"
)
func NewDbService(token string) *DbService {
return &DbService{
client: client.NewClient(&client.Options{
Token: token,
}),
}
}
type DbService struct {
client *client.Client
}
// Count records in a table
func (t *DbService) Count(request *CountRequest) (*CountResponse, error) {
rsp := &CountResponse{}
return rsp, t.client.Call("db", "Count", request, rsp)
}
// Create a record in the database. Optionally include an "id" field otherwise it's set automatically.
func (t *DbService) Create(request *CreateRequest) (*CreateResponse, error) {
rsp := &CreateResponse{}
return rsp, t.client.Call("db", "Create", request, rsp)
}
// Delete a record in the database by id.
func (t *DbService) Delete(request *DeleteRequest) (*DeleteResponse, error) {
rsp := &DeleteResponse{}
return rsp, t.client.Call("db", "Delete", request, rsp)
}
// Read data from a table. Lookup can be by ID or via querying any field in the record.
func (t *DbService) Read(request *ReadRequest) (*ReadResponse, error) {
rsp := &ReadResponse{}
return rsp, t.client.Call("db", "Read", request, rsp)
}
// Truncate the records in a table
func (t *DbService) Truncate(request *TruncateRequest) (*TruncateResponse, error) {
rsp := &TruncateResponse{}
return rsp, t.client.Call("db", "Truncate", request, rsp)
}
// Update a record in the database. Include an "id" in the record to update.
func (t *DbService) Update(request *UpdateRequest) (*UpdateResponse, error) {
rsp := &UpdateResponse{}
return rsp, t.client.Call("db", "Update", request, rsp)
}
type CountRequest struct {
// specify the table name
Table string `json:"table"`
}
type CountResponse struct {
// the number of records in the table
Count int32 `json:"count"`
}
type CreateRequest struct {
// JSON encoded record or records (can be array or object)
Record map[string]interface{} `json:"record"`
// Optional table name. Defaults to 'default'
Table string `json:"table"`
}
type CreateResponse struct {
// The id of the record (either specified or automatically created)
Id string `json:"id"`
}
type DeleteRequest struct {
// id of the record
Id string `json:"id"`
// Optional table name. Defaults to 'default'
Table string `json:"table"`
}
type DeleteResponse struct {
}
type ReadRequest struct {
// Read by id. Equivalent to 'id == "your-id"'
Id string `json:"id"`
// Maximum number of records to return. Default limit is 25.
// Maximum limit is 1000. Anything higher will return an error.
Limit int32 `json:"limit"`
Offset int32 `json:"offset"`
// 'asc' (default), 'desc'
Order string `json:"order"`
// field name to order by
OrderBy string `json:"orderBy"`
// Examples: 'age >= 18', 'age >= 18 and verified == true'
// Comparison operators: '==', '!=', '<', '>', '<=', '>='
// Logical operator: 'and'
// Dot access is supported, eg: 'user.age == 11'
// Accessing list elements is not supported yet.
Query string `json:"query"`
// Optional table name. Defaults to 'default'
Table string `json:"table"`
}
type ReadResponse struct {
// JSON encoded records
Records []map[string]interface{} `json:"records"`
}
type TruncateRequest struct {
// Optional table name. Defaults to 'default'
Table string `json:"table"`
}
type TruncateResponse struct {
// The table truncated
Table string `json:"table"`
}
type UpdateRequest struct {
// The id of the record. If not specified it is inferred from the 'id' field of the record
Id string `json:"id"`
// record, JSON object
Record map[string]interface{} `json:"record"`
// Optional table name. Defaults to 'default'
Table string `json:"table"`
}
type UpdateResponse struct {
}
|
// Copyright 2019 Liquidata, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package merge
import (
"context"
"github.com/liquidata-inc/dolt/go/libraries/doltcore/doltdb"
"github.com/liquidata-inc/dolt/go/libraries/doltcore/row"
"github.com/liquidata-inc/dolt/go/libraries/doltcore/schema/encoding"
"github.com/liquidata-inc/dolt/go/libraries/doltcore/table"
"github.com/liquidata-inc/dolt/go/store/types"
)
type AutoResolver func(key types.Value, conflict doltdb.Conflict) (types.Value, error)
func Ours(key types.Value, cnf doltdb.Conflict) (types.Value, error) {
return cnf.Value, nil
}
func Theirs(key types.Value, cnf doltdb.Conflict) (types.Value, error) {
return cnf.MergeValue, nil
}
func ResolveTable(ctx context.Context, vrw types.ValueReadWriter, tbl *doltdb.Table, autoResFunc AutoResolver) (*doltdb.Table, error) {
if has, err := tbl.HasConflicts(); err != nil {
return nil, err
} else if !has {
return nil, doltdb.ErrNoConflicts
}
tblSchRef, err := tbl.GetSchemaRef()
if err != nil {
return nil, err
}
tblSchVal, err := tblSchRef.TargetValue(ctx, vrw)
if err != nil {
return nil, err
}
tblSch, err := encoding.UnmarshalNomsValue(ctx, vrw.Format(), tblSchVal)
if err != nil {
return nil, err
}
schemas, conflicts, err := tbl.GetConflicts(ctx)
if err != nil {
return nil, err
}
rowData, err := tbl.GetRowData(ctx)
if err != nil {
return nil, err
}
rowEditor := rowData.Edit()
err = conflicts.Iter(ctx, func(key, value types.Value) (stop bool, err error) {
cnf, err := doltdb.ConflictFromTuple(value.(types.Tuple))
if err != nil {
return false, err
}
updated, err := autoResFunc(key, cnf)
if err != nil {
return false, err
}
if types.IsNull(updated) {
rowEditor.Remove(key)
} else {
r, err := row.FromNoms(tblSch, key.(types.Tuple), updated.(types.Tuple))
if err != nil {
return false, err
}
if has, err := row.IsValid(r, tblSch); err != nil {
return false, err
} else if !has {
return false, table.NewBadRow(r)
}
rowEditor.Set(key, updated)
}
return false, nil
})
if err != nil {
return nil, err
}
m, err := rowEditor.Map(ctx)
if err != nil {
return nil, err
}
newTbl, err := doltdb.NewTable(ctx, vrw, tblSchVal, m)
if err != nil {
return nil, err
}
m, err = types.NewMap(ctx, vrw)
if err != nil {
return nil, err
}
newTbl, err = newTbl.SetConflicts(ctx, schemas, m)
if err != nil {
return nil, err
}
return newTbl, nil
}
|
package cli
import (
"errors"
"fmt"
"io/ioutil"
"os"
"os/exec"
"strings"
"github.com/madebyais/fast/app"
"github.com/madebyais/fast/common"
"github.com/madebyais/fast/config"
)
// Interface is an interface for cli package
type Interface interface {
Init()
}
type schema struct {
args []string
cmd string
}
// New is used to initiate cli package
func New() Interface {
return &schema{}
}
// Init is used to run the cli package
func (s *schema) Init() {
s.args = os.Args
err := s.execCommand()
if err != nil {
panic(err)
}
}
// execCommand will run/execute command based on args
// passed through the FAST cli
func (s *schema) execCommand() error {
if len(s.args) == 1 {
return s.startCmd()
}
switch s.args[1] {
default:
return s.startCmd()
case `create`:
return s.createCmd()
case `build`:
return s.buildCmd()
case `rm`:
return s.removeCmd()
case `help`:
return s.helpCmd()
}
}
// helpCmd will execute help command,
// which will show FAST description and its help page
func (s *schema) helpCmd() error {
s.cmd = `help`
fmt.Println(common.HelpTextPage)
return nil
}
// createCmd will create a file with .go as file extension
// it will contain the default function file
// cmd: fast create {your_module_name}
func (s *schema) createCmd() error {
s.cmd = `create`
if len(s.args) < 3 {
return errors.New(`cannot find module name`)
}
moduleName := s.args[2]
moduleContent := strings.Replace(common.DefaultModuleFile, `{module_name}`, moduleName, -1)
moduleTitle := strings.ToTitle(moduleName)
moduleContent = strings.Replace(moduleContent, `{module_title}`, moduleTitle, -1)
filename := fmt.Sprintf(`%s.go`, moduleName)
filepath := fmt.Sprintf(`./%s`, filename)
err := ioutil.WriteFile(filepath, []byte(moduleContent), 0644)
if err != nil {
return err
}
fmt.Println(`Your`, moduleTitle, `module has been created successfully. Generated filename ~>`, filename)
return nil
}
// buildCmd will export the .go file into .so file
// which have been created using the create command
// cmd: fast build {your_module_name}
func (s *schema) buildCmd() error {
s.cmd = `build`
if len(s.args) < 3 {
return errors.New(`cannot find module name`)
}
moduleName := s.args[2]
gofilename := fmt.Sprintf(`%s.go`, moduleName)
sofilename := fmt.Sprintf(`%s.so`, moduleName)
err := exec.Command(`go`, `build`, `-buildmode=plugin`, `-o`, sofilename, gofilename).Run()
if err != nil {
return err
}
moduleTitle := strings.ToTitle(moduleName)
fmt.Println(`Your`, moduleTitle, `module has been build successfully. Generated filename ~>`, sofilename)
return nil
}
// removeCmd will remove both .go and .so files
// cmd: fast rm {your_module_name}
func (s *schema) removeCmd() error {
s.cmd = `rm`
if len(s.args) < 3 {
return errors.New(`cannot find module name`)
}
moduleName := s.args[2]
gofilename := fmt.Sprintf(`./%s.go`, moduleName)
sofilename := fmt.Sprintf(`./%s.so`, moduleName)
err := os.Remove(gofilename)
if err != nil {
return err
}
err = os.Remove(sofilename)
if err != nil {
return err
}
return nil
}
// startCmd will start the FAST server
func (s *schema) startCmd() error {
s.cmd = `start`
config.New()
app.New().Start()
return nil
}
|
//
// Copyright (c) SAS Institute Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package xmldsig
import (
"sort"
"github.com/beevik/etree"
)
// Canonicalize a document starting from the given element and return the
// serialized bytes. Implements something vaguely like xml-exc-c14n. Namespaces
// declared in parent nodes are pulled in, and namespaces not used in the
// element where they are declared are pushed further down to the elements that
// use them.
//
// This is not a standards-conforming implementation. Use at your own peril.
func SerializeCanonical(oldroot *etree.Element) ([]byte, error) {
// make a deep copy before mangling things
root := oldroot.Copy()
// remake the document without any xml declarations etc.
doc := etree.NewDocument()
doc.SetRoot(root)
doc.WriteSettings.CanonicalEndTags = true
doc.WriteSettings.CanonicalText = true
doc.WriteSettings.CanonicalAttrVal = true
pullDown(oldroot, root)
walkAttributes(root)
return doc.WriteToBytes()
}
// if the attribute is a namespace declaration then return the namespace
func getDecl(attr etree.Attr) (string, bool) {
if attr.Space == "" && attr.Key == "xmlns" {
return "", true
} else if attr.Space == "xmlns" {
return attr.Key, true
} else {
return "", false
}
}
// attribute name for declaring the given namespace
func putDecl(space string) string {
if space == "" {
return "xmlns"
}
return "xmlns:" + space
}
func walkAttributes(elem *etree.Element) {
// remove unused spaces and push ones this element doesn't use down to child elements
for i := 0; i < len(elem.Attr); {
attr := elem.Attr[i]
if space, isDecl := getDecl(attr); isDecl && !usesSpace(elem, space) {
pushDown(elem, elem, space, putDecl(space), attr.Value)
elem.Attr = append(elem.Attr[:i], elem.Attr[i+1:]...)
continue
}
i++
}
sort.Slice(elem.Attr, func(i, j int) bool {
x := elem.Attr[i]
y := elem.Attr[j]
// default namespace node sorts first
if x.Space == "" && x.Key == "xmlns" {
return true
} else if y.Space == "" && y.Key == "xmlns" {
return false
}
// then all other namespace nodes
if x.Space == "xmlns" && y.Space != "xmlns" {
return true
} else if y.Space == "xmlns" && x.Space != "xmlns" {
return false
}
// then order by namespace and finally by key
if x.Space != y.Space {
return x.Space < y.Space
}
return x.Key < y.Key
})
for i := 0; i < len(elem.Child); {
token := elem.Child[i]
switch t := token.(type) {
case *etree.Element:
walkAttributes(t)
case *etree.CharData:
// keep
default:
// remove
elem.Child = append(elem.Child[:i], elem.Child[i+1:]...)
continue
}
i++
}
}
// does this element or its attributes reference the given namespace?
func usesSpace(elem *etree.Element, space string) bool {
if elem.Space == space {
return true
} else if space == "" {
// if the element doesn't use the default namespace, then neither do the attributes
return false
}
for _, attr := range elem.Attr {
if attr.Space == space {
return true
}
}
return false
}
// if the root element used to be the child of another element, pull down
// namespaces that were declared in its ancestors
func pullDown(oldroot, newroot *etree.Element) {
spaces := make(map[string]string)
for p := oldroot.Parent(); p != nil; p = p.Parent() {
for _, attr := range p.Attr {
space, isDecl := getDecl(attr)
if !isDecl {
continue
}
if spaces[space] != "" {
continue
}
spaces[space] = attr.Value
}
}
for space, value := range spaces {
pushDown(nil, newroot, space, putDecl(space), value)
}
}
// add a namespace to child elements that need it
func pushDown(top, elem *etree.Element, space, key, value string) {
if elem != top && elem.SelectAttr(key) != nil {
// redeclared here already
return
} else if usesSpace(elem, space) {
// used here, declare it here
elem.CreateAttr(key, value)
} else {
// recurse further
for _, elem := range elem.ChildElements() {
pushDown(top, elem, space, key, value)
}
}
}
|
package main
import (
"errors"
"fmt"
"net/http"
"time"
"github.com/kubil6y/dukkan-go/internal/data"
"github.com/kubil6y/dukkan-go/internal/email"
"github.com/kubil6y/dukkan-go/internal/validator"
)
func (app *application) createAuthenticationTokenHandler(w http.ResponseWriter, r *http.Request) {
var input createAuthenticationTokenDTO
if err := app.readJSON(w, r, &input); err != nil {
app.badRequestResponse(w, r, err)
return
}
v := validator.New()
if input.validate(v); !v.Valid() {
app.failedValidationResponse(w, r, v.Errors)
return
}
user, err := app.models.Users.GetByEmail(input.Email)
if err != nil {
switch {
case errors.Is(err, data.ErrRecordNotFound):
app.invalidCredentialsResponse(w, r)
default:
app.serverErrorResponse(w, r, err)
}
return
}
matches, err := user.ComparePassword(input.Password)
if err != nil {
app.serverErrorResponse(w, r, err)
return
}
if !matches {
app.invalidCredentialsResponse(w, r)
return
}
token, err := app.models.Tokens.New(user.ID, 3*24*time.Hour, data.ScopeAuthentication)
if err != nil {
app.serverErrorResponse(w, r, err)
return
}
// Deleting auth tokens, keeping only last 5 on the background with a goroutine.
app.background(func() {
fmt.Println("trying to delete tokens") // TODO
if err := app.models.Tokens.KeepLastFiveAuthTokens(user.ID); err != nil {
app.logger.Error("Error deleting tokens")
}
})
e := envelope{"authentication_token": map[string]interface{}{
"token": token.Plaintext,
"expiry": token.Expiry,
}}
out := app.outOK(e)
if err := app.writeJSON(w, http.StatusOK, out, nil); err != nil {
app.serverErrorResponse(w, r, err)
return
}
}
func (app *application) activateAccountHandler(w http.ResponseWriter, r *http.Request) {
var input activateAccountDTO
if err := app.readJSON(w, r, &input); err != nil {
app.badRequestResponse(w, r, err)
return
}
v := validator.New()
if input.validate(v); !v.Valid() {
app.failedValidationResponse(w, r, v.Errors)
return
}
user, err := app.models.Users.GetForToken(data.ScopeActivation, input.Code)
if err != nil {
switch {
case errors.Is(err, data.ErrRecordNotFound):
app.notFoundResponse(w, r)
default:
app.serverErrorResponse(w, r, err)
}
return
}
user.IsActivated = true
if err := app.models.Tokens.ActivateUserAndDeleteToken(input.Code, user); err != nil {
app.serverErrorResponse(w, r, err)
return
}
e := envelope{"message": "success"}
out := app.outOK(e)
if err := app.writeJSON(w, http.StatusOK, out, nil); err != nil {
app.serverErrorResponse(w, r, err)
return
}
}
func (app *application) generateActivationTokenHandler(w http.ResponseWriter, r *http.Request) {
var input generateActivationTokenDTO
if err := app.readJSON(w, r, &input); err != nil {
app.badRequestResponse(w, r, err)
return
}
v := validator.New()
if input.validate(v); !v.Valid() {
app.failedValidationResponse(w, r, v.Errors)
return
}
user, err := app.models.Users.GetByEmail(input.Email)
if err != nil {
switch {
case errors.Is(err, data.ErrRecordNotFound):
app.notFoundResponse(w, r)
default:
app.serverErrorResponse(w, r, err)
}
return
}
token, err := app.models.Tokens.New(user.ID, 1*time.Hour, data.ScopeActivation)
if err != nil {
app.serverErrorResponse(w, r, err)
return
}
app.background(func() {
email.ActivationEmail(user, token.Plaintext)
})
e := envelope{
"code": token.Plaintext,
}
out := app.outOK(e)
if err := app.writeJSON(w, http.StatusOK, out, nil); err != nil {
app.serverErrorResponse(w, r, err)
return
}
}
// NOTE this is the same logic as createAuthenticationTokenHandler,
// loginHandler also returns user for easier client side implementation.
func (app *application) loginHandler(w http.ResponseWriter, r *http.Request) {
var input createAuthenticationTokenDTO
if err := app.readJSON(w, r, &input); err != nil {
app.badRequestResponse(w, r, err)
return
}
v := validator.New()
if input.validate(v); !v.Valid() {
app.failedValidationResponse(w, r, v.Errors)
return
}
user, err := app.models.Users.GetByEmail(input.Email)
if err != nil {
switch {
case errors.Is(err, data.ErrRecordNotFound):
app.invalidCredentialsResponse(w, r)
default:
app.serverErrorResponse(w, r, err)
}
return
}
matches, err := user.ComparePassword(input.Password)
if err != nil {
app.serverErrorResponse(w, r, err)
return
}
if !matches {
app.invalidCredentialsResponse(w, r)
return
}
token, err := app.models.Tokens.New(user.ID, 3*24*time.Hour, data.ScopeAuthentication)
if err != nil {
app.serverErrorResponse(w, r, err)
return
}
// Deleting auth tokens, keeping only last 5 on the background with a goroutine.
app.background(func() {
fmt.Println("trying to delete tokens") // TODO
if err := app.models.Tokens.KeepLastFiveAuthTokens(user.ID); err != nil {
app.logger.Error("Error deleting tokens")
}
})
e := envelope{
"user": user,
"authentication_token": map[string]interface{}{
"token": token.Plaintext,
"expiry": token.Expiry,
}}
out := app.outOK(e)
if err := app.writeJSON(w, http.StatusOK, out, nil); err != nil {
app.serverErrorResponse(w, r, err)
return
}
}
|
package controller
import (
"context"
"fmt"
"net"
"reflect"
"strings"
"github.com/cnf/structhash"
k8serrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
utilruntime "k8s.io/apimachinery/pkg/util/runtime"
"k8s.io/client-go/tools/cache"
"k8s.io/klog/v2"
kubeovnv1 "github.com/kubeovn/kube-ovn/pkg/apis/kubeovn/v1"
"github.com/kubeovn/kube-ovn/pkg/ovs"
"github.com/kubeovn/kube-ovn/pkg/ovsdb/ovnnb"
"github.com/kubeovn/kube-ovn/pkg/util"
)
func (c *Controller) enqueueAddSg(obj interface{}) {
var key string
var err error
if key, err = cache.MetaNamespaceKeyFunc(obj); err != nil {
utilruntime.HandleError(err)
return
}
klog.V(3).Infof("enqueue add securityGroup %s", key)
c.addOrUpdateSgQueue.Add(key)
}
func (c *Controller) enqueueUpdateSg(old, new interface{}) {
oldSg := old.(*kubeovnv1.SecurityGroup)
newSg := new.(*kubeovnv1.SecurityGroup)
if !reflect.DeepEqual(oldSg.Spec, newSg.Spec) {
var key string
var err error
if key, err = cache.MetaNamespaceKeyFunc(new); err != nil {
utilruntime.HandleError(err)
return
}
klog.V(3).Infof("enqueue update securityGroup %s", key)
c.addOrUpdateSgQueue.Add(key)
}
}
func (c *Controller) enqueueDeleteSg(obj interface{}) {
var key string
var err error
if key, err = cache.MetaNamespaceKeyFunc(obj); err != nil {
utilruntime.HandleError(err)
return
}
klog.V(3).Infof("enqueue delete securityGroup %s", key)
c.delSgQueue.Add(key)
}
func (c *Controller) runAddSgWorker() {
for c.processNextAddOrUpdateSgWorkItem() {
}
}
func (c *Controller) runDelSgWorker() {
for c.processNextDeleteSgWorkItem() {
}
}
func (c *Controller) runSyncSgPortsWorker() {
for c.processNextSyncSgPortsWorkItem() {
}
}
func (c *Controller) processNextSyncSgPortsWorkItem() bool {
obj, shutdown := c.syncSgPortsQueue.Get()
if shutdown {
return false
}
err := func(obj interface{}) error {
defer c.syncSgPortsQueue.Done(obj)
var key string
var ok bool
if key, ok = obj.(string); !ok {
c.syncSgPortsQueue.Forget(obj)
utilruntime.HandleError(fmt.Errorf("expected string in workqueue but got %#v", obj))
return nil
}
if err := c.syncSgLogicalPort(key); err != nil {
c.syncSgPortsQueue.AddRateLimited(key)
return fmt.Errorf("error syncing '%s': %s, requeuing", key, err.Error())
}
c.syncSgPortsQueue.Forget(obj)
return nil
}(obj)
if err != nil {
utilruntime.HandleError(err)
return true
}
return true
}
func (c *Controller) processNextAddOrUpdateSgWorkItem() bool {
obj, shutdown := c.addOrUpdateSgQueue.Get()
if shutdown {
return false
}
err := func(obj interface{}) error {
defer c.addOrUpdateSgQueue.Done(obj)
var key string
var ok bool
if key, ok = obj.(string); !ok {
c.addOrUpdateSgQueue.Forget(obj)
utilruntime.HandleError(fmt.Errorf("expected string in workqueue but got %#v", obj))
return nil
}
if err := c.handleAddOrUpdateSg(key); err != nil {
c.addOrUpdateSgQueue.AddRateLimited(key)
return fmt.Errorf("error syncing '%s': %s, requeuing", key, err.Error())
}
c.addOrUpdateSgQueue.Forget(obj)
return nil
}(obj)
if err != nil {
utilruntime.HandleError(err)
return true
}
return true
}
func (c *Controller) processNextDeleteSgWorkItem() bool {
obj, shutdown := c.delSgQueue.Get()
if shutdown {
return false
}
err := func(obj interface{}) error {
defer c.delSgQueue.Done(obj)
var key string
var ok bool
if key, ok = obj.(string); !ok {
c.delSgQueue.Forget(obj)
utilruntime.HandleError(fmt.Errorf("expected string in workqueue but got %#v", obj))
return nil
}
if err := c.handleDeleteSg(key); err != nil {
c.delSgQueue.AddRateLimited(key)
return fmt.Errorf("error syncing '%s': %s, requeuing", key, err.Error())
}
c.delSgQueue.Forget(obj)
return nil
}(obj)
if err != nil {
utilruntime.HandleError(err)
return true
}
return true
}
func (c *Controller) initDenyAllSecurityGroup() error {
if err := c.ovnLegacyClient.CreateSgPortGroup(util.DenyAllSecurityGroup); err != nil {
return err
}
if err := c.ovnLegacyClient.CreateSgDenyAllACL(); err != nil {
return err
}
c.addOrUpdateSgQueue.Add(util.DenyAllSecurityGroup)
return nil
}
// updateDenyAllSgPorts set lsp to deny which security_groups is not empty
func (c *Controller) updateDenyAllSgPorts() error {
// list all lsp which security_groups is not empty
lsps, err := c.ovnClient.ListNormalLogicalSwitchPorts(true, map[string]string{sgsKey: ""})
if err != nil {
klog.Errorf("failed to find logical port, %v", err)
return err
}
addPorts := make([]string, 0, len(lsps))
for _, lsp := range lsps {
// skip lsp which only have mac addresses,address is in port.PortSecurity[0]
if len(strings.Split(lsp.PortSecurity[0], " ")) < 2 {
continue
}
/* skip lsp which security_group does not exist */
// sgs format: sg1/sg2/sg3
sgs := strings.Split(lsp.ExternalIDs[sgsKey], "/")
allNotExist, err := c.securityGroupAllNotExist(sgs)
if err != nil {
return err
}
if allNotExist {
continue
}
addPorts = append(addPorts, lsp.Name)
}
pgName := ovs.GetSgPortGroupName(util.DenyAllSecurityGroup)
// reset pg ports
if err := c.ovnClient.PortGroupResetPorts(pgName); err != nil {
klog.Error(err)
return err
}
// add port
if len(addPorts) == 0 {
return nil
}
klog.V(6).Infof("add ports %v to port group %s", addPorts, pgName)
if err := c.ovnClient.PortGroupAddPorts(pgName, addPorts...); err != nil {
klog.Errorf("add ports to port group %s: %v", pgName, err)
return err
}
return nil
}
func (c *Controller) handleAddOrUpdateSg(key string) error {
c.sgKeyMutex.Lock(key)
defer c.sgKeyMutex.Unlock(key)
// set 'deny all' for port associated with security group
if key == util.DenyAllSecurityGroup {
if err := c.updateDenyAllSgPorts(); err != nil {
klog.Errorf("update sg deny all policy failed. %v", err)
return err
}
}
cachedSg, err := c.sgsLister.Get(key)
if err != nil {
if k8serrors.IsNotFound(err) {
return nil
}
return err
}
sg := cachedSg.DeepCopy()
if err = c.validateSgRule(sg); err != nil {
return err
}
if err = c.ovnLegacyClient.CreateSgPortGroup(sg.Name); err != nil {
return fmt.Errorf("failed to create sg port_group %s, %v", key, err.Error())
}
if err = c.ovnLegacyClient.CreateSgAssociatedAddressSet(sg.Name); err != nil {
return fmt.Errorf("failed to create sg associated address_set %s, %v", key, err.Error())
}
ingressNeedUpdate := false
egressNeedUpdate := false
// check md5
newIngressMd5 := fmt.Sprintf("%x", structhash.Md5(sg.Spec.IngressRules, 1))
if !sg.Status.IngressLastSyncSuccess || newIngressMd5 != sg.Status.IngressMd5 {
klog.Infof("ingress need update, sg:%s", sg.Name)
ingressNeedUpdate = true
}
newEgressMd5 := fmt.Sprintf("%x", structhash.Md5(sg.Spec.EgressRules, 1))
if !sg.Status.EgressLastSyncSuccess || newEgressMd5 != sg.Status.EgressMd5 {
klog.Infof("egress need update, sg:%s", sg.Name)
egressNeedUpdate = true
}
// check allowSameGroupTraffic switch
if sg.Status.AllowSameGroupTraffic != sg.Spec.AllowSameGroupTraffic {
klog.Infof("both ingress && egress need update, sg:%s", sg.Name)
ingressNeedUpdate = true
egressNeedUpdate = true
}
// update sg rule
if ingressNeedUpdate {
if err = c.ovnLegacyClient.UpdateSgACL(sg, ovs.SgAclIngressDirection); err != nil {
sg.Status.IngressLastSyncSuccess = false
c.patchSgStatus(sg)
return err
}
if err := c.ovnLegacyClient.CreateSgBaseIngressACL(sg.Name); err != nil {
return err
}
sg.Status.IngressMd5 = newIngressMd5
sg.Status.IngressLastSyncSuccess = true
c.patchSgStatus(sg)
}
if egressNeedUpdate {
if err = c.ovnLegacyClient.UpdateSgACL(sg, ovs.SgAclEgressDirection); err != nil {
sg.Status.EgressLastSyncSuccess = false
c.patchSgStatus(sg)
return err
}
if err := c.ovnLegacyClient.CreateSgBaseEgressACL(sg.Name); err != nil {
return err
}
sg.Status.EgressMd5 = newEgressMd5
sg.Status.EgressLastSyncSuccess = true
c.patchSgStatus(sg)
}
// update status
sg.Status.PortGroup = ovs.GetSgPortGroupName(sg.Name)
sg.Status.AllowSameGroupTraffic = sg.Spec.AllowSameGroupTraffic
c.patchSgStatus(sg)
c.syncSgPortsQueue.Add(key)
return nil
}
func (c *Controller) validateSgRule(sg *kubeovnv1.SecurityGroup) error {
// check sg rules
allRules := append(sg.Spec.IngressRules, sg.Spec.EgressRules...)
for _, rule := range allRules {
if rule.IPVersion != "ipv4" && rule.IPVersion != "ipv6" {
return fmt.Errorf("IPVersion should be 'ipv4' or 'ipv6'")
}
if rule.Priority < 1 || rule.Priority > 200 {
return fmt.Errorf("priority '%d' is not in the range of 1 to 200", rule.Priority)
}
switch rule.RemoteType {
case kubeovnv1.SgRemoteTypeAddress:
if strings.Contains(rule.RemoteAddress, "/") {
if _, _, err := net.ParseCIDR(rule.RemoteAddress); err != nil {
return fmt.Errorf("invalid CIDR '%s'", rule.RemoteAddress)
}
} else {
if net.ParseIP(rule.RemoteAddress) == nil {
return fmt.Errorf("invalid ip address '%s'", rule.RemoteAddress)
}
}
case kubeovnv1.SgRemoteTypeSg:
_, err := c.sgsLister.Get(rule.RemoteSecurityGroup)
if err != nil {
return fmt.Errorf("failed to get remote sg '%s', %v", rule.RemoteSecurityGroup, err)
}
default:
return fmt.Errorf("not support sgRemoteType '%s'", rule.RemoteType)
}
if rule.Protocol == kubeovnv1.ProtocolTCP || rule.Protocol == kubeovnv1.ProtocolUDP {
if rule.PortRangeMin < 1 || rule.PortRangeMin > 65535 || rule.PortRangeMax < 1 || rule.PortRangeMax > 65535 {
return fmt.Errorf("portRange is out of range")
}
if rule.PortRangeMin > rule.PortRangeMax {
return fmt.Errorf("portRange err, range Minimum value greater than maximum value")
}
}
}
return nil
}
func (c *Controller) patchSgStatus(sg *kubeovnv1.SecurityGroup) {
bytes, err := sg.Status.Bytes()
if err != nil {
klog.Error(err)
return
} else {
if _, err = c.config.KubeOvnClient.KubeovnV1().SecurityGroups().Patch(context.Background(), sg.Name, types.MergePatchType, bytes, metav1.PatchOptions{}, "status"); err != nil {
klog.Error("patch security group status failed", err)
}
}
}
func (c *Controller) handleDeleteSg(key string) error {
c.sgKeyMutex.Lock(key)
defer c.sgKeyMutex.Unlock(key)
return c.ovnLegacyClient.DeleteSgPortGroup(key)
}
func (c *Controller) syncSgLogicalPort(key string) error {
c.sgKeyMutex.Lock(key)
defer c.sgKeyMutex.Unlock(key)
sg, err := c.sgsLister.Get(key)
if err != nil {
if k8serrors.IsNotFound(err) {
klog.Errorf("sg '%s' not found.", key)
return nil
}
klog.Errorf("failed to get sg '%s'. %v", key, err)
return err
}
results, err := c.ovnLegacyClient.CustomFindEntity("logical_switch_port", []string{"_uuid", "name", "port_security"}, fmt.Sprintf("external_ids:associated_sg_%s=true", key))
if err != nil {
klog.Errorf("failed to find logical port, %v", err)
return err
}
if len(results) == 0 {
return nil
}
var v4s, v6s []string
var ports []string
for _, ret := range results {
if len(ret["port_security"]) < 2 {
continue
}
ports = append(ports, ret["name"][0])
for _, address := range ret["port_security"][1:] {
if strings.Contains(address, ":") {
v6s = append(v6s, address)
} else {
v4s = append(v4s, address)
}
}
}
if err = c.ovnLegacyClient.SetPortsToPortGroup(sg.Status.PortGroup, ports); err != nil {
klog.Errorf("failed to set port to sg, %v", err)
return err
}
if err = c.ovnLegacyClient.SetAddressesToAddressSet(v4s, ovs.GetSgV4AssociatedName(key)); err != nil {
klog.Errorf("failed to set address_set, %v", err)
return err
}
if err = c.ovnLegacyClient.SetAddressesToAddressSet(v6s, ovs.GetSgV6AssociatedName(key)); err != nil {
klog.Errorf("failed to set address_set, %v", err)
return err
}
c.addOrUpdateSgQueue.Add(util.DenyAllSecurityGroup)
return nil
}
func (c *Controller) getPortSg(port *ovnnb.LogicalSwitchPort) ([]string, error) {
var sgList []string
for key, value := range port.ExternalIDs {
if strings.HasPrefix(key, "associated_sg_") && value == "true" {
sgName := strings.ReplaceAll(key, "associated_sg_", "")
sgList = append(sgList, sgName)
}
}
return sgList, nil
}
func (c *Controller) reconcilePortSg(portName, securityGroups string) error {
port, err := c.ovnClient.GetLogicalSwitchPort(portName, false)
if err != nil {
klog.Errorf("failed to get logical switch port %s: %v", portName, err)
return err
}
oldSgList, err := c.getPortSg(port)
if err != nil {
klog.Errorf("get port sg failed, %v", err)
return err
}
klog.Infof("reconcile port sg, port='%s', oldSgList='%s', newSgList='%s'", portName, oldSgList, securityGroups)
newSgList := strings.Split(securityGroups, ",")
diffSgList := util.DiffStringSlice(oldSgList, newSgList)
for _, sgName := range diffSgList {
if sgName == "" {
continue
}
needAssociated := "false"
if util.ContainsString(newSgList, sgName) {
needAssociated = "true"
}
if err = c.ovnLegacyClient.SetPortExternalIds(portName, fmt.Sprintf("associated_sg_%s", sgName), needAssociated); err != nil {
klog.Errorf("set port '%s' external_ids failed, %v", portName, err)
return err
}
c.syncSgPortsQueue.Add(sgName)
}
if err = c.ovnLegacyClient.SetPortExternalIds(portName, "security_groups", strings.ReplaceAll(securityGroups, ",", "/")); err != nil {
klog.Errorf("set port '%s' external_ids failed, %v", portName, err)
return err
}
return nil
}
// securityGroupAllNotExist return true if all sgs does not exist
func (c *Controller) securityGroupAllNotExist(sgs []string) (bool, error) {
if len(sgs) == 0 {
return true, nil
}
notExistsCount := 0
// sgs format: sg1/sg2/sg3
for _, sg := range sgs {
ok, err := c.ovnClient.PortGroupExists(ovs.GetSgPortGroupName(sg))
if err != nil {
return true, err
}
if !ok {
notExistsCount++
}
}
return notExistsCount == len(sgs), nil
}
|
package cli
import (
"fmt"
"strings"
"github.com/mebyus/ffd/cli/command"
"github.com/mebyus/ffd/resource"
"github.com/mebyus/ffd/resource/fiction"
)
type downloadExecutor struct{}
func NewDownloadExecutor() *downloadExecutor {
return &downloadExecutor{}
}
func NewDownloadTemplate() (template *command.Template) {
template = &command.Template{
Name: "download",
Description: command.Description{
Short: "download a fic",
},
ValueFlags: []command.ValueFlag{
{
Flag: command.Flag{
Aliases: map[string]command.AliasType{
"o": command.SingleChar,
"out": command.MultipleChars,
},
},
Default: "",
},
{
Flag: command.Flag{
Aliases: map[string]command.AliasType{
"f": command.SingleChar,
"format": command.MultipleChars,
},
},
Default: "txt",
},
},
BoolFlags: []command.BoolFlag{
{
Flag: command.Flag{
Aliases: map[string]command.AliasType{
"s": command.SingleChar,
"save-source": command.MultipleChars,
},
},
Default: false,
},
},
}
return
}
func (e *downloadExecutor) Execute(cmd *command.Command) (err error) {
if len(cmd.Targets) == 0 {
return fmt.Errorf("target is not specified")
}
saveSource := cmd.BoolFlags["save-source"]
format := fiction.RenderFormat(strings.ToUpper(cmd.ValueFlags["format"]))
err = resource.Download(cmd.Targets[0], saveSource, format)
return
}
|
package main
import "fmt"
func main() {
i,j := 10,20
// like c/c++ or others go doesn't has any () parentesis in its if--else condition statement
// if..else if...else format is matter
if i<j {
fmt.Printf("%v is less than %v\n",i,j)
} else if i==j {
fmt.Printf("%v is equal to %v\n",i,j)
}else {
fmt.Printf("%v is greater than %v\n",i,j)
}
} |
// Copyright 2018 Aleksandr Demakin. All rights reserved.
package printer
import (
"bytes"
"errors"
"io/ioutil"
"testing"
"github.com/avdva/unravel/card"
"github.com/avdva/unravel/hash"
"github.com/stretchr/testify/require"
)
type errorWriter struct{}
func (e *errorWriter) Write(buff []byte) (int, error) {
return 0, errors.New("errorWriter")
}
type logger struct {
e error
}
func (l *logger) Printf(s string, args ...interface{}) {
l.e = args[0].(error)
}
func TestPrinter(t *testing.T) {
r := require.New(t)
buf := bytes.NewBuffer(nil)
p := New(buf, hash.MakeHasher("pjw"), nil)
h := card.EventHeader{
SessionID: "1",
WebsiteURL: "google.com",
}
p.OnResize(h, card.Dimension{800, 600}, card.Dimension{1920, 1018})
bytes, err := ioutil.ReadAll(buf)
r.NoError(err)
r.Equal([]byte("{WebsiteUrl:google.com SessionId:1 ResizeFrom:{Width:800 Height:600} ResizeTo:{Width:1920 Height:1018} CopyAndPaste:map[] FormCompletionTime:0}\n"), bytes)
p.OnCopyPaste(h, "form1", false)
bytes, err = ioutil.ReadAll(buf)
r.NoError(err)
r.Equal([]byte("{WebsiteUrl:google.com SessionId:1 ResizeFrom:{Width:800 Height:600} ResizeTo:{Width:1920 Height:1018} CopyAndPaste:map[form1:false] FormCompletionTime:0}\n"), bytes)
p.OnCopyPaste(h, "form1", true)
bytes, err = ioutil.ReadAll(buf)
r.NoError(err)
r.Equal([]byte("{WebsiteUrl:google.com SessionId:1 ResizeFrom:{Width:800 Height:600} ResizeTo:{Width:1920 Height:1018} CopyAndPaste:map[form1:true] FormCompletionTime:0}\n"), bytes)
p.OnSubmit(h, 1313)
bytes, err = ioutil.ReadAll(buf)
r.NoError(err)
r.Equal([]byte("{WebsiteUrl:google.com SessionId:1 ResizeFrom:{Width:800 Height:600} ResizeTo:{Width:1920 Height:1018} CopyAndPaste:map[form1:true] FormCompletionTime:1313}, hash = 0E22B00D\n"), bytes)
h.SessionID = "2"
h.WebsiteURL = "stackoverflow.com"
p.OnResize(h, card.Dimension{1920, 1018}, card.Dimension{800, 600})
bytes, err = ioutil.ReadAll(buf)
r.NoError(err)
r.Equal([]byte("{WebsiteUrl:stackoverflow.com SessionId:2 ResizeFrom:{Width:1920 Height:1018} ResizeTo:{Width:800 Height:600} CopyAndPaste:map[] FormCompletionTime:0}\n"), bytes)
p.OnSubmit(h, 123)
bytes, err = ioutil.ReadAll(buf)
r.NoError(err)
r.Equal([]byte("{WebsiteUrl:stackoverflow.com SessionId:2 ResizeFrom:{Width:1920 Height:1018} ResizeTo:{Width:800 Height:600} CopyAndPaste:map[] FormCompletionTime:123}, hash = 0180272D\n"), bytes)
l := &logger{}
p = New(&errorWriter{}, hash.MakeHasher("pjw"), l)
p.OnSubmit(h, 123)
r.Equal("errorWriter", l.e.Error())
}
|
package main
import (
"bytes"
"encoding/json"
"fmt"
"html/template"
"io/ioutil"
"log"
"os"
"path/filepath"
"strings"
)
func getApibFileContent(c Collection) string {
tpl := `
# Group {{ .Info.Name }}
{{ .Info.Description }}
{{ range .Items }}
{{ .Markup }}
{{ end }}
`
t := template.New("Template")
t, _ = t.Parse(tpl)
var doc bytes.Buffer
t.Execute(&doc, c)
s := doc.String()
return s
}
func getResponseFiles(items []CollectionItem) []map[string]string {
var files []map[string]string
for _, item := range items {
responses := item.ResponseList()
for _, response := range responses {
m := map[string]string{}
m["path"] = response.BodyIncludePath(item.Request)
m["body"] = response.FormattedBody()
files = append(files, m)
}
}
return files
}
func writeToFile(path string, content string, force bool) {
if _, err := os.Stat(path); os.IsNotExist(err) || force {
os.MkdirAll(filepath.Dir(path), os.ModePerm)
err := ioutil.WriteFile(path, []byte(content), 0644)
if err == nil {
fmt.Printf("Created %v\n", path)
}
}
}
func shouldWriteFiles(c Config) bool {
return c.DumpRequest == ""
}
func main() {
config := Config{}
config.Init()
if config.CollectionPath == "" {
fmt.Println("No collection file defined!")
return
}
file, _ := ioutil.ReadFile(config.CollectionPath)
var c Collection
err := json.Unmarshal(file, &c)
if err != nil {
log.Fatal("Error in unmarshaling postman collection: ", err)
}
apibFileName := strings.Replace(c.Info.Name, " ", "-", -1)
if config.ApibFileName != "" {
apibFileName = config.ApibFileName
}
if config.EnvironmentPath != "" {
file, _ := ioutil.ReadFile(config.EnvironmentPath)
json.Unmarshal(file, &DefaultCollectionEnv)
}
apibFile := getApibFileContent(c)
if shouldWriteFiles(config) {
writeToFile(
fmt.Sprintf("%v/%v.apib", filepath.Clean(config.DestinationPath), apibFileName),
apibFile,
config.ForceApibCreation,
)
for _, file := range getResponseFiles(c.Items) {
writeToFile(
fmt.Sprintf("%v/%v", filepath.Clean(config.DestinationPath), file["path"]),
file["body"],
config.ForceResponsesCreation,
)
}
}
if config.DumpRequest != "" {
for _, request := range c.Items {
if request.Name == config.DumpRequest {
fmt.Println(request.Markup())
}
}
}
}
|
package metrics
import (
"time"
"github.com/prometheus/client_golang/prometheus"
)
func (r *Registry) init() {
r.uptimeCounter = prometheus.NewCounter(
prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: `uptime`,
Help: `count seconds running`,
},
)
r.startUptimeCounterAsync(time.Second * 15)
r.r.MustRegister(r.uptimeCounter)
r.homeCounter = prometheus.NewCounter(
prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: `home_counter`,
},
)
r.r.MustRegister(r.homeCounter)
r.pageViewCounter = prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: `page_view`,
},
[]string{`id`},
)
r.r.MustRegister(r.pageViewCounter)
r.userAgentCounter = prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: `user_agent`,
},
[]string{`bot`, `browser_name`, `browser_version`, `mobile`, `os_name`, `os_version`, `platform`},
)
r.r.MustRegister(r.userAgentCounter)
}
func (r *Registry) startUptimeCounterAsync(interval time.Duration) {
lastTime := time.Now()
count := func() {
now := time.Now()
elapsed := now.Sub(lastTime)
r.uptimeCounter.Add(elapsed.Seconds())
lastTime = now
}
loop := func() {
t := time.NewTicker(interval)
defer t.Stop()
for {
select {
case <-r.ctx.Done():
return
case <-t.C:
count()
}
}
}
go loop()
}
|
package main
import "fmt"
func main() {
i := 1
//Go não tem operações aritméticas de ponteiros
var p *int = nil
p = &i // pegando o endereço da variavel i
*p++
i++
fmt.Println(p, *p, i, &i)
}
|
// Copyright 2016 Albert Nigmatzianov. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package client
import (
"errors"
"fmt"
"net/url"
"github.com/bogem/vnehm/ui"
"github.com/valyala/fasthttp"
)
const apiURL = "https://api.vk.com/method"
var (
ErrForbidden = errors.New("403 - Forbidden")
ErrNotFound = errors.New("404 - Not Found")
)
func getTracks(params url.Values) ([]byte, error) {
uri := formTracksURI(params)
return get(uri)
}
func formTracksURI(params url.Values) string {
return apiURL + "/audio.get?" + params.Encode()
}
func search(params url.Values) ([]byte, error) {
uri := formSearchURI(params)
return get(uri)
}
func formSearchURI(params url.Values) string {
return apiURL + "/audio.search?" + params.Encode()
}
func wallAudios(params url.Values) ([]byte, error) {
uri := formWallAudiosURI(params)
return get(uri)
}
func formWallAudiosURI(params url.Values) string {
return apiURL + "/wall.getById?" + params.Encode()
}
func get(uri string) ([]byte, error) {
statusCode, body, err := fasthttp.Get(nil, uri)
if err != nil {
return nil, err
}
if err := handleStatusCode(statusCode); err != nil {
return nil, err
}
return body, nil
}
func handleStatusCode(statusCode int) error {
switch {
case statusCode == 403:
return ErrForbidden
case statusCode == 404:
return ErrNotFound
case statusCode >= 300 && statusCode < 500:
return fmt.Errorf("invalid response from VK: %v", statusCode)
case statusCode >= 500:
ui.Term("there is a problem by VK. Please wait a while", nil)
}
return nil
}
|
// Copyright 2019 The Cockroach Authors.
//
// Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt.
//
// As of the Change Date specified in that file, in accordance with
// the Business Source License, use of this software will be governed
// by the Apache License, Version 2.0, included in the file
// licenses/APL.txt.
package sql
import (
"context"
"sync"
"github.com/cockroachdb/cockroach/pkg/roachpb"
"github.com/cockroachdb/cockroach/pkg/sql/catalog"
"github.com/cockroachdb/cockroach/pkg/sql/catalog/colinfo"
"github.com/cockroachdb/cockroach/pkg/sql/catalog/descpb"
"github.com/cockroachdb/cockroach/pkg/sql/opt/exec"
"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgcode"
"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"
"github.com/cockroachdb/cockroach/pkg/sql/row"
"github.com/cockroachdb/cockroach/pkg/sql/rowenc"
"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
"github.com/cockroachdb/cockroach/pkg/sql/span"
"github.com/cockroachdb/cockroach/pkg/util/log"
"github.com/cockroachdb/errors"
)
var insertFastPathNodePool = sync.Pool{
New: func() interface{} {
return &insertFastPathNode{}
},
}
// insertFastPathNode is a faster implementation of inserting values in a table
// and performing FK checks. It is used when all the foreign key checks can be
// performed via a direct lookup in an index, and when the input is VALUES of
// limited size (at most mutations.MaxBatchSize).
type insertFastPathNode struct {
// input values, similar to a valuesNode.
input [][]tree.TypedExpr
// columns is set if this INSERT is returning any rows, to be
// consumed by a renderNode upstream. This occurs when there is a
// RETURNING clause with some scalar expressions.
columns colinfo.ResultColumns
run insertFastPathRun
}
type insertFastPathRun struct {
insertRun
fkChecks []insertFastPathFKCheck
numInputCols int
// inputBuf stores the evaluation result of the input rows, linearized into a
// single slice; see inputRow(). Unfortunately we can't do everything one row
// at a time, because we need the datums for generating error messages in case
// an FK check fails.
inputBuf tree.Datums
// fkBatch accumulates the FK existence checks.
fkBatch roachpb.BatchRequest
// fkSpanInfo keeps track of information for each fkBatch.Request entry.
fkSpanInfo []insertFastPathFKSpanInfo
// fkSpanMap is used to de-duplicate FK existence checks. Only used if there
// is more than one input row.
fkSpanMap map[string]struct{}
}
// insertFastPathFKSpanInfo records information about each Request in the
// fkBatch, associating it with a specific check and row index.
type insertFastPathFKSpanInfo struct {
check *insertFastPathFKCheck
rowIdx int
}
// insertFastPathFKCheck extends exec.InsertFastPathFKCheck with metadata that
// is computed once and can be reused across rows.
type insertFastPathFKCheck struct {
exec.InsertFastPathFKCheck
tabDesc catalog.TableDescriptor
idxDesc *descpb.IndexDescriptor
keyPrefix []byte
colMap catalog.TableColMap
spanBuilder *span.Builder
}
func (c *insertFastPathFKCheck) init(params runParams) error {
idx := c.ReferencedIndex.(*optIndex)
c.tabDesc = c.ReferencedTable.(*optTable).desc
c.idxDesc = idx.desc
codec := params.ExecCfg().Codec
c.keyPrefix = rowenc.MakeIndexKeyPrefix(codec, c.tabDesc, c.idxDesc.ID)
c.spanBuilder = span.MakeBuilder(params.EvalContext(), codec, c.tabDesc, c.idxDesc)
if len(c.InsertCols) > idx.numLaxKeyCols {
return errors.AssertionFailedf(
"%d FK cols, only %d cols in index", len(c.InsertCols), idx.numLaxKeyCols,
)
}
for i, ord := range c.InsertCols {
var colID descpb.ColumnID
if i < len(c.idxDesc.ColumnIDs) {
colID = c.idxDesc.ColumnIDs[i]
} else {
colID = c.idxDesc.ExtraColumnIDs[i-len(c.idxDesc.ColumnIDs)]
}
c.colMap.Set(colID, int(ord))
}
return nil
}
// generateSpan returns the span that we need to look up to confirm existence of
// the referenced row.
func (c *insertFastPathFKCheck) generateSpan(inputRow tree.Datums) (roachpb.Span, error) {
return row.FKCheckSpan(c.spanBuilder, inputRow, c.colMap, len(c.InsertCols))
}
// errorForRow returns an error indicating failure of this FK check for the
// given row.
func (c *insertFastPathFKCheck) errorForRow(inputRow tree.Datums) error {
values := make(tree.Datums, len(c.InsertCols))
for i, ord := range c.InsertCols {
values[i] = inputRow[ord]
}
return c.MkErr(values)
}
func (r *insertFastPathRun) inputRow(rowIdx int) tree.Datums {
start := rowIdx * r.numInputCols
end := start + r.numInputCols
return r.inputBuf[start:end:end]
}
// addFKChecks adds Requests to fkBatch and entries in fkSpanInfo / fkSpanMap as
// needed for checking foreign keys for the given row.
func (r *insertFastPathRun) addFKChecks(
ctx context.Context, rowIdx int, inputRow tree.Datums,
) error {
for i := range r.fkChecks {
c := &r.fkChecks[i]
// See if we have any nulls.
numNulls := 0
for _, ord := range c.InsertCols {
if inputRow[ord] == tree.DNull {
numNulls++
}
}
if numNulls > 0 {
if c.MatchMethod == tree.MatchFull && numNulls != len(c.InsertCols) {
return c.errorForRow(inputRow)
}
// We have a row with only NULLS, or a row with some NULLs and match
// method PARTIAL. We can ignore this row.
return nil
}
span, err := c.generateSpan(inputRow)
if err != nil {
return err
}
if r.fkSpanMap != nil {
_, exists := r.fkSpanMap[string(span.Key)]
if exists {
// Duplicate span.
continue
}
r.fkSpanMap[string(span.Key)] = struct{}{}
}
if r.traceKV {
log.VEventf(ctx, 2, "FKScan %s", span)
}
reqIdx := len(r.fkBatch.Requests)
r.fkBatch.Requests = append(r.fkBatch.Requests, roachpb.RequestUnion{})
r.fkBatch.Requests[reqIdx].MustSetInner(&roachpb.ScanRequest{
RequestHeader: roachpb.RequestHeaderFromSpan(span),
})
r.fkSpanInfo = append(r.fkSpanInfo, insertFastPathFKSpanInfo{
check: c,
rowIdx: rowIdx,
})
}
return nil
}
// runFKChecks runs the fkBatch and checks that all spans return at least one
// key.
func (n *insertFastPathNode) runFKChecks(params runParams) error {
if len(n.run.fkBatch.Requests) == 0 {
return nil
}
defer n.run.fkBatch.Reset()
// Run the FK checks batch.
br, err := params.p.txn.Send(params.ctx, n.run.fkBatch)
if err != nil {
return err.GoError()
}
for i := range br.Responses {
resp := br.Responses[i].GetInner().(*roachpb.ScanResponse)
if len(resp.Rows) == 0 {
// No results for lookup; generate the violation error.
info := n.run.fkSpanInfo[i]
return info.check.errorForRow(n.run.inputRow(info.rowIdx))
}
}
return nil
}
func (n *insertFastPathNode) startExec(params runParams) error {
// Cache traceKV during execution, to avoid re-evaluating it for every row.
n.run.traceKV = params.p.ExtendedEvalContext().Tracing.KVTracingEnabled()
n.run.initRowContainer(params, n.columns)
n.run.numInputCols = len(n.input[0])
n.run.inputBuf = make(tree.Datums, len(n.input)*n.run.numInputCols)
if len(n.input) > 1 {
n.run.fkSpanMap = make(map[string]struct{})
}
if len(n.run.fkChecks) > 0 {
for i := range n.run.fkChecks {
if err := n.run.fkChecks[i].init(params); err != nil {
return err
}
}
maxSpans := len(n.run.fkChecks) * len(n.input)
n.run.fkBatch.Requests = make([]roachpb.RequestUnion, 0, maxSpans)
n.run.fkSpanInfo = make([]insertFastPathFKSpanInfo, 0, maxSpans)
if len(n.input) > 1 {
n.run.fkSpanMap = make(map[string]struct{}, maxSpans)
}
}
return n.run.ti.init(params.ctx, params.p.txn, params.EvalContext())
}
// Next is required because batchedPlanNode inherits from planNode, but
// batchedPlanNode doesn't really provide it. See the explanatory comments
// in plan_batch.go.
func (n *insertFastPathNode) Next(params runParams) (bool, error) { panic("not valid") }
// Values is required because batchedPlanNode inherits from planNode, but
// batchedPlanNode doesn't really provide it. See the explanatory comments
// in plan_batch.go.
func (n *insertFastPathNode) Values() tree.Datums { panic("not valid") }
// BatchedNext implements the batchedPlanNode interface.
func (n *insertFastPathNode) BatchedNext(params runParams) (bool, error) {
if n.run.done {
return false, nil
}
// The fast path node does everything in one batch.
for rowIdx, tupleRow := range n.input {
if err := params.p.cancelChecker.Check(); err != nil {
return false, err
}
inputRow := n.run.inputRow(rowIdx)
for col, typedExpr := range tupleRow {
var err error
inputRow[col], err = typedExpr.Eval(params.EvalContext())
if err != nil {
err = interceptAlterColumnTypeParseError(n.run.insertCols, col, err)
return false, err
}
}
// Process the insertion for the current source row, potentially
// accumulating the result row for later.
if err := n.run.processSourceRow(params, inputRow); err != nil {
return false, err
}
// Add FK existence checks.
if len(n.run.fkChecks) > 0 {
if err := n.run.addFKChecks(params.ctx, rowIdx, inputRow); err != nil {
return false, err
}
}
}
// Perform the FK checks.
// TODO(radu): we could run the FK batch in parallel with the main batch (if
// we aren't auto-committing).
if err := n.runFKChecks(params); err != nil {
return false, err
}
if err := n.run.ti.finalize(params.ctx); err != nil {
return false, err
}
// Remember we're done for the next call to BatchedNext().
n.run.done = true
// Possibly initiate a run of CREATE STATISTICS.
params.ExecCfg().StatsRefresher.NotifyMutation(n.run.ti.ri.Helper.TableDesc.GetID(), len(n.input))
return true, nil
}
// BatchedCount implements the batchedPlanNode interface.
func (n *insertFastPathNode) BatchedCount() int { return len(n.input) }
// BatchedCount implements the batchedPlanNode interface.
func (n *insertFastPathNode) BatchedValues(rowIdx int) tree.Datums { return n.run.ti.rows.At(rowIdx) }
func (n *insertFastPathNode) Close(ctx context.Context) {
n.run.ti.close(ctx)
*n = insertFastPathNode{}
insertFastPathNodePool.Put(n)
}
// See planner.autoCommit.
func (n *insertFastPathNode) enableAutoCommit() {
n.run.ti.enableAutoCommit()
}
// interceptAlterColumnTypeParseError wraps a type parsing error with a warning
// about the column undergoing an ALTER COLUMN TYPE schema change.
// If colNum is not -1, only the colNum'th column in insertCols will be checked
// for AlterColumnTypeInProgress, otherwise every column in insertCols will
// be checked.
func interceptAlterColumnTypeParseError(
insertCols []descpb.ColumnDescriptor, colNum int, err error,
) error {
// Only intercept the error if the column being inserted into
// is an actual column. This is to avoid checking on values that don't
// correspond to an actual column, for example a check constraint.
if colNum >= len(insertCols) {
return err
}
var insertCol descpb.ColumnDescriptor
// wrapParseError is a helper function that checks if an insertCol has the
// AlterColumnTypeInProgress flag and wraps the parse error msg stating
// that the error may be because the column is being altered.
// Returns if the error msg has been wrapped and the wrapped error msg.
wrapParseError := func(insertCol descpb.ColumnDescriptor, colNum int, err error) (bool, error) {
if insertCol.AlterColumnTypeInProgress {
code := pgerror.GetPGCode(err)
if code == pgcode.InvalidTextRepresentation {
if colNum != -1 {
// If a column is specified, we can ensure the parse error
// is happening because the column is undergoing an alter column type
// schema change.
return true, errors.Wrapf(err,
"This table is still undergoing the ALTER COLUMN TYPE schema change, "+
"this insert is not supported until the schema change is finalized")
}
// If no column is specified, the error message is slightly changed to say
// that the error MAY be because a column is undergoing an alter column type
// schema change.
return true, errors.Wrap(err,
"This table is still undergoing the ALTER COLUMN TYPE schema change, "+
"this insert may not be supported until the schema change is finalized")
}
}
return false, err
}
// If a colNum is specified, we just check the one column for
// AlterColumnTypeInProgress and return the error whether it's wrapped or not.
if colNum != -1 {
insertCol = insertCols[colNum]
_, err = wrapParseError(insertCol, colNum, err)
return err
}
// If the colNum is -1, we check every insertCol for AlterColumnTypeInProgress.
for _, insertCol = range insertCols {
var changed bool
changed, err = wrapParseError(insertCol, colNum, err)
if changed {
return err
}
}
return err
}
|
package nbanews
type Media interface {
TargetURL() string
Fetch() error
ArticleList() []*Article
}
type Article struct {
Title string
URL string
}
|
// Copyright 2019 The gVisor 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 lib
import (
"fmt"
"os"
"os/exec"
"regexp"
"strings"
)
// Directories to exclude from tests.
var javaExclDirs = regexp.MustCompile(`(^(sun\/security)|(java\/util\/stream)|(java\/time)| )`)
// Location of java tests.
const javaTestDir = "/root/jdk/test/jdk"
// javaRunner implements TestRunner for Java.
type javaRunner struct{}
var _ TestRunner = javaRunner{}
// ListTests implements TestRunner.ListTests.
func (javaRunner) ListTests() ([]string, error) {
args := []string{
"-dir:" + javaTestDir,
"-ignore:quiet",
"-a",
"-listtests",
":jdk_core",
":jdk_svc",
":jdk_sound",
":jdk_imageio",
}
cmd := exec.Command("jtreg", args...)
cmd.Stderr = os.Stderr
out, err := cmd.Output()
if err != nil {
return nil, fmt.Errorf("jtreg -listtests : %v", err)
}
var testSlice []string
for _, test := range strings.Split(string(out), "\n") {
if !javaExclDirs.MatchString(test) {
testSlice = append(testSlice, test)
}
}
return testSlice, nil
}
// TestCmds implements TestRunner.TestCmds.
func (javaRunner) TestCmds(tests []string) []*exec.Cmd {
args := append(
[]string{
"-agentvm", // Execute each action using a pool of reusable JVMs.
"-dir:" + javaTestDir, // Base directory for test files and directories.
"-noreport", // Do not generate /root/JTreport/html/report.html.
"-timeoutFactor:5", // Extend the default timeout (2 min) of all tests by this factor.
"-verbose:all", // Verbose output.
"-tl:200", // Do not run tests which specify a timeout longer than 200s.
},
tests...,
)
return []*exec.Cmd{exec.Command("jtreg", args...)}
}
|
package memstr
import "testing"
var (
memoryTests = map[string]int64{
"1k": 1000,
"2K": 2048,
}
)
func TestParseMemory(t *testing.T) {
for k, v := range memoryTests {
n, err := Parse(k)
if err != nil {
t.Error(err)
}
if n != v {
t.Fail()
}
}
}
|
package plugconf
import (
"reflect"
"testing"
"github.com/vim-volt/volt/lockjson"
"github.com/vim-volt/volt/pathutil"
)
func TestSortByDepends(t *testing.T) {
type input struct {
reposList []lockjson.Repos
plugconfMap map[pathutil.ReposPath]*ParsedInfo
}
cases := []struct {
input input
want []lockjson.Repos
}{
{
input: input{
reposList: []lockjson.Repos{
{Path: pathutil.DecodeReposPath("test/test-1")},
{Path: pathutil.DecodeReposPath("test/test-2")},
{Path: pathutil.DecodeReposPath("test/test-3")},
},
plugconfMap: map[pathutil.ReposPath]*ParsedInfo{
pathutil.DecodeReposPath("test/test-1"): {
depends: []pathutil.ReposPath{
pathutil.DecodeReposPath("test/test-2"),
},
},
pathutil.DecodeReposPath("test/test-2"): {
depends: []pathutil.ReposPath{
pathutil.DecodeReposPath("test/test-3"),
},
},
pathutil.DecodeReposPath("test/test-3"): {},
},
},
want: []lockjson.Repos{
{Path: pathutil.DecodeReposPath("test/test-3")},
{Path: pathutil.DecodeReposPath("test/test-2")},
{Path: pathutil.DecodeReposPath("test/test-1")},
},
},
{
input: input{
reposList: []lockjson.Repos{
{Path: pathutil.DecodeReposPath("Shougo/ddc-matcher_head")},
{Path: pathutil.DecodeReposPath("Shougo/ddc.vim")},
{Path: pathutil.DecodeReposPath("shun/ddc-vim-lsp")},
{Path: pathutil.DecodeReposPath("vim-denops/denops.vim")},
},
plugconfMap: map[pathutil.ReposPath]*ParsedInfo{
pathutil.DecodeReposPath("vim-denops/denops.vim"): {},
pathutil.DecodeReposPath("Shougo/ddc.vim"): {
depends: []pathutil.ReposPath{
pathutil.DecodeReposPath("vim-denops/denops.vim"),
},
},
pathutil.DecodeReposPath("Shougo/ddc-matcher_head"): {
depends: []pathutil.ReposPath{
pathutil.DecodeReposPath("vim-denops/denops.vim"),
pathutil.DecodeReposPath("Shougo/ddc.vim"),
},
},
pathutil.DecodeReposPath("shun/ddc-vim-lsp"): {
depends: []pathutil.ReposPath{
pathutil.DecodeReposPath("vim-denops/denops.vim"),
pathutil.DecodeReposPath("Shougo/ddc.vim"),
pathutil.DecodeReposPath("Shougo/ddc-matcher_head"),
},
},
},
},
want: []lockjson.Repos{
{Path: pathutil.DecodeReposPath("vim-denops/denops.vim")},
{Path: pathutil.DecodeReposPath("Shougo/ddc.vim")},
{Path: pathutil.DecodeReposPath("Shougo/ddc-matcher_head")},
{Path: pathutil.DecodeReposPath("shun/ddc-vim-lsp")},
},
},
}
for _, tt := range cases {
sortByDepends(tt.input.reposList, tt.input.plugconfMap)
if !reflect.DeepEqual(tt.input.reposList, tt.want) {
t.Fatalf("want: %v, but got: %v", tt.want, tt.input.reposList)
}
}
}
|
// Copyright 2019 Liquidata, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package mvdata
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/liquidata-inc/dolt/go/libraries/doltcore/schema/encoding"
"github.com/liquidata-inc/dolt/go/libraries/doltcore/table"
)
const (
schemaFile = "schema.json"
mappingFile = "mapping.json"
)
func TestDataMover(t *testing.T) {
tests := []struct {
schemaJSON string
mappingJSON string
mvOpts *MoveOptions
}{
{
"",
"",
&MoveOptions{
Operation: OverwriteOp,
ContOnErr: false,
SchFile: "",
MappingFile: "",
PrimaryKey: "",
Src: NewDataLocation("data.csv", ""),
Dest: NewDataLocation("data.psv", "psv")},
},
/*{
"",
"",
&MoveOptions{
Operation: OverwriteOp,
ContOnErr: false,
SchFile: "",
MappingFile: "",
PrimaryKey: "a",
Src: NewDataLocation("data.csv", ""),
Dest: NewDataLocation("data.nbf", "")},
},
{
"",
"",
&MoveOptions{
Operation: OverwriteOp,
ContOnErr: false,
SchFile: "",
MappingFile: "",
PrimaryKey: "",
Src: NewDataLocation("data.nbf", "nbf"),
Dest: NewDataLocation("table-name", "")},
},*/
{
"",
"",
&MoveOptions{
Operation: OverwriteOp,
ContOnErr: false,
SchFile: "",
MappingFile: "",
PrimaryKey: "a",
Src: NewDataLocation("data.csv", ""),
Dest: NewDataLocation("table-name", "")},
},
{
`{
"columns": [
{
"name": "key",
"kind": "string",
"tag": 0,
"is_part_of_pk": true,
"col_constraints":[
{
"constraint_type": "not_null"
}
]
},
{"name": "value", "kind": "int", "tag": 1}
]
}`,
`{"a":"key","b":"value"}`,
&MoveOptions{
Operation: OverwriteOp,
ContOnErr: false,
SchFile: "",
MappingFile: "",
PrimaryKey: "",
Src: NewDataLocation("data.csv", ""),
Dest: NewDataLocation("table-name", "")},
},
}
for _, test := range tests {
var err error
_, root, fs := createRootAndFS()
if test.schemaJSON != "" {
test.mvOpts.SchFile = schemaFile
err = fs.WriteFile(schemaFile, []byte(test.schemaJSON))
}
if test.mappingJSON != "" {
test.mvOpts.MappingFile = mappingFile
err = fs.WriteFile(mappingFile, []byte(test.mappingJSON))
}
src := test.mvOpts.Src
seedWr, err := src.NewCreatingWriter(context.Background(), test.mvOpts, root, fs, true, fakeSchema, nil)
if err != nil {
t.Fatal(err.Error())
}
imtRd := table.NewInMemTableReader(imt)
_, _, err = table.PipeRows(context.Background(), imtRd, seedWr, false)
seedWr.Close(context.Background())
imtRd.Close(context.Background())
if err != nil {
t.Fatal(err)
}
encoding.UnmarshalJson(test.schemaJSON)
dm, crDMErr := NewDataMover(context.Background(), root, fs, test.mvOpts, nil)
if crDMErr != nil {
t.Fatal(crDMErr.String())
}
var badCount int64
badCount, err = dm.Move(context.Background())
assert.Equal(t, int64(0), badCount)
if err != nil {
t.Fatal(err)
}
}
}
|
package oidcserver
import (
"context"
"net/http"
)
// Scopes represents additional data requested by the clients about the end user.
type Scopes struct {
// The client has requested a refresh token from the server.
OfflineAccess bool
// The client has requested group information about the end user.
Groups bool
}
// Identity represents the ID Token claims supported by the server.
type Identity struct {
UserID string
Username string
Email string
EmailVerified bool
Groups []string
// ACR should contain the value of the Authentication Context Class this
// requested was serviced with. OPTIONAL.
ACR *string
// AMR is the identifiers for authentication methods used in the
// authentication. OPTIONAL
AMR []string
// ConnectorData holds data used by the connector for subsequent requests after initial
// authentication, such as access tokens for upstream provides.
//
// This data is never shared with end users, OAuth clients, or through the API.
ConnectorData []byte
}
// LoginRequest encapsulates the information passed in for this SSO request.
type LoginRequest struct {
// AuthID is the unique identifier for this access request. It is assigned
// at login request, and is needed to finalize the flow.
AuthID string
// Scopes are the Oauth2 Scopes for OIDC requests.
Scopes Scopes
// ACRValues indicate the requested Authorization Context Classes. This is
// an _optional_ field, connectors can choose to ignore it. They are
// specified in preference order. If the connector can handle this, it
// should indicate the value used in the ACR field in the returned identity
ACRValues []string
}
// Connector is used to actually manage the end user authentication
type Connector interface {
// Initialize is called by Server before the connectors first authentication
// flow. This passes an Authenticator which the connector can use to assign
// an identity to the authorization flow, and determine the final URL to
// send the user to
Initialize(auth Authenticator)
// LoginPage is called at the start of an authentication flow. This method
// can render/return whatever it wants and run the user through any
// arbitrary intermediate pages. The only requirement is that it threads the
// AuthID through these, and at the end of the connector flow it needs to
// pass this to the Authenticator's Authenticate method, and redirect the
// user to the resulting URL.
LoginPage(w http.ResponseWriter, r *http.Request, lr LoginRequest)
}
// RefreshConnector is a connector that can update the client claims.
type RefreshConnector interface {
// Refresh is called when a client attempts to claim a refresh token. The
// connector should attempt to update the identity object to reflect any
// changes since the token was last refreshed.
Refresh(ctx context.Context, s Scopes, identity Identity) (Identity, error)
}
// An error that implements errRetryable can signal that an error is retryable.
// A retryable error might have different meaning depending on context: for
// instance, an HTTP error code that is retryable might be returned to the
// client.
type errRetryable interface {
Retryable() bool
}
func isRetryableErr(err error) bool {
er, ok := err.(errRetryable)
return ok && er.Retryable()
}
|
/*
Links
* http://yjyruwufuhi.github.com/1.html
* http://yjyruwufuhi.github.com/2.html
* http://yjyruwufuhi.github.com/3.html
* http://yjyruwufuhi.github.com/4.html
* http://yjyruwufuhi.github.com/5.html
* http://yjyruwufuhi.github.com/6.html
* http://yjyruwufuhi.github.com/7.html
* http://yjyruwufuhi.github.com/8.html
* http://yjyruwufuhi.github.com/9.html
* http://yjyruwufuhi.github.com/10.html
*/
package abc
|
package models
type Vehicle struct{
Model string `json:"model"`
Plate string `json:"plate"`
Capacity float32 `json:"capacity"`
Vin string `json:"vin"`
}
func (v *Vehicle) SetAttributes(model string, plate string, capacity float32, vin string){
v.Model = model
v.Plate = plate
v.Capacity = capacity
v.Vin = vin
} |
/*
* REST API
*
* Rockset's REST API allows for creating and managing all resources in Rockset. Each supported endpoint is documented below. All requests must be authorized with a Rockset API key, which can be created in the [Rockset console](https://console.rockset.com). The API key must be provided as `ApiKey <api_key>` in the `Authorization` request header. For example: ``` Authorization: ApiKey aB35kDjg93J5nsf4GjwMeErAVd832F7ad4vhsW1S02kfZiab42sTsfW5Sxt25asT ``` All endpoints are only accessible via https. Build something awesome!
*
* API version: v1
* Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)
*/
package rockset
import (
"bufio"
"bytes"
"encoding/json"
"io/ioutil"
"log"
"net/http"
"net/url"
"strings"
"fmt"
)
type UsersApiService Service
/*
UsersApiService Create User
Create a new user for an organization.
* @param body JSON object
@return CreateUserResponse
*/
func (a *UsersApiService) Create(body CreateUserRequest) (CreateUserResponse, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Post")
localVarPostBody interface{}
localVarFileName string
localVarFileBytes []byte
localVarReturnValue CreateUserResponse
)
// create path and map variables
localVarPath := a.Client.cfg.BasePath + "/v1/orgs/self/users"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHttpContentTypes := []string{"application/json"}
// set Content-Type header
localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
if localVarHttpContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHttpContentType
}
// to determine the Api Key header
localVarHttpHeaderAuthorization := ""
localVarHttpHeaderApiKey := a.Client.selectHeaderAuthorization(localVarHttpHeaderAuthorization)
if localVarHttpHeaderApiKey == "" {
log.Fatal("missing required argument ApiKey")
}
localVarHeaderParams["authorization"] = "ApiKey " + localVarHttpHeaderApiKey
// body params
localVarPostBody = &body
r, err := a.Client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHttpResponse, err := a.Client.callAPI(r)
if err != nil || localVarHttpResponse == nil {
return localVarReturnValue, localVarHttpResponse, err
}
localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
localVarHttpResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHttpResponse, err
}
if localVarHttpResponse.StatusCode < 300 {
// If we succeed, return the data, otherwise pass on to decode error.
err = a.Client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
if err == nil {
return localVarReturnValue, localVarHttpResponse, err
}
}
if localVarHttpResponse.StatusCode >= 300 {
newErr := GenericSwaggerError{
body: localVarBody,
error: localVarHttpResponse.Status,
}
if localVarHttpResponse.StatusCode == 200 {
var v CreateUserResponse
err = a.Client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHttpResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHttpResponse, newErr
}
return localVarReturnValue, localVarHttpResponse, newErr
}
return localVarReturnValue, localVarHttpResponse, nil
}
func (a *UsersApiService) CreateStream(body CreateUserRequest) (string, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Post")
localVarPostBody interface{}
localVarFileName string
localVarFileBytes []byte
localVarBody []byte
)
// create path and map variables
localVarPath := a.Client.cfg.BasePath + "/v1/orgs/self/users"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHttpContentTypes := []string{"application/json"}
// set Content-Type header
localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
if localVarHttpContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHttpContentType
}
// to determine the Api Key header
localVarHttpHeaderAuthorization := ""
localVarHttpHeaderApiKey := a.Client.selectHeaderAuthorization(localVarHttpHeaderAuthorization)
if localVarHttpHeaderApiKey == "" {
log.Fatal("missing required argument ApiKey")
}
localVarHeaderParams["authorization"] = "ApiKey " + localVarHttpHeaderApiKey
// body params
localVarPostBody = &body
r, err := a.Client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
if err != nil {
return "", nil, err
}
localVarHttpResponse, err := a.Client.callAPI(r)
if err != nil || localVarHttpResponse == nil {
return "", localVarHttpResponse, err
}
reader := bufio.NewReader(localVarHttpResponse.Body)
localVarBody, err= reader.ReadBytes('\n')
var out bytes.Buffer
err = json.Indent(&out, []byte(string(localVarBody)), "", " ")
if err != nil {
return "", localVarHttpResponse, err
}
if localVarHttpResponse.StatusCode >= 300 {
return out.String(), localVarHttpResponse, nil
}
return out.String(), localVarHttpResponse, nil
}
/*
UsersApiService Delete User
Delete a user from an organization.
* @param user user email
@return DeleteUserResponse
*/
func (a *UsersApiService) Delete(user string) (DeleteUserResponse, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Delete")
localVarPostBody interface{}
localVarFileName string
localVarFileBytes []byte
localVarReturnValue DeleteUserResponse
)
// create path and map variables
localVarPath := a.Client.cfg.BasePath + "/v1/orgs/self/users/{user}"
localVarPath = strings.Replace(localVarPath, "{"+"user"+"}", fmt.Sprintf("%v", user), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHttpContentTypes := []string{"application/json"}
// set Content-Type header
localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
if localVarHttpContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHttpContentType
}
// to determine the Api Key header
localVarHttpHeaderAuthorization := ""
localVarHttpHeaderApiKey := a.Client.selectHeaderAuthorization(localVarHttpHeaderAuthorization)
if localVarHttpHeaderApiKey == "" {
log.Fatal("missing required argument ApiKey")
}
localVarHeaderParams["authorization"] = "ApiKey " + localVarHttpHeaderApiKey
r, err := a.Client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHttpResponse, err := a.Client.callAPI(r)
if err != nil || localVarHttpResponse == nil {
return localVarReturnValue, localVarHttpResponse, err
}
localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
localVarHttpResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHttpResponse, err
}
if localVarHttpResponse.StatusCode < 300 {
// If we succeed, return the data, otherwise pass on to decode error.
err = a.Client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
if err == nil {
return localVarReturnValue, localVarHttpResponse, err
}
}
if localVarHttpResponse.StatusCode >= 300 {
newErr := GenericSwaggerError{
body: localVarBody,
error: localVarHttpResponse.Status,
}
if localVarHttpResponse.StatusCode == 200 {
var v DeleteUserResponse
err = a.Client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHttpResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHttpResponse, newErr
}
return localVarReturnValue, localVarHttpResponse, newErr
}
return localVarReturnValue, localVarHttpResponse, nil
}
func (a *UsersApiService) DeleteStream(user string) (string, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Delete")
localVarPostBody interface{}
localVarFileName string
localVarFileBytes []byte
localVarBody []byte
)
// create path and map variables
localVarPath := a.Client.cfg.BasePath + "/v1/orgs/self/users/{user}"
localVarPath = strings.Replace(localVarPath, "{"+"user"+"}", fmt.Sprintf("%v", user), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHttpContentTypes := []string{"application/json"}
// set Content-Type header
localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
if localVarHttpContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHttpContentType
}
// to determine the Api Key header
localVarHttpHeaderAuthorization := ""
localVarHttpHeaderApiKey := a.Client.selectHeaderAuthorization(localVarHttpHeaderAuthorization)
if localVarHttpHeaderApiKey == "" {
log.Fatal("missing required argument ApiKey")
}
localVarHeaderParams["authorization"] = "ApiKey " + localVarHttpHeaderApiKey
r, err := a.Client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
if err != nil {
return "", nil, err
}
localVarHttpResponse, err := a.Client.callAPI(r)
if err != nil || localVarHttpResponse == nil {
return "", localVarHttpResponse, err
}
reader := bufio.NewReader(localVarHttpResponse.Body)
localVarBody, err= reader.ReadBytes('\n')
var out bytes.Buffer
err = json.Indent(&out, []byte(string(localVarBody)), "", " ")
if err != nil {
return "", localVarHttpResponse, err
}
if localVarHttpResponse.StatusCode >= 300 {
return out.String(), localVarHttpResponse, nil
}
return out.String(), localVarHttpResponse, nil
}
/*
UsersApiService Get Current User
Retrieve currently active user.
@return User
*/
func (a *UsersApiService) Get() (User, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Get")
localVarPostBody interface{}
localVarFileName string
localVarFileBytes []byte
localVarReturnValue User
)
// create path and map variables
localVarPath := a.Client.cfg.BasePath + "/v1/orgs/self/users/self"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHttpContentTypes := []string{"application/json"}
// set Content-Type header
localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
if localVarHttpContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHttpContentType
}
// to determine the Api Key header
localVarHttpHeaderAuthorization := ""
localVarHttpHeaderApiKey := a.Client.selectHeaderAuthorization(localVarHttpHeaderAuthorization)
if localVarHttpHeaderApiKey == "" {
log.Fatal("missing required argument ApiKey")
}
localVarHeaderParams["authorization"] = "ApiKey " + localVarHttpHeaderApiKey
r, err := a.Client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHttpResponse, err := a.Client.callAPI(r)
if err != nil || localVarHttpResponse == nil {
return localVarReturnValue, localVarHttpResponse, err
}
localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
localVarHttpResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHttpResponse, err
}
if localVarHttpResponse.StatusCode < 300 {
// If we succeed, return the data, otherwise pass on to decode error.
err = a.Client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
if err == nil {
return localVarReturnValue, localVarHttpResponse, err
}
}
if localVarHttpResponse.StatusCode >= 300 {
newErr := GenericSwaggerError{
body: localVarBody,
error: localVarHttpResponse.Status,
}
if localVarHttpResponse.StatusCode == 200 {
var v User
err = a.Client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHttpResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHttpResponse, newErr
}
return localVarReturnValue, localVarHttpResponse, newErr
}
return localVarReturnValue, localVarHttpResponse, nil
}
func (a *UsersApiService) GetStream() (string, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Get")
localVarPostBody interface{}
localVarFileName string
localVarFileBytes []byte
localVarBody []byte
)
// create path and map variables
localVarPath := a.Client.cfg.BasePath + "/v1/orgs/self/users/self"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHttpContentTypes := []string{"application/json"}
// set Content-Type header
localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
if localVarHttpContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHttpContentType
}
// to determine the Api Key header
localVarHttpHeaderAuthorization := ""
localVarHttpHeaderApiKey := a.Client.selectHeaderAuthorization(localVarHttpHeaderAuthorization)
if localVarHttpHeaderApiKey == "" {
log.Fatal("missing required argument ApiKey")
}
localVarHeaderParams["authorization"] = "ApiKey " + localVarHttpHeaderApiKey
r, err := a.Client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
if err != nil {
return "", nil, err
}
localVarHttpResponse, err := a.Client.callAPI(r)
if err != nil || localVarHttpResponse == nil {
return "", localVarHttpResponse, err
}
reader := bufio.NewReader(localVarHttpResponse.Body)
localVarBody, err= reader.ReadBytes('\n')
var out bytes.Buffer
err = json.Indent(&out, []byte(string(localVarBody)), "", " ")
if err != nil {
return "", localVarHttpResponse, err
}
if localVarHttpResponse.StatusCode >= 300 {
return out.String(), localVarHttpResponse, nil
}
return out.String(), localVarHttpResponse, nil
}
/*
UsersApiService List Users
Retrieve all users for an organization.
@return ListUsersResponse
*/
func (a *UsersApiService) List() (ListUsersResponse, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Get")
localVarPostBody interface{}
localVarFileName string
localVarFileBytes []byte
localVarReturnValue ListUsersResponse
)
// create path and map variables
localVarPath := a.Client.cfg.BasePath + "/v1/orgs/self/users"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHttpContentTypes := []string{"application/json"}
// set Content-Type header
localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
if localVarHttpContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHttpContentType
}
// to determine the Api Key header
localVarHttpHeaderAuthorization := ""
localVarHttpHeaderApiKey := a.Client.selectHeaderAuthorization(localVarHttpHeaderAuthorization)
if localVarHttpHeaderApiKey == "" {
log.Fatal("missing required argument ApiKey")
}
localVarHeaderParams["authorization"] = "ApiKey " + localVarHttpHeaderApiKey
r, err := a.Client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHttpResponse, err := a.Client.callAPI(r)
if err != nil || localVarHttpResponse == nil {
return localVarReturnValue, localVarHttpResponse, err
}
localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
localVarHttpResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHttpResponse, err
}
if localVarHttpResponse.StatusCode < 300 {
// If we succeed, return the data, otherwise pass on to decode error.
err = a.Client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
if err == nil {
return localVarReturnValue, localVarHttpResponse, err
}
}
if localVarHttpResponse.StatusCode >= 300 {
newErr := GenericSwaggerError{
body: localVarBody,
error: localVarHttpResponse.Status,
}
if localVarHttpResponse.StatusCode == 200 {
var v ListUsersResponse
err = a.Client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"));
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHttpResponse, newErr
}
newErr.model = v
return localVarReturnValue, localVarHttpResponse, newErr
}
return localVarReturnValue, localVarHttpResponse, newErr
}
return localVarReturnValue, localVarHttpResponse, nil
}
func (a *UsersApiService) ListStream() (string, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Get")
localVarPostBody interface{}
localVarFileName string
localVarFileBytes []byte
localVarBody []byte
)
// create path and map variables
localVarPath := a.Client.cfg.BasePath + "/v1/orgs/self/users"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHttpContentTypes := []string{"application/json"}
// set Content-Type header
localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
if localVarHttpContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHttpContentType
}
// to determine the Api Key header
localVarHttpHeaderAuthorization := ""
localVarHttpHeaderApiKey := a.Client.selectHeaderAuthorization(localVarHttpHeaderAuthorization)
if localVarHttpHeaderApiKey == "" {
log.Fatal("missing required argument ApiKey")
}
localVarHeaderParams["authorization"] = "ApiKey " + localVarHttpHeaderApiKey
r, err := a.Client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
if err != nil {
return "", nil, err
}
localVarHttpResponse, err := a.Client.callAPI(r)
if err != nil || localVarHttpResponse == nil {
return "", localVarHttpResponse, err
}
reader := bufio.NewReader(localVarHttpResponse.Body)
localVarBody, err= reader.ReadBytes('\n')
var out bytes.Buffer
err = json.Indent(&out, []byte(string(localVarBody)), "", " ")
if err != nil {
return "", localVarHttpResponse, err
}
if localVarHttpResponse.StatusCode >= 300 {
return out.String(), localVarHttpResponse, nil
}
return out.String(), localVarHttpResponse, nil
}
|
package main
// WARNING: API of Kubeconform is still under development and not yet
// considered stable
import (
"github.com/yannh/kubeconform/pkg/validator"
"log"
"os"
)
func main() {
filepath := "../fixtures/valid.yaml"
f, err := os.Open(filepath)
if err != nil {
log.Fatalf("failed opening %s: %s", filepath, err)
}
v, err := validator.New(nil, validator.Opts{Strict: true})
if err != nil {
log.Fatalf("failed initializing validator: %s", err)
}
for i, res := range v.Validate(filepath, f) { // A file might contain multiple resources
// File starts with ---, the parser assumes a first empty resource
if res.Status == validator.Invalid {
log.Fatalf("resource %d in file %s is not valid: %s", i, filepath, res.Err)
}
if res.Status == validator.Error {
log.Fatalf("error while processing resource %d in file %s: %s", i, filepath, res.Err)
}
}
}
|
/*
Copyright 2020 Docker Compose CLI 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 compose
import (
"context"
"fmt"
"io"
"strings"
"github.com/docker/compose/v2/cmd/formatter"
"github.com/docker/cli/opts"
"github.com/spf13/cobra"
"github.com/docker/compose/v2/pkg/api"
)
type lsOptions struct {
Format string
Quiet bool
All bool
Filter opts.FilterOpt
}
func listCommand(streams api.Streams, backend api.Service) *cobra.Command {
lsOpts := lsOptions{Filter: opts.NewFilterOpt()}
lsCmd := &cobra.Command{
Use: "ls [OPTIONS]",
Short: "List running compose projects",
RunE: Adapt(func(ctx context.Context, args []string) error {
return runList(ctx, streams, backend, lsOpts)
}),
Args: cobra.NoArgs,
ValidArgsFunction: noCompletion(),
}
lsCmd.Flags().StringVar(&lsOpts.Format, "format", "table", "Format the output. Values: [table | json].")
lsCmd.Flags().BoolVarP(&lsOpts.Quiet, "quiet", "q", false, "Only display IDs.")
lsCmd.Flags().Var(&lsOpts.Filter, "filter", "Filter output based on conditions provided.")
lsCmd.Flags().BoolVarP(&lsOpts.All, "all", "a", false, "Show all stopped Compose projects")
return lsCmd
}
var acceptedListFilters = map[string]bool{
"name": true,
}
func runList(ctx context.Context, streams api.Streams, backend api.Service, lsOpts lsOptions) error {
filters := lsOpts.Filter.Value()
err := filters.Validate(acceptedListFilters)
if err != nil {
return err
}
stackList, err := backend.List(ctx, api.ListOptions{All: lsOpts.All})
if err != nil {
return err
}
if lsOpts.Quiet {
for _, s := range stackList {
fmt.Fprintln(streams.Out(), s.Name)
}
return nil
}
if filters.Len() > 0 {
var filtered []api.Stack
for _, s := range stackList {
if filters.Contains("name") && !filters.Match("name", s.Name) {
continue
}
filtered = append(filtered, s)
}
stackList = filtered
}
view := viewFromStackList(stackList)
return formatter.Print(view, lsOpts.Format, streams.Out(), func(w io.Writer) {
for _, stack := range view {
_, _ = fmt.Fprintf(w, "%s\t%s\t%s\n", stack.Name, stack.Status, stack.ConfigFiles)
}
}, "NAME", "STATUS", "CONFIG FILES")
}
type stackView struct {
Name string
Status string
ConfigFiles string
}
func viewFromStackList(stackList []api.Stack) []stackView {
retList := make([]stackView, len(stackList))
for i, s := range stackList {
retList[i] = stackView{
Name: s.Name,
Status: strings.TrimSpace(fmt.Sprintf("%s %s", s.Status, s.Reason)),
ConfigFiles: s.ConfigFiles,
}
}
return retList
}
|
package todotxt
import (
"errors"
"sort"
"time"
)
// TaskSortByType represents type of sorting element and order.
//go:generate stringer -type TaskSortByType -trimprefix Sort -output sort_type.go
type TaskSortByType uint8
// Flags for defining sorting element and order.
const (
SortTaskIDAsc TaskSortByType = iota + 1
SortTaskIDDesc
SortTodoTextAsc
SortTodoTextDesc
SortPriorityAsc
SortPriorityDesc
SortCreatedDateAsc
SortCreatedDateDesc
SortCompletedDateAsc
SortCompletedDateDesc
SortDueDateAsc
SortDueDateDesc
SortContextAsc
SortContextDesc
SortProjectAsc
SortProjectDesc
)
// Sort allows a TaskList to be sorted by certain predefined fields. Multiple-key sorting is supported.
// See constants Sort* for fields and sort order.
func (tasklist *TaskList) Sort(flag TaskSortByType, flags ...TaskSortByType) error {
combined := make([]TaskSortByType, len(flags)+1)
j := 0
for i := len(flags) - 1; i >= 0; i-- {
combined[j] = flags[i]
j++
}
combined[j] = flag
for _, flag := range combined {
switch flag {
case SortTaskIDAsc, SortTaskIDDesc:
tasklist.sortByTaskID(flag)
case SortTodoTextAsc, SortTodoTextDesc:
tasklist.sortByTodoText(flag)
case SortPriorityAsc, SortPriorityDesc:
tasklist.sortByPriority(flag)
case SortCreatedDateAsc, SortCreatedDateDesc:
tasklist.sortByCreatedDate(flag)
case SortCompletedDateAsc, SortCompletedDateDesc:
tasklist.sortByCompletedDate(flag)
case SortDueDateAsc, SortDueDateDesc:
tasklist.sortByDueDate(flag)
case SortContextAsc, SortContextDesc:
tasklist.sortByContext(flag)
case SortProjectAsc, SortProjectDesc:
tasklist.sortByProject(flag)
default:
return errors.New("unrecognized sort option")
}
}
return nil
}
type tasklistSort struct {
tasklists TaskList
by func(t1, t2 *Task) bool
}
func (ts *tasklistSort) Len() int {
return len(ts.tasklists)
}
func (ts *tasklistSort) Swap(l, r int) {
ts.tasklists[l], ts.tasklists[r] = ts.tasklists[r], ts.tasklists[l]
}
func (ts *tasklistSort) Less(l, r int) bool {
return ts.by(&ts.tasklists[l], &ts.tasklists[r])
}
func (tasklist *TaskList) sortBy(by func(t1, t2 *Task) bool) *TaskList {
ts := &tasklistSort{
tasklists: *tasklist,
by: by,
}
sort.Stable(ts)
return tasklist
}
func (tasklist *TaskList) sortByTaskID(order TaskSortByType) *TaskList {
tasklist.sortBy(func(t1, t2 *Task) bool {
if t1.ID < t2.ID {
return order == SortTaskIDAsc
}
return order == SortTaskIDDesc
})
return tasklist
}
func (tasklist *TaskList) sortByTodoText(order TaskSortByType) *TaskList {
tasklist.sortBy(func(t1, t2 *Task) bool {
if t1.Todo < t2.Todo {
return order == SortTodoTextAsc
}
return order == SortTodoTextDesc
})
return tasklist
}
func (tasklist *TaskList) sortByPriority(order TaskSortByType) *TaskList {
tasklist.sortBy(func(t1, t2 *Task) bool {
if order == SortPriorityAsc { // ASC
if t1.HasPriority() && t2.HasPriority() {
return t1.Priority < t2.Priority
}
return t1.HasPriority()
}
// DESC
if t1.HasPriority() && t2.HasPriority() {
return t1.Priority > t2.Priority
}
return !t1.HasPriority()
})
return tasklist
}
func sortByDate(asc bool, hasDate1, hasDate2 bool, date1, date2 time.Time) bool {
if asc { // ASC
if hasDate1 && hasDate2 {
return date1.Before(date2)
}
return hasDate2
}
// DESC
if hasDate1 && hasDate2 {
return date1.After(date2)
}
return !hasDate2
}
func (tasklist *TaskList) sortByCreatedDate(order TaskSortByType) *TaskList {
tasklist.sortBy(func(t1, t2 *Task) bool {
return sortByDate(order == SortCreatedDateAsc, t1.HasCreatedDate(), t2.HasCreatedDate(), t1.CreatedDate, t2.CreatedDate)
})
return tasklist
}
func (tasklist *TaskList) sortByCompletedDate(order TaskSortByType) *TaskList {
tasklist.sortBy(func(t1, t2 *Task) bool {
return sortByDate(order == SortCompletedDateAsc, t1.HasCompletedDate(), t2.HasCompletedDate(), t1.CompletedDate, t2.CompletedDate)
})
return tasklist
}
func (tasklist *TaskList) sortByDueDate(order TaskSortByType) *TaskList {
tasklist.sortBy(func(t1, t2 *Task) bool {
return sortByDate(order == SortDueDateAsc, t1.HasDueDate(), t2.HasDueDate(), t1.DueDate, t2.DueDate)
})
return tasklist
}
// lessStrings checks if the string slices a is exactly less than b in lexicographical order.
func lessStrings(a, b []string) bool {
la, lb, min := len(a), len(b), 0
if la == 0 && lb == 0 {
return false
} else if la == 0 && lb > 0 {
return false
} else if la > 0 && lb == 0 {
return true
}
if min = la; la > lb {
min = lb
}
for i := 0; i < min; i++ {
if a[i] < b[i] {
return true
} else if a[i] > b[i] {
return false
}
}
if la == lb {
return false
}
return la < lb
}
func (tasklist *TaskList) sortByContext(order TaskSortByType) *TaskList {
tasklist.sortBy(func(t1, t2 *Task) bool {
if order == SortContextAsc {
return lessStrings(t1.Contexts, t2.Contexts)
}
return lessStrings(t2.Contexts, t1.Contexts)
})
return tasklist
}
func (tasklist *TaskList) sortByProject(order TaskSortByType) *TaskList {
tasklist.sortBy(func(t1, t2 *Task) bool {
if order == SortProjectAsc {
return lessStrings(t1.Projects, t2.Projects)
}
return lessStrings(t2.Projects, t1.Projects)
})
return tasklist
}
|
// Copyright 2020 The gVisor 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 injector handles mutating webhook operations.
package injector
import (
"context"
"crypto/tls"
"encoding/json"
"fmt"
"net/http"
"os"
"github.com/mattbaird/jsonpatch"
"gvisor.dev/gvisor/pkg/log"
admv1beta1 "k8s.io/api/admission/v1beta1"
admregv1beta1 "k8s.io/api/admissionregistration/v1beta1"
v1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
kubeclientset "k8s.io/client-go/kubernetes"
)
const (
// Name is the name of the admission webhook service. The admission
// webhook must be exposed in the following service; this is mainly for
// the server certificate.
Name = "gvisor-injection-admission-webhook"
// serviceNamespace is the namespace of the admission webhook service.
serviceNamespace = "e2e"
fullName = Name + "." + serviceNamespace + ".svc"
)
// CreateConfiguration creates MutatingWebhookConfiguration and registers the
// webhook admission controller with the kube-apiserver. The webhook will only
// take effect on pods in the namespaces selected by `podNsSelector`. If `podNsSelector`
// is empty, the webhook will take effect on all pods.
func CreateConfiguration(clientset kubeclientset.Interface, selector *metav1.LabelSelector) error {
fail := admregv1beta1.Fail
config := &admregv1beta1.MutatingWebhookConfiguration{
ObjectMeta: metav1.ObjectMeta{
Name: Name,
},
Webhooks: []admregv1beta1.MutatingWebhook{
{
Name: fullName,
ClientConfig: admregv1beta1.WebhookClientConfig{
Service: &admregv1beta1.ServiceReference{
Name: Name,
Namespace: serviceNamespace,
},
CABundle: caCert,
},
Rules: []admregv1beta1.RuleWithOperations{
{
Operations: []admregv1beta1.OperationType{
admregv1beta1.Create,
},
Rule: admregv1beta1.Rule{
APIGroups: []string{"*"},
APIVersions: []string{"*"},
Resources: []string{"pods"},
},
},
},
FailurePolicy: &fail,
NamespaceSelector: selector,
},
},
}
log.Infof("Creating MutatingWebhookConfiguration %q", config.Name)
if _, err := clientset.AdmissionregistrationV1beta1().MutatingWebhookConfigurations().Create(context.TODO(), config, metav1.CreateOptions{}); err != nil {
if !apierrors.IsAlreadyExists(err) {
return fmt.Errorf("failed to create MutatingWebhookConfiguration %q: %s", config.Name, err)
}
log.Infof("MutatingWebhookConfiguration %q already exists; use the existing one", config.Name)
}
return nil
}
// GetTLSConfig retrieves the CA cert that signed the cert used by the webhook.
func GetTLSConfig() *tls.Config {
sc, err := tls.X509KeyPair(serverCert, serverKey)
if err != nil {
log.Warningf("Failed to generate X509 key pair: %v", err)
os.Exit(1)
}
return &tls.Config{
Certificates: []tls.Certificate{sc},
}
}
// Admit performs admission checks and mutations on Pods.
func Admit(writer http.ResponseWriter, req *http.Request) {
review := &admv1beta1.AdmissionReview{}
if err := json.NewDecoder(req.Body).Decode(review); err != nil {
log.Infof("Failed with error (%v) to decode Admit request: %+v", err, *req)
writer.WriteHeader(http.StatusBadRequest)
return
}
log.Debugf("admitPod: %+v", review)
var err error
review.Response, err = admitPod(review.Request)
if err != nil {
log.Warningf("admitPod failed: %v", err)
review.Response = &admv1beta1.AdmissionResponse{
Result: &metav1.Status{
Reason: metav1.StatusReasonInvalid,
Message: err.Error(),
},
}
sendResponse(writer, review)
return
}
log.Debugf("Processed admission review: %+v", review)
sendResponse(writer, review)
}
func sendResponse(writer http.ResponseWriter, response any) {
b, err := json.Marshal(response)
if err != nil {
log.Warningf("Failed with error (%v) to marshal response: %+v", err, response)
writer.WriteHeader(http.StatusInternalServerError)
return
}
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
func admitPod(req *admv1beta1.AdmissionRequest) (*admv1beta1.AdmissionResponse, error) {
// Verify that the request is indeed a Pod.
resource := metav1.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
if req.Resource != resource {
return nil, fmt.Errorf("unexpected resource %+v in pod admission", req.Resource)
}
// Decode the request into a Pod.
pod := &v1.Pod{}
if err := json.Unmarshal(req.Object.Raw, pod); err != nil {
return nil, fmt.Errorf("failed to decode pod object %s/%s", req.Namespace, req.Name)
}
// Copy first to change it.
podCopy := pod.DeepCopy()
updatePod(podCopy)
patch, err := createPatch(req.Object.Raw, podCopy)
if err != nil {
return nil, fmt.Errorf("failed to create patch for pod %s/%s (generatedName: %s)", pod.Namespace, pod.Name, pod.GenerateName)
}
log.Debugf("Patched pod %s/%s (generateName: %s): %+v", pod.Namespace, pod.Name, pod.GenerateName, podCopy)
patchType := admv1beta1.PatchTypeJSONPatch
return &admv1beta1.AdmissionResponse{
Allowed: true,
Patch: patch,
PatchType: &patchType,
}, nil
}
func updatePod(pod *v1.Pod) {
gvisor := "gvisor"
pod.Spec.RuntimeClassName = &gvisor
// We don't run SELinux test for gvisor.
// If SELinuxOptions are specified, this is usually for volume test to pass
// on SELinux. This can be safely ignored.
if pod.Spec.SecurityContext != nil && pod.Spec.SecurityContext.SELinuxOptions != nil {
pod.Spec.SecurityContext.SELinuxOptions = nil
}
for i := range pod.Spec.Containers {
c := &pod.Spec.Containers[i]
if c.SecurityContext != nil && c.SecurityContext.SELinuxOptions != nil {
c.SecurityContext.SELinuxOptions = nil
}
}
for i := range pod.Spec.InitContainers {
c := &pod.Spec.InitContainers[i]
if c.SecurityContext != nil && c.SecurityContext.SELinuxOptions != nil {
c.SecurityContext.SELinuxOptions = nil
}
}
}
func createPatch(old []byte, newObj any) ([]byte, error) {
new, err := json.Marshal(newObj)
if err != nil {
return nil, err
}
patch, err := jsonpatch.CreatePatch(old, new)
if err != nil {
return nil, err
}
return json.Marshal(patch)
}
|
// Copyright (c) 2018-present, MultiVAC Foundation
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
package imvvm
import (
"github.com/multivactech/MultiVAC/model/shard"
"github.com/multivactech/MultiVAC/model/wire"
)
// DeployInitializer will initialize the initial data of each shard when a smart contract is deployed.
type DeployInitializer interface {
// Initialize is called when a smart contract is deployed and initialized.
Initialize(shard shard.Index) []byte
}
// SmartContractMvvmExecutor will execute the given code when the smart contract is applied, and return a bunch of
// OutState and Action to change the status of each shard.
type SmartContractMvvmExecutor interface {
// Execute is called when a smart contract is applied and executed.
Execute(tx *wire.MsgTx, shardState *wire.OutState) (*wire.OutState, []*wire.OutState, []*wire.ReduceAction, error)
}
|
package main
import "strconv"
//面试题46. 把数字翻译成字符串
//给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。
//
//
//
//示例 1:
//
//输入: 12258
//输出: 5
//解释: 12258有5种不同的翻译，分别是"bccfi", "bwfi", "bczi", "mcfi"和"mzi"
//思路： 动态规划
// dp[s] = dp[s-1] + dp[s-2]
func translateNum(num int) int {
str := strconv.Itoa(num)
var dp func(s string) int
dp = func(s string) int {
n := len(s)
if n < 2 {
return 1
}
if s[0] == '1' || (s[0] == '2' && s[1] < '6') {
return dp(s[1:]) + dp(s[2:])
}
return dp(s[1:])
}
return dp(str)
}
func main() {
println(translateNum(18822))
println(translateNum(220))
println(translateNum(22220))
}
|
package module
import (
"github.com/l-dandelion/cwgo/data"
)
type Counts struct {
CalledCount int64
AcceptedCount int64
CompletedCount int64
HandlingNumber int64
}
type SummaryStruct struct {
Called int64 `json:"called"`
Accepted int64 `json:"accepted"`
Completed int64 `json:"completed"`
Handling int64 `json:"handling"`
Extra interface{} `json:"extra,omitempty"` // 额外信息
}
type Module interface {
Counts() Counts
Summary() SummaryStruct
CalledCount() int64
AcceptedCount() int64
CompletedCount() int64
HandlingNumber() int64
}
//下载器
type Downloader interface {
Module
Download(*data.Request) (*data.Response, error)
}
//分析器
type Analyzer interface {
Module
RespParsers() []ParseResponse
Analyze(*data.Response) ([]data.Data, []error)
}
//响应解析器
type ParseResponse func(*data.Response) ([]data.Data, []error)
//条目处理管道
type Pipeline interface {
Module
ItemProcessors() []ProcessItem
Send(item data.Item) []error
FailFast() bool
SetFailFast(failFast bool)
}
//条目处理器
type ProcessItem func(data.Item) (data.Item, error)
|
package adapter
import (
"fmt"
"github.com/dustin/go-humanize"
"github.com/rhymond/go-money"
"github.com/tidwall/gjson"
"github.com/zcong1993/badge-service/utils"
)
var (
opencUnknownInput = makeUnknownTopicInput("opencollective")
opencTopics = []string{"backers", "contributors", "balance", "yearly"}
)
// OpencollectiveApi is opencollective api provider
func OpencollectiveApi(args ...string) BadgeInput {
if len(args) != 2 {
return ErrorInput
}
topic := args[0]
name := args[1]
if !utils.IsOneOf(opencTopics, topic) {
return opencUnknownInput
}
endpoint := fmt.Sprintf("https://opencollective.com/%s.json", name)
resp, err := utils.Get(endpoint)
if err != nil {
return ErrorInput
}
if string(resp) == "Not found" {
r := opencUnknownInput
r.Status = "Not Found"
return r
}
input := opencUnknownInput
input.Subject = topic
switch topic {
case "backers", "contributors":
count := gjson.Get(string(resp), topic+"Count").Int()
input.Status = utils.StringOrDefault(humanize.Comma(count), "0")
input.Color = "green"
break
case "balance", "yearly":
currency := utils.StringOrDefault(gjson.Get(string(resp), "currency").String(), "USD")
t := topic
if topic == "yearly" {
t = "yearlyIncome"
input.Subject = "yearly income"
}
c := gjson.Get(string(resp), t).Int()
input.Status = money.New(c, currency).Display()
input.Color = "green"
break
}
return input
}
|
package main
import "fmt"
// the heap type
type heap []int
// insert adds element e to the heap
func (h *heap) insert(e int) {
l := len(*h)
*h = (*h)[0 : l+1]
s := *h
s[l] = e
for i := l; i > 0; i = parent(i) {
p := parent(i)
if s[p] <= s[i] {
break
}
s[i], s[p] = s[p], s[i]
}
}
// pop returns the top element from the heap
func (h *heap) pop() int {
s := *h
l := len(s)
r := s[0]
s[0] = s[l-1]
*h = (*h)[0 : l-1]
s.heapify(0)
return r
}
// create takes the given slice and creates a heap type that uses the slice for storage
func create(s []int) *heap {
res := heap(s[0:0])
return &res
}
func parent(x int) int { return (x - 1) / 2 }
func left(x int) int { return 2*x + 1 }
func right(x int) int { return 2*x + 2 }
func (h heap) heapify(i int) {
small := i
if left(i) < len(h) && h[left(i)] < h[i] {
small = left(i)
}
if right(i) < len(h) && h[right(i)] < h[small] {
small = right(i)
}
if small != i {
h[i], h[small] = h[small], h[i]
h.heapify(small)
}
}
// Test functions
func tpush(h *heap, x int) {
fmt.Println("Adding number", x)
h.insert(x)
fmt.Println(*h)
}
func tpop(h *heap) {
fmt.Println("Popping number", h.pop())
fmt.Println(*h)
}
func main() {
h := create(make([]int, 100))
tpush(h, 15)
tpush(h, 5)
tpush(h, 73)
tpush(h, 27)
tpush(h, 2)
tpush(h, 17)
tpop(h)
tpop(h)
tpush(h, 62)
for len(*h) > 0 {
tpop(h)
}
}
|
package core
import (
domain "github.com/I-Reven/Hexagonal/src/domain/grpc"
"github.com/I-Reven/Hexagonal/src/infrastructure/grpc/core/handler"
"google.golang.org/grpc"
)
type Grpc struct{}
func (Grpc) Route() *grpc.Server {
server := grpc.NewServer()
domain.RegisterPingServer(server, &handler.Ping{})
return server
}
|
package web
import (
"net/http"
"encoding/json"
"encoding/base64"
"io"
"io/ioutil"
"fa/s3util"
"fa/model"
"fa/openface"
"os"
"fmt"
)
type faceRecogInput struct {
Image string `json:"image"`
}
type celebOutput struct {
Name string `json:"name"`
Confidence string `json:"confidence"`
}
func FaceRecogHandler() http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if uid, ok := r.Context().Value("uid").(string); ok {
var i faceRecogInput
err := json.NewDecoder(r.Body).Decode(&i)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
classifier, err := ioutil.TempFile("/tmp/", "classifier")
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
defer classifier.Close()
defer os.Remove(classifier.Name())
err = s3util.GetClassifier(uid,classifier)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
data, err := base64.StdEncoding.DecodeString(i.Image)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
img, err := model.WriteBytesToFile(data, "/tmp/")
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer os.Remove(img)
result, err := openface.Infer(classifier.Name(), img)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
resp, err := model.GetLovedOneById(result[0], r.Header.Get("Authorization"))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if resp.StatusCode != http.StatusOK {
fmt.Println("get celeb")
o := &celebOutput{
Name: result[0],
Confidence: result[1],
}
w.Header().Add("Person-Type", "celeb")
w.Header().Set("Content-Type", "applicaton/json")
err = json.NewEncoder(w).Encode(&o)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
return
}
defer resp.Body.Close()
w.Header().Add("Person-Type", "loved-one")
_, err = io.Copy(w, resp.Body)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
fmt.Println("Copying")
} else {
http.Error(w, "Error getting user id", http.StatusInternalServerError)
return
}
}
}
|
package email
import (
"bytes"
"fmt"
"html/template"
"log"
"net/smtp"
)
const (
SMTP_USERNAME = "Eric.Irwin1124@gmail.com"
SMTP_PASSWORD = "UvHw2w6jhpJl"
SMTP_SERVER = "mail.smtp2go.com"
SMTP_PORT = 2525
)
//Request struct
type Request struct {
from string
to []string
subject string
body string
}
func NewRequest(to []string, from string, subject, body string) *Request {
return &Request{
to: to,
subject: subject,
body: body,
from: from,
}
}
func (r *Request) SendEmail() (bool, error) {
// Set up authentication information.
auth := smtp.PlainAuth(
"",
SMTP_USERNAME,
SMTP_PASSWORD,
SMTP_SERVER,
)
mime := "MIME-version: 1.0;\nContent-Type: text/html; charset=\"UTF-8\";\n\n"
subject := "Subject: " + r.subject + "!\n"
msg := []byte(subject + mime + "\n" + r.body)
addr := fmt.Sprintf("%v:%v", SMTP_SERVER, SMTP_PORT)
if err := smtp.SendMail(addr, auth, r.from, r.to, msg); err != nil {
return false, err
}
return true, nil
}
func (r *Request) ParseTemplate(templatePath string, data interface{}) error {
t, err := template.ParseFiles(templatePath)
if err != nil {
log.Println(err)
return err
}
buf := new(bytes.Buffer)
if err = t.Execute(buf, data); err != nil {
log.Println(err)
return err
}
r.body = buf.String()
return nil
}
|
package method
import (
"net/http"
"reflect"
"shared/utility/httputil"
)
type HttpPostHandler struct {
*httputil.HttpMethodAdapter
}
func NewHttpPostHandler() *HttpPostHandler {
return &HttpPostHandler{
HttpMethodAdapter: httputil.NewHttpMethodAdapter(http.MethodPost),
}
}
func (p *HttpPostHandler) FilterMethod(f interface{}) bool {
t := reflect.TypeOf(f)
// check kind
if t.Kind() != reflect.Func {
return false
}
// check in
numIn := t.NumIn()
if numIn != 3 && numIn != 2 {
return false
}
if t.In(1).String() != "context.Context" {
return false
}
numOut := t.NumOut()
// check out
if numOut != 2 && numOut != 1 {
return false
}
if numOut == 2 {
if t.Out(1).String() != "error" {
return false
}
} else {
if t.Out(0).String() != "error" {
return false
}
}
return true
}
|
package cli
import (
"bytes"
"fmt"
"io"
"net/http"
"os"
"strings"
)
func apiHost() string {
return fmt.Sprintf("%s:%d", provideWebHost(), provideWebPort())
}
func apiURL(path string) string {
path = strings.TrimLeft(path, "/")
return fmt.Sprintf("http://%s:%d/api/%s", provideWebHost(), provideWebPort(), path)
}
func apiGet(path string) (body io.ReadCloser) {
url := apiURL(path)
res, err := http.Get(url)
if err != nil {
cmdFail(fmt.Errorf("Could not connect to Tilt at %s: %v", url, err))
}
if res.StatusCode != http.StatusOK {
failWithNonOKResponse(url, res)
}
return res.Body
}
func apiPostJson(path string, payload []byte) (body io.ReadCloser, status int) {
url := apiURL(path)
res, err := http.Post(url, "application/json", bytes.NewBuffer(payload))
if err != nil {
cmdFail(fmt.Errorf("Could not connect to Tilt at %s: %v", url, err))
}
return res.Body, res.StatusCode
}
func cmdFail(err error) {
_, _ = fmt.Fprintf(os.Stderr, "%v\n", err)
os.Exit(1)
}
func failWithNonOKResponse(url string, res *http.Response) {
body := "<no response body>"
b, err := io.ReadAll(res.Body)
if err != nil {
cmdFail(fmt.Errorf("Error reading response body from %s: %v", url, err))
}
if string(b) != "" {
body = string(b)
}
_ = res.Body.Close()
cmdFail(fmt.Errorf("Request to %s failed with status %q: %s", url, res.Status, body))
}
|
package main
import "fmt"
var arr []string
func searchWords(str string, count int) {
if len(str) == 0 {
return
}
arr = append(arr, str)
searchWords(str[1:], count + 1)
fmt.Printf("arr: %v, count: %v \n", arr, count)
}
func main() {
arr = make([]string, 0)
searchWords("fine", 0)
}
|
// 178.Checking erros err sample || panic log 錯誤回報
// https://golang.org/pkg/builtin/#panic
// log.Println()
// log.Fatalln() // 印出錯誤後 結束 exit
// os.Exit()
// log.Panicln() // 可以回復
// deferred functions run
// can use “recover”
// panic() CMD 跑才 看的到錯誤訊息
// panic() // 在 "當前goroutine" 增加deferr 最後執行 nil 0 改成 1 程式繼續
// panic 中文解說 底部小節 https://draveness.me/golang/docs/part2-foundation/ch05-keyword/golang-panic-recover/
package main
import (
"os"
)
func main() {
// f, err := os.Create("log.txt")
// if err != nil {
// fmt.Println(err)
// }
// defer f.Close()
// log.SetOutput(f)
// f2, err := os.Open("no-file.txt")
// if err != nil {
// // log.Println("-錯誤 log.Println_nofile.txt-", err)
// panic(err)
// }
// defer f2.Close()
_, err := os.Open("no-file.txt")
if err != nil {
// 回報類型
// fmt.Println("-錯誤 fmt.Println-", err)
// log.Println("-錯誤 log.Println-", err)
// -----------------
// log.Fatalln("-錯誤 log.Fatalln-", err)
// Fatalln()
// Fatalln()這個function就是兩行code的組合，這個function是包在"log"中的。
// 其實就是執行這兩行，Print出錯誤內容後結束程式
// defer 不會跑
// fmt.Println(err)
// os.Exit(1)
// -----------------
panic(err)
}
}
|
package rigger
import (
"github.com/AsynkronIT/protoactor-go/actor"
"github.com/golang/protobuf/proto"
)
type riggerRestServer struct {
}
func (r *riggerRestServer) OnRestarting(ctx actor.Context) {
}
func (r *riggerRestServer) OnStarted(ctx actor.Context, args interface{}) error {
return nil
}
func (r *riggerRestServer) OnPostStarted(ctx actor.Context, args interface{}) {
}
func (r *riggerRestServer) OnStopping(ctx actor.Context) {
}
func (r *riggerRestServer) OnStopped(ctx actor.Context) {
}
func (r *riggerRestServer) OnMessage(ctx actor.Context, message interface{}) proto.Message {
return nil
}
func (r *riggerRestServer) startRestServer() {
}
|
package openrtb_ext
type ExtBematterfull struct {
Env string `json:"env"`
Pid string `json:"pid"`
}
|
// Package input ...
package input
import (
"github.com/go-rod/rod/lib/proto"
"github.com/ysmood/gson"
)
// Modifier values
const (
ModifierAlt = 1
ModifierControl = 2
ModifierMeta = 4
ModifierShift = 8
)
// Key symbol
type Key rune
// keyMap for key description
var keyMap = map[Key]KeyInfo{}
// keyMapShifted for shifted key description
var keyMapShifted = map[Key]KeyInfo{}
var keyShiftedMap = map[Key]Key{}
// AddKey to KeyMap
func AddKey(key string, shiftedKey string, code string, keyCode int, location int) Key {
if len(key) == 1 {
r := Key(key[0])
if _, has := keyMap[r]; !has {
keyMap[r] = KeyInfo{key, code, keyCode, location}
if len(shiftedKey) == 1 {
rs := Key(shiftedKey[0])
keyMapShifted[rs] = KeyInfo{shiftedKey, code, keyCode, location}
keyShiftedMap[r] = rs
}
return r
}
}
k := Key(keyCode + (location+1)*256)
keyMap[k] = KeyInfo{key, code, keyCode, location}
return k
}
// Info of the key
func (k Key) Info() KeyInfo {
if k, has := keyMap[k]; has {
return k
}
if k, has := keyMapShifted[k]; has {
return k
}
panic("key not defined")
}
// KeyInfo of a key
// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent
type KeyInfo struct {
// Here's the value for Shift key on the keyboard
Key string // Shift
Code string // ShiftLeft
KeyCode int // 16
Location int // 1
}
// Shift returns the shifted key, such as shifted "1" is "!".
func (k Key) Shift() (Key, bool) {
s, has := keyShiftedMap[k]
return s, has
}
// Printable returns true if the key is printable
func (k Key) Printable() bool {
return len(k.Info().Key) == 1
}
// Modifier returns the modifier value of the key
func (k Key) Modifier() int {
switch k.Info().KeyCode {
case 18:
return ModifierAlt
case 17:
return ModifierControl
case 91, 92:
return ModifierMeta
case 16:
return ModifierShift
}
return 0
}
// Encode general key event
func (k Key) Encode(t proto.InputDispatchKeyEventType, modifiers int) *proto.InputDispatchKeyEvent {
tp := t
if t == proto.InputDispatchKeyEventTypeKeyDown && !k.Printable() {
tp = proto.InputDispatchKeyEventTypeRawKeyDown
}
info := k.Info()
l := gson.Int(info.Location)
keypad := false
if info.Location == 3 {
l = nil
keypad = true
}
txt := ""
if k.Printable() {
txt = info.Key
}
var cmd []string
if IsMac {
cmd = macCommands[info.Key]
}
e := &proto.InputDispatchKeyEvent{
Type: tp,
WindowsVirtualKeyCode: info.KeyCode,
Code: info.Code,
Key: info.Key,
Text: txt,
UnmodifiedText: txt,
Location: l,
IsKeypad: keypad,
Modifiers: modifiers,
Commands: cmd,
}
return e
}
|
package main
// Structures used to represent the schema.
type JsonSchema struct {
Title string `json:"title,omitempty"`
Description string `json:"description,omitempty"`
Type string `json:"type,omitempty"`
Definitions map[string]*JsonSchema `json:"definitions,omitempty"`
// If type is 'object'
Properties map[string]*JsonSchema `json:"properties,omitempty"`
// If type is 'array'
Items *JsonSchema `json:"items,omitempty"`
// If type is not present, implies object of type Ref, or enum values.
Enum []interface{} `json:"enum,omitempty"`
Ref string `json:"$ref,omitempty"`
Links []*JsonLink `json:"links,omitempty"`
}
type JsonLink struct {
Href string `json:"href,omitempty"`
Rel string `json:"rel,omitempty"`
Title string `json:"title,omitempty"`
Description string `json:"description,omitempty"`
Method string `json:"method,omitempty"`
EncType string `json:"encType,omitempty"`
Schema *JsonSchema `json:"schema,omitempty"`
TargetSchema *JsonSchema `json:"targetSchema,omitempty"`
}
|
// Command query implements a simple CLI for querying a PHP AST.
package main
import (
"flag"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
"github.com/stephens2424/php/ast"
"github.com/stephens2424/php/parser"
"github.com/stephens2424/php/query"
)
func main() {
recursive := flag.Bool("r", false, "Recursive")
flag.Parse()
selector := strings.Join(flag.Args(), " ")
dir, err := os.Getwd()
if err != nil {
panic(err)
}
g := newGatherer(*recursive)
if err := filepath.Walk(dir, g.walkFile); err != nil {
panic(err)
}
selected, _ := query.Select(g.nodes).Select(selector)
/*
for _, sel := range selected {
pos := sel.Node.Begin()
fmt.Println(pos)
}
*/
fmt.Println(len(selected), "found")
}
func newGatherer(recursive bool) gatherer {
return gatherer{recursive, make([]ast.Node, 0)}
}
type gatherer struct {
recursive bool
nodes []ast.Node
}
func (g *gatherer) walkFile(path string, info os.FileInfo, err error) error {
// TODO handle error
_ = err
if info.IsDir() || !strings.HasSuffix(path, ".php") {
return nil
}
if info.IsDir() && !g.recursive {
return filepath.SkipDir
}
f, err := os.Open(path)
if err != nil {
return err
}
defer func() { _ = f.Close() }()
src, err := ioutil.ReadAll(f)
if err != nil {
return err
}
p := parser.NewParser()
file, err := p.Parse("test.php", string(src))
if err != nil {
return err
}
g.nodes = append(g.nodes, file.Nodes...)
return nil
}
|
package swordoffer
import "sort"
//剑指 Offer 38. 字符串的排列
//输入一个字符串，打印出该字符串中字符的所有排列。
//
//
//
//你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
//
//
//
//示例:
//
//输入：s = "abc"
//输出：["abc","acb","bac","bca","cab","cba"]
//
//
//限制：
//
//1 <= s 的长度 <= 8
func permutation(s string) []string {
array := []byte(s)
n := len(s)
dic := make([]byte, 0)
result := make([]string, 0)
sort.Slice(array, func(i, j int) bool {
return array[i] < array[j]
})
visited := make([]bool, n)
var dfs func(x int)
dfs = func(x int) {
if x == n {
result = append(result, string(dic))
return
}
for i, _ := range visited {
if visited[i] || (i > 0 && !visited[i-1] && array[i-1] == array[i]) {
continue
}
visited[i] = true
dic = append(dic, array[i])
dfs(x + 1)
dic = dic[:len(dic)-1]
visited[i] = false
}
}
dfs(0)
return result
}
|
package tariff
import (
"errors"
"net/http"
"sync"
"time"
"github.com/cenkalti/backoff/v4"
"github.com/evcc-io/evcc/api"
"github.com/evcc-io/evcc/tariff/ngeso"
"github.com/evcc-io/evcc/util"
"github.com/evcc-io/evcc/util/request"
"slices"
)
type Ngeso struct {
mux sync.Mutex
log *util.Logger
regionId string
regionPostcode string
data api.Rates
updated time.Time
}
var _ api.Tariff = (*Ngeso)(nil)
func init() {
registry.Add("ngeso", NewNgesoFromConfig)
}
func NewNgesoFromConfig(other map[string]interface{}) (api.Tariff, error) {
var cc struct {
Region string
Postcode string
}
if err := util.DecodeOther(other, &cc); err != nil {
return nil, err
}
if cc.Region != "" && cc.Postcode != "" {
return nil, errors.New("cannot define region and postcode simultaneously")
}
t := &Ngeso{
log: util.NewLogger("ngeso"),
regionId: cc.Region,
regionPostcode: cc.Postcode,
}
done := make(chan error)
go t.run(done)
err := <-done
return t, err
}
func (t *Ngeso) run(done chan error) {
var once sync.Once
client := request.NewHelper(t.log)
bo := newBackoff()
// Use national results by default.
var tReq ngeso.CarbonForecastRequest
tReq = ngeso.ConstructNationalForecastRequest()
// If a region is available, use that.
// These should never be set simultaneously (see NewNgesoFromConfig), but in the rare case that they are,
// use the postcode as the preferred method.
if t.regionId != "" {
tReq = ngeso.ConstructRegionalForecastByIDRequest(t.regionId)
}
if t.regionPostcode != "" {
tReq = ngeso.ConstructRegionalForecastByPostcodeRequest(t.regionPostcode)
}
// Data updated by ESO every half hour, but we only need data every hour to stay current.
for ; true; <-time.Tick(time.Hour) {
var carbonResponse ngeso.CarbonForecastResponse
if err := backoff.Retry(func() error {
var err error
carbonResponse, err = tReq.DoRequest(client)
// Consider whether errors.As would be more appropriate if this needs to start dealing with wrapped errors.
if se, ok := err.(request.StatusError); ok && se.HasStatus(http.StatusBadRequest) {
// Catch cases where we're sending completely incorrect data (usually the result of a bad region).
return backoff.Permanent(se)
}
return err
}, bo); err != nil {
once.Do(func() { done <- err })
t.log.ERROR.Println(err)
continue
}
once.Do(func() { close(done) })
t.mux.Lock()
t.updated = time.Now()
t.data = make(api.Rates, 0, len(carbonResponse.Results()))
for _, r := range carbonResponse.Results() {
ar := api.Rate{
Start: r.ValidityStart.Time,
End: r.ValidityEnd.Time,
// Use the forecasted rate, as the actual rate is only available for historical data
Price: r.Intensity.Forecast,
}
t.data = append(t.data, ar)
}
t.mux.Unlock()
}
}
// Rates implements the api.Tariff interface
func (t *Ngeso) Rates() (api.Rates, error) {
t.mux.Lock()
defer t.mux.Unlock()
return slices.Clone(t.data), outdatedError(t.updated, time.Hour)
}
// Type implements the api.Tariff interface
func (t *Ngeso) Type() api.TariffType {
return api.TariffTypeCo2
}
|
package minstack
import "github.com/alandtsang/leetcode-go/stack"
type Stack = stack.Stack
type MinStack struct {
min *Stack
data *Stack
}
/** initialize your data structure here. */
func Constructor() MinStack {
minStack := stack.NewStack()
dataStack := stack.NewStack()
return MinStack{
min: minStack,
data: dataStack,
}
}
func (this *MinStack) Push(x int) {
this.data.Push(x)
if this.min.Len() == 0 {
this.min.Push(x)
} else {
val := this.GetMin()
if x < val {
this.min.Push(x)
} else {
this.min.Push(val)
}
}
}
func (this *MinStack) Pop() {
this.data.Pop()
this.min.Pop()
}
func (this *MinStack) Top() int {
top := this.data.Peek()
return top.(int)
}
func (this *MinStack) GetMin() int {
m := this.min.Peek()
return m.(int)
}
|
package mservice
type ServiceHousekeep struct {
ServiceRecord
Price string
TimeAvailable string
OptType int //1: 自带 : 2：雇主提供
Hint string
Description string
}
|
package controller
import (
"github.com/gin-gonic/gin"
"dawn_media/conf"
"dawn_media/model"
"dawn_media/tool"
"net/http"
"strconv"
"time"
"errors"
"strings"
)
/**
用户前台管理评论
*/
func PageODUserComment(c *gin.Context) {
var authUser *model.User
if t, ok := c.Get("authUser"); ok {
authUser = t.(*model.User)
}
var (
page = model.DefaultPage(c)
curTime = strconv.Itoa(int(time.Now().Unix()))
comments = make([]*model.Comment, 0)
)
page.Find(
&comments,
model.CommentConditionDB(0, authUser.ID, c.DefaultQuery("curTime", curTime)),
false)
c.HTML(http.StatusOK, "ordinary/user_comment", h(gin.H{
"comments": comments,
"page": page,
}, c))
}
/**
用户后台管理评论
*/
func PageUserComment(c *gin.Context) {
var (
page = model.DefaultPage(c)
curTime = strconv.Itoa(int(time.Now().Unix()))
comments = make([]*model.Comment, 0)
)
page.Find(
&comments,
model.CommentConditionDB(0, 0, c.DefaultQuery("curTime", curTime)),
false)
c.HTML(http.StatusOK, "admin/manage_comment", h(gin.H{
"comments": comments,
"page": page,
}, c))
}
/**
管理员删除评论
*/
func CommentDelete(c *gin.Context) {
commentDelete(c, "/admin/manage_comment")
}
/**
用户删除评论
*/
func ODCommentDelete(c *gin.Context) {
commentDelete(c, "/ordinary/user_comment")
}
func commentDelete(c *gin.Context, uri string) {
ids := tool.GetInts(c.PostFormArray("comment_ids"))
if err := model.Delete(&model.Comment{}, ids...); err != nil {
redirectError(c, uri, err.Error())
return
}
redirectOK(c, uri, "删除成功")
}
/**
用户发表评论
*/
func CommentCreate(c *gin.Context) {
var (
authUser *model.User
err = errors.New("无权限发表评论")
)
if t, ok := c.Get("authUser"); ok {
authUser = t.(*model.User)
comment := &model.Comment{}
comment.UserID = authUser.ID
if e := c.ShouldBindJSON(comment); e == nil {
if len(strings.TrimSpace(comment.Content)) < 1 {
err = errors.New("评论不能为空")
} else {
if e := comment.Create(); e == nil {
if e := comment.Get(); e == nil {
c.JSON(http.StatusOK, j(http.StatusOK, gin.H{
"comment": comment,
"avatarMap": conf.C().AvatarMap,
}, ""))
return
} else {
err = e
}
} else {
err = e
}
}
} else {
err = e
}
}
c.JSON(http.StatusBadRequest, j(http.StatusBadRequest, "", err.Error()))
}
/**
获取评论，根据时间戳和媒体id获取，时间戳为了防止重复加载
*/
func GetComments(c *gin.Context) {
var (
page = model.DefaultPage(c)
curTime = c.Query("curTime")
media = &model.Media{}
)
media.ID = tool.GetInt(c.DefaultQuery("id", "0"))
if media.ID == 0 || !model.Exist(media, media.ID) {
c.JSON(http.StatusBadRequest, j(http.StatusBadRequest, nil, "媒体不存在"))
return
}
comments := make([]*model.Comment, 0)
page.Find(&comments, model.CommentConditionDB(media.ID, 0, curTime), false)
c.JSON(http.StatusOK, j(http.StatusOK, gin.H{
"page": page,
"comments": comments,
"avatarMap": conf.C().AvatarMap,
}, ""))
}
|
package utility
import (
"context"
"database/sql"
"fmt"
"net/url"
"time"
kitlog "github.com/go-kit/kit/log"
)
// BuildDsn uses the provided values to build a URL based DSN to connect to a database.
//
// Parameters
// scheme is the connection scheme, such as "sqlserver"
// username: to authenticate to the server with, such as "sa"
// password: for the account given by the username
// hostname: for the server hosting the database, such as "localhost"
// port: for the port the server is listening for a connection on
// database: for the database to use for all requests using this connection
//
// Outputs
// dsn: database connection string in format: "<scheme>://<username>:<password>@<hostname>:<port>?params=p1"
func BuildDsn(scheme, username, password, hostname, port, database string) (dsn *url.URL) {
query := url.Values{}
query.Add("app name", "gateway")
query.Add("database", database)
return &url.URL{
Scheme: scheme,
User: url.UserPassword(username, password),
Host: fmt.Sprintf("%s:%s", hostname, port),
RawQuery: query.Encode(),
}
}
// PingDatabase will periodically check to see if the database connection is still open and the database is accessible.
//
//
// Parameters
//
//
// ctx: basic context
//
// db: the connection for the database that should be pinged
//
// sleepFailTime: the amount of time PingDatabase should wait to ping again after a failed ping
//
// mssqlRequiredVersion: checks the version of the stored procedures the database is exposing
// Will log an error if a version other than the one specified is exposed
//
// logger: a Logger to log any issues/errors
//
//
// Outputs none
func PingDatabase(ctx context.Context, db *sql.DB, sleepFailTime time.Duration,
sleepTestTime time.Duration, mssqlRequiredVersion *SemVer, logger kitlog.Logger,
statusNotOkay chan bool) {
for {
select {
case <-ctx.Done():
_ = logger.Log("PingDatabase: ping check canceled")
return
default:
if err := db.Ping(); err != nil {
_ = logger.Log("func", "utility.PingDatabase", "pingError", err.Error(), "note", "will retry in "+sleepTestTime.String())
select {
case _, _ = <-statusNotOkay:
break
default:
break
}
statusNotOkay <- true
time.Sleep(sleepFailTime)
} else {
row := db.QueryRow("USP_ReadProcedureVersion")
type versionVal struct {
Version string `json:"version"`
}
var vv versionVal
errS := row.Scan(&vv.Version)
if errS == nil {
semVerProc, errSVS := SemVerFromString(vv.Version)
if errSVS != nil {
_ = logger.Log("utility.PingDatabase", "invalid version string provided")
select {
case _, _ = <-statusNotOkay:
break
default:
break
}
statusNotOkay <- true
} else if semVerProc.Compare(mssqlRequiredVersion) < 0 {
_ = logger.Log("utility.PingDatabase", "unsupported database version",
"minimumVersionRequired", mssqlRequiredVersion.String(),
"versionConnected", semVerProc.String())
select {
case _, _ = <-statusNotOkay:
break
default:
break
}
statusNotOkay <- true
}
} else {
_ = logger.Log("utility.PingDatabase", "unable to get proc version from database", "error", errS.Error())
select {
case _, _ = <-statusNotOkay:
break
default:
break
}
statusNotOkay <- true
}
}
select {
case _, _ = <-statusNotOkay:
break
default:
break
}
statusNotOkay <- false
time.Sleep(sleepTestTime)
}
}
}
|
package model
//微信支付回调返回示例
//<xml>
//<appid><![CDATA[wx2421b1c4370ec43b]]></appid>
//<attach><![CDATA[支付测试]]></attach>
//<bank_type><![CDATA[CFT]]></bank_type>
//<fee_type><![CDATA[CNY]]></fee_type>
//<is_subscribe><![CDATA[Y]]></is_subscribe>
//<mch_id><![CDATA[10000100]]></mch_id>
//<nonce_str><![CDATA[5d2b6c2a8db53831f7eda20af46e531c]]></nonce_str>
//<openid><![CDATA[oUpF8uMEb4qRXf22hE3X68TekukE]]></openid>
//<out_trade_no><![CDATA[1409811653]]></out_trade_no>
//<result_code><![CDATA[SUCCESS]]></result_code>
//<return_code><![CDATA[SUCCESS]]></return_code>
//<sign><![CDATA[B552ED6B279343CB493C5DD0D78AB241]]></sign>
//<sub_mch_id><![CDATA[10000100]]></sub_mch_id>
//<time_end><![CDATA[20140903131540]]></time_end>
//<total_fee>1</total_fee>
//<coupon_fee_0><![CDATA[10]]></coupon_fee_0>
//<coupon_count><![CDATA[1]]></coupon_count>
//<coupon_type><![CDATA[CASH]]></coupon_type>
//<coupon_id><![CDATA[10000]]></coupon_id>
//<trade_type><![CDATA[JSAPI]]></trade_type>
//<transaction_id><![CDATA[1004400740201409030005092168]]></transaction_id>
//</xml>
type PayResponse struct {
AppId string `json:"app_id"`
Attach string `json:"attach"`
BankType string `json:"bank_type"`
FeeType string `json:"fee_type"`
IsSubscribe string `json:"is_subscribe"`
MchId string `json:"mch_id"`
NonceStr string `json:"nonce_str"`
OpenId string `json:"open_id"`
OutTradeNo string `json:"out_trade_no"`
ResultCode string `json:"result_code"`
ReturnCode string `json:"return_code"`
Sign string `json:"sign"`
SubMchId string `json:"sub_mch_id"`
TimeEnd string `json:"time_end"`
TotalFee int64 `json:"total_fee"`
TradeType string `json:"trade_type"`
TransactionId string `json:"transaction_id"`
}
type HttpResponse struct {
Authorization string `json:"authorization"`
}
|
// Copyright 2015 The go-aita Authors
// This file is part of the go-aita library.
//
// The go-aita library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-aita library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-aita library. If not, see <http://www.gnu.org/licenses/>.
package aita
import (
"aita_chain/common"
"aita_chain/core/shard"
"aita_chain/gVar"
"aita_chain/params"
"errors"
"fmt"
"math/big"
"math/rand"
"sync"
"sync/atomic"
"time"
"aita_chain/aita/downloader"
"aita_chain/aita/fetcher"
"aita_chain/aitadb"
"aita_chain/consensus"
"aita_chain/core"
"aita_chain/core/types"
"aita_chain/event"
"aita_chain/log"
"aita_chain/p2p"
"aita_chain/p2p/anode"
)
const (
txChanSize = 4096
leader = 0
member = 1
xcrossed = 1
sameshard = 0
yes = 1
no = 0
// leader decision time out (unit: s)
leaderDecisionTimeOut = 3600
// enough number to start a service
EpochReadyNum = 0
)
var (
daoChallengeTimeout = 15 * time.Second // Time allowance for a node to reply to the DAO handshake challenge
)
// errIncompatibleConfig is returned if the requested protocols and configs are
// not compatible (low protocol version restrictions and high requirements).
var errIncompatibleConfig = errors.New("incompatible configuration")
func errResp(code errCode, format string, v ...interface{}) error {
return fmt.Errorf("%v - %v", code, fmt.Sprintf(format, v...))
}
type ProtocolManager struct {
networkID uint64
fastSync uint32 // Flag whether fast sync is enabled (gets disabled if we already have blocks)
acceptTxs uint32 // Flag whether we're considered synchronised (enables transaction processing)
txpool txPool
maxPeers int
downloader *downloader.Downloader
fetcher *fetcher.Fetcher
peers *peerSet
// NOTE: peer pool is used to maintain all connected peers
peerPool PeerPool
// USE CoreCache
coreCache *shard.CoreCache
SubProtocols []p2p.Protocol
eventMux *event.TypeMux
txsCh chan core.NewTxsEvent
txsSub event.Subscription
minedBlockSub *event.TypeMuxSubscription
// channels for fetcher, syncer, txsyncLoop
newPeerCh chan *peer
txsyncCh chan *txsync
quitSync chan struct{}
noMorePeers chan struct{}
wg sync.WaitGroup
}
func NewProtocolManager(config *params.ChainConfig, mode downloader.SyncMode, networkID uint64, mux *event.TypeMux, txpool txPool, engine consensus.Engine, blockchain interface{}, chaindb aitadb.Database, coreCache *shard.CoreCache) (*ProtocolManager, error) {
// Create the protocol manager with the base fields
manager := &ProtocolManager{
networkID: networkID,
eventMux: mux,
txpool: txpool,
peers: newPeerSet(),
newPeerCh: make(chan *peer),
noMorePeers: make(chan struct{}),
txsyncCh: make(chan *txsync),
quitSync: make(chan struct{}),
//goShard: make(chan int),
coreCache: coreCache,
peerPool: GetPeerPoolIns(),
}
// Initiate a sub-protocol for every implemented version we can handle
manager.SubProtocols = make([]p2p.Protocol, 0, len(ProtocolVersions))
for i, version := range ProtocolVersions {
version := version // Closure for the run
manager.SubProtocols = append(manager.SubProtocols, p2p.Protocol{
Name: ProtocolName,
Version: version,
Length: ProtocolLengths[i],
Run: func(p *p2p.Peer, rw p2p.MsgReadWriter) error {
peer := manager.newPeer(int(version), p, rw)
select {
case manager.newPeerCh <- peer:
manager.wg.Add(1)
defer manager.wg.Done()
return manager.handle(peer)
case <-manager.quitSync:
return p2p.DiscQuitting
}
},
PeerInfo: func(id anode.ID) interface{} {
if p := manager.peers.Peer(fmt.Sprintf("%x", id[:8])); p != nil {
return p.Info()
}
return nil
},
})
}
if len(manager.SubProtocols) == 0 {
return nil, errIncompatibleConfig
}
manager.peerPool.InitProtocol(manager.SubProtocols)
return manager, nil
}
func (pm *ProtocolManager) removePeer(id string) {
// Short circuit if the peer was already removed
peer := pm.peers.Peer(id)
if peer == nil {
return
}
log.Debug("Removing Aita peer", "peer", id)
if err := pm.peers.Unregister(id); err != nil {
log.Error("Peer removal failed", "peer", id, "err", err)
}
// Hard disconnect at the networking layer
if peer != nil {
peer.Peer.Disconnect(p2p.DiscUselessPeer)
}
}
func (pm *ProtocolManager) Start(maxPeers int) {
pm.maxPeers = maxPeers
// broadcast transactions
pm.txsCh = make(chan core.NewTxsEvent, txChanSize)
pm.txsSub = pm.txpool.SubscribeNewTxsEvent(pm.txsCh)
node, exist := pm.peerPool.PM().GetSelf()
if exist {
pm.coreCache.ShardID = node.ShardId
pm.coreCache.InShardID = node.InShardId
pm.coreCache.Role = int(node.Type)
}
go pm.CheckReady()
<-pm.coreCache.GoShard
go pm.txBroadcastLoop()
go func(pm *ProtocolManager) {
var i = 0
for {
for {
if len(pm.coreCache.TxListGroupPool) == 0 {
time.Sleep(time.Second * 1)
} else {
break
}
}
go pm.txListProcess()
time.Sleep(time.Second * 1)
i++
}
}(pm)
}
func (pm *ProtocolManager) CheckReady() {
for {
time.Sleep(time.Microsecond * 3000)
// FIXME LEN(PEERS) IS 1, WHEN NO PEERS
length := pm.peerPool.PM().GetPeerCount(pm.coreCache.ShardID)
if length >= EpochReadyNum {
pm.coreCache.GoShard <- true
break
}
time.Sleep(time.Microsecond * 3000)
}
}
func (pm *ProtocolManager) txListProcess() {
TLG := <-pm.coreCache.TxListGroupPool
pm.signTxList(TLG)
go pm.sendTxList()
timeoutflag := true
cnt := 1
thisRoundIdx := TLG.TLS[pm.coreCache.ShardID].Round
ch := pm.coreCache.TxlDeChanMap.Get(thisRoundIdx)
for timeoutflag && cnt < int(gVar.ShardSize) {
select {
case <-ch:
cnt++
case <-time.After(leaderDecisionTimeOut * time.Second):
fmt.Println("TxDecSet is not full", cnt, "in total")
timeoutflag = false
}
}
fmt.Println("TxDec of Round", thisRoundIdx, "total txdec: ", uint32(cnt))
// NOTE use a global var to track the round
if thisRoundIdx-pm.coreCache.PrevHeight > 0 {
for {
pm.coreCache.TxlProcessedNumLock.Lock()
v := pm.coreCache.TxlProcessedNum
pm.coreCache.TxlProcessedNumLock.Unlock()
if v == thisRoundIdx-pm.coreCache.PrevHeight-1 {
break
}
time.Sleep(time.Microsecond * 500)
}
}
pm.signTxDecSet(TLG)
pm.processTransactionDecisionSet(TLG.TDS[pm.coreCache.ShardID])
go pm.sendTxDecSet(TLG)
go pm.NormalTxBlock(thisRoundIdx - pm.coreCache.PrevHeight)
pm.coreCache.TxlProcessedNumLock.Lock()
pm.coreCache.TxlProcessedNum++
pm.coreCache.TxlProcessedNumLock.Unlock()
pm.coreCache.TxListGoroutineTokens <- true
}
func (pm *ProtocolManager) release(tlg *shard.TLGroup) {
pm.coreCache.TxlDeChanMap.Delete(tlg.TLS[pm.coreCache.ShardID].Round)
hash := tlg.TLS[pm.coreCache.ShardID].HashID
delete(pm.coreCache.TlgMap, hash)
}
// Gen and send TxBlock
func (pm *ProtocolManager) NormalTxBlock(currentRound uint32) {
if currentRound > 0 {
//<-pm.coreCache.TBBChan[pm.coreCache.CurrentRound-1]
for {
pm.coreCache.TxblkSequenceLock.Lock()
v := pm.coreCache.TxBlkSequence
pm.coreCache.TxblkSequenceLock.Unlock()
if v == currentRound-1 {
break
}
time.Sleep(time.Microsecond * 500)
}
}
pm.GenTxBlock()
go pm.SendTxBlock()
pm.coreCache.TxblkSequenceLock.Lock()
pm.coreCache.TxBlkSequence++
pm.coreCache.TxblkSequenceLock.Unlock()
}
func (pm *ProtocolManager) TxLastBlock() {
lastFlag := true
for lastFlag {
tmpEpoch := <-pm.coreCache.StartLastTxBlock
if tmpEpoch == pm.coreCache.CurrentEpoch {
lastFlag = false
}
}
}
// generate transaction block
func (pm *ProtocolManager) GenTxBlock() {
height := pm.coreCache.TxBlkChain.Height
pm.coreCache.TxBlock = new(core.TxBlock)
pm.coreCache.TxBlock.MakeTxBlock(pm.coreCache.InShardID, &pm.coreCache.Ready, pm.coreCache.TxBlkChain.LastTB, pm.coreCache.Prikey, height+1, 0, nil, 0)
pm.coreCache.Ready = nil
*(pm.coreCache.TBCache) = append(*(pm.coreCache.TBCache), pm.coreCache.TxBlock.HashID)
pm.coreCache.TxCntProcessed += pm.coreCache.TxBlock.TxCnt
pm.coreCache.TxBlkChain.AddBlock(pm.coreCache.TxBlock)
}
// send transaction block
func (pm *ProtocolManager) SendTxBlock() {
peers := pm.peerPool.PM().GetPeers(pm.coreCache.ShardID)
for _, p := range peers {
peer, ok := convert(p)
if ok && peer.InShardID != pm.coreCache.InShardID {
go peer.SendTxBlock(pm.coreCache.TxBlock)
}
}
}
func (pm *ProtocolManager) PreprocessTxBlock(block *core.TxBlock, sc *types.StatusCheck) error {
if sc == nil {
return fmt.Errorf("statuscheck is nil")
}
if sc.UnknownTxNum == gVar.INITTIAL_STATUS {
if int(block.TxCnt) != len(block.TxArray) {
return fmt.Errorf("PreTxBlock: TxBlock parameter not match")
}
sc.UnknownTxNum = int(block.TxCnt)
sc.Valid = make([]int, block.TxCnt)
for i := uint32(0); i < block.TxCnt; i++ {
_, ok := pm.coreCache.TxHashCache[block.TxHash[i]]
if !ok {
tmpWait, okW := pm.coreCache.WaitHashCache[block.TxHash[i]]
if okW {
tmpWait.DataTB = append(tmpWait.DataTB, block)
tmpWait.StatTB = append(tmpWait.StatTB, sc)
// NOTE i-th transaction
tmpWait.IDTB = append(tmpWait.IDTB, int(i))
} else {
tmpWait = shard.WaitProcess{nil, nil, nil, nil, nil, nil, nil, nil, nil}
tmpWait.DataTB = append(tmpWait.DataTB, block)
tmpWait.StatTB = append(tmpWait.StatTB, sc)
tmpWait.IDTB = append(tmpWait.IDTB, int(i))
}
pm.coreCache.WaitHashCache[block.TxHash[i]] = tmpWait
} else {
sc.UnknownTxNum--
sc.Valid[i] = gVar.TX_KNOWN
}
}
}
if sc.UnknownTxNum > 0 {
sc.Channel = make(chan bool, sc.UnknownTxNum)
}
return nil
}
//GetTxBlock handle the txblock sent by the leader
func (pm *ProtocolManager) GetTxBlock(a *core.TxBlock) error {
pm.coreCache.TXBlockRWL.Lock()
if pm.coreCache.TxBlock != nil {
if a.Height != pm.coreCache.TxBlock.Height+1 {
return fmt.Errorf("Height not match")
}
for i := uint32(0); i < a.TxCnt; i++ {
pm.coreCache.ClearCache(a.TxHash[i])
}
*(pm.coreCache.TBCache) = append(*(pm.coreCache.TBCache), a.HashID)
pm.coreCache.TxBlock = a
pm.coreCache.TxCntProcessed += pm.coreCache.TxBlock.TxCnt
pm.coreCache.TxBlkChain.AddBlock(a)
pm.coreCache.CurrentRound++
}
pm.coreCache.TXBlockRWL.Unlock()
return nil
}
func (pm *ProtocolManager) HandleTxBlock(txblk *core.TxBlock) error {
sc := types.StatusCheck{UnknownTxNum: gVar.INITTIAL_STATUS, Valid: nil}
pm.PreprocessTxBlock(txblk, &sc)
timeoutFlag := true
cnt := sc.UnknownTxNum
for timeoutFlag && sc.UnknownTxNum > 0 {
select {
case <-sc.Channel:
cnt--
case <-time.After(60 * time.Second):
timeoutFlag = false
}
}
if pm.coreCache.CurrentRound > 0 {
//<-pm.coreCache.TBBChan[pm.coreCache.CurrentRound-1]
for {
pm.coreCache.TxblkSequenceLock.Lock()
v := pm.coreCache.TxBlkSequence
pm.coreCache.TxblkSequenceLock.Unlock()
if v == pm.coreCache.CurrentRound-1 {
break
}
time.Sleep(time.Microsecond * 500)
}
}
flag := true
//fmt.Println("TxB Kind", tmp.Kind)
for flag {
err := pm.GetTxBlock(txblk)
if err != nil {
//fmt.Println("txBlock", base58.Encode(tmp.HashID[:]), " error", err)
} else {
flag = false
}
time.Sleep(time.Microsecond * gVar.GeneralSleepTime)
}
pm.coreCache.TxblkSequenceLock.Lock()
pm.coreCache.TxBlkSequence++
pm.coreCache.TxblkSequenceLock.Unlock()
//if txblk.Height <= pm.coreCache.PrevHeight+gVar.NumTxListPerEpoch {
// pm.coreCache.TBChan[txblk.Height-pm.coreCache.PrevHeight-1] <- pm.coreCache.CurrentEpoch
//}
// NOTE don't check bad blocks
//if tmp.Kind != 3 {
//
//} else {
// fmt.Println(time.Now(), CacheDbRef.ID, "gets a bad txBlock with", tmp.TxCnt, "Txs from", tmp.ID, "Hash", base58.Encode(tmp.HashID[:]), "Height:", tmp.Height)
// RollingProcess(true, false, tmp)
//}
return nil
}
func (pm *ProtocolManager) signTxDecSet(tlg *shard.TLGroup) {
for i := uint32(0); i < gVar.ShardCnt; i++ {
tlg.TDS[i].Sign(pm.coreCache.Prikey)
}
}
func (pm *ProtocolManager) sendTxDecSet(tlg *shard.TLGroup) {
go pm.sendTxDecSetInShard(tlg)
//NOTE RANDOM SEED
rand.Seed(time.Now().Unix() + rand.Int63())
for i := uint32(0); i < gVar.ShardCnt; i++ {
p := pm.peerPool.PM().GetRandom(i)
peer, ok := convert(p)
if ok {
go peer.SendXShardTxDecSet(tlg.TDS[peer.ShardID])
}
}
cnt := 1
mask := make([]bool, gVar.ShardCnt)
mask[pm.coreCache.ShardID] = true
for cnt < int(gVar.ShardCnt) {
select {
case tmp := <-pm.coreCache.TxDecRevChan[pm.coreCache.CurrentRound]:
fmt.Println("Get txdecRev from", tmp.ShardID)
mask[tmp.ShardID] = true
cnt++
case <-time.After(5 * time.Second):
for i := uint32(0); i < gVar.ShardCnt; i++ {
if !mask[i] {
p := pm.peerPool.PM().GetRandom(i)
peer, ok := convert(p)
if ok {
peer.SendXShardTxDecSet(tlg.TDS[peer.ShardID])
}
}
}
}
}
pm.release(tlg)
}
func (pm *ProtocolManager) PreprocessTxDecSet(tds *types.TxDecSet, sc *types.StatusCheck) error {
if sc == nil {
return fmt.Errorf("statuscheck is nil")
}
if sc.UnknownTxNum == gVar.INITTIAL_STATUS {
sc.UnknownTxNum = int(tds.TxCnt)
sc.Valid = make([]int, tds.TxCnt)
for i := uint32(0); i < tds.TxCnt; i++ {
_, ok := pm.coreCache.TxHashCache[tds.TxArray[i]]
if !ok {
tmpWait, okW := pm.coreCache.WaitHashCache[tds.TxArray[i]]
if okW {
tmpWait.DataTDS = append(tmpWait.DataTDS, tds)
tmpWait.StatTDS = append(tmpWait.StatTDS, sc)
tmpWait.IDTDS = append(tmpWait.IDTDS, int(i))
} else {
tmpWait = shard.WaitProcess{nil, nil, nil, nil, nil, nil, nil, nil, nil}
tmpWait.DataTDS = append(tmpWait.DataTDS, tds)
tmpWait.StatTDS = append(tmpWait.StatTDS, sc)
tmpWait.IDTDS = append(tmpWait.IDTDS, int(i))
}
pm.coreCache.WaitHashCache[tds.TxArray[i]] = tmpWait
} else {
sc.UnknownTxNum--
sc.Valid[i] = gVar.TX_KNOWN
}
}
}
if sc.UnknownTxNum > 0 {
sc.Channel = make(chan bool, sc.UnknownTxNum)
}
return nil
}
func (pm *ProtocolManager) HandleTxDecSetLeader(tds *types.TxDecSet) error {
statusCheck := types.StatusCheck{UnknownTxNum: gVar.INITTIAL_STATUS, Valid: nil}
pm.PreprocessTxDecSet(tds, &statusCheck)
flag := true
if statusCheck.UnknownTxNum == 0 {
flag = false
}
for flag {
time.Sleep(time.Microsecond * 50)
if statusCheck.UnknownTxNum == 0 {
flag = false
}
}
flag = false
pm.processTransactionDecisionSet(tds)
pm.coreCache.TDSCnt[tds.ShardIndexFrom]++
if pm.coreCache.TDSCnt[tds.ShardIndexFrom] == gVar.NumTxListPerEpoch {
pm.coreCache.TDSNotReady--
if pm.coreCache.TDSNotReady == 0 {
flag = true
}
}
if flag {
pm.coreCache.StartLastTxBlock <- pm.coreCache.CurrentEpoch
}
return nil
}
func (pm *ProtocolManager) HandleTxDecRecv(tdsr *types.TxDecSetRev) error {
pm.coreCache.TxDecRevChan[tdsr.Round-pm.coreCache.PrevHeight] <- *tdsr
return nil
}
func (pm *ProtocolManager) HandleTxDecSet(tds *types.TxDecSet, inputType int) error {
if tds.Round < pm.coreCache.PrevHeight {
return fmt.Errorf("Previous epoch packet")
}
if inputType == xcrossed {
var tdr types.TxDecSetRev
tdr.ShardID = pm.coreCache.ShardID
tdr.Round = tds.Round
p := pm.peerPool.PM().Get(tds.ShardIndexFrom, tds.SenderInShardID)
peer, ok := p.(*peer)
if ok && peer != nil {
go peer.SendTxDecSetRecv(&tdr)
}
}
return nil
}
func (pm *ProtocolManager) HandleAndSendTxDecSet(tds *types.TxDecSet) error {
err := pm.HandleTxDecSet(tds, xcrossed)
if err != nil {
return err
}
peers := pm.peerPool.PM().GetPeers(pm.coreCache.ShardID)
for _, prIf := range peers {
pr := prIf.(*peer)
if pr.InShardID != pm.coreCache.InShardID {
go pr.SendInShardTxDecSet(tds)
}
}
return nil
}
func (pm *ProtocolManager) sendTxDecSetInShard(tlg *shard.TLGroup) {
ps := pm.peerPool.PM().GetPeers(pm.coreCache.ShardID)
if len(ps) > 0 {
fmt.Println("U go peers ++++++")
for _, p := range ps {
peer, ok := convert(p)
if ok && peer.InShardID != pm.coreCache.InShardID {
go peer.SendInShardTxDecSet(tlg.TDS[pm.coreCache.ShardID])
}
}
} else {
fmt.Println("U cannot go peers ++++++")
}
}
func (pm *ProtocolManager) processTransactionDecisionSet(tds *types.TxDecSet) {
if tds.ShardIndexFrom == pm.coreCache.ShardID {
tmpTlg, ok := pm.coreCache.TlgMap[tds.TxlistHashID]
if ok {
tds.TxCnt = tmpTlg.TLS[pm.coreCache.ShardID].TxCnt
tds.TxArray = tmpTlg.TLS[pm.coreCache.ShardID].TxArray
}
}
for i := uint32(0); i < tds.TxCnt; i++ {
tmpTxHash := tds.TxArray[i]
tmpXShardDec := pm.coreCache.CacheXshardDecs.Get(tmpTxHash)
if tmpXShardDec == nil {
tmpXShardDec = new(types.CrossShardDec)
tmpXShardDec.NewFromOther(tds.ShardIndexFrom, tds.Result(i))
pm.coreCache.CacheXshardDecs.Set(tmpTxHash, tmpXShardDec)
} else {
tmpXShardDec.UpdateFromOther(tds.ShardIndexFrom, tds.Result(i))
if tmpXShardDec.Res == gVar.RESULT_YES {
pm.coreCache.Ready = append(pm.coreCache.Ready, *(tmpXShardDec.Data))
}
if tmpXShardDec.Total == 0 {
pm.coreCache.CacheXshardDecs.Delete(tmpTxHash)
} else {
pm.coreCache.CacheXshardDecs.Set(tmpTxHash, tmpXShardDec)
}
}
}
if tds.ShardIndexFrom == pm.coreCache.ShardID {
tds.TxCnt = 0
tds.TxArray = nil
}
}
func (pm *ProtocolManager) signTxList(tlg *shard.TLGroup) {
selfShardID := pm.coreCache.ShardID
tlg.TLS[selfShardID].Sign(pm.coreCache.Prikey)
pm.coreCache.TxCnt += tlg.TLS[selfShardID].TxCnt
for i := uint32(0); i < gVar.ShardCnt; i++ {
if selfShardID != i {
tlg.TLS[i].HashID = tlg.TLS[i].Hash()
}
}
for i := uint32(0); i < gVar.ShardCnt; i++ {
if i == selfShardID {
tlg.TDS[i].Set(tlg.TLS[i], selfShardID, true)
} else {
tlg.TDS[i].Set(tlg.TLS[i], selfShardID, false)
}
}
pm.coreCache.TlgMap[tlg.TLS[pm.coreCache.ShardID].HashID] = tlg
}
func (pm *ProtocolManager) sendTxList() {
for {
v := <-pm.coreCache.TxlReadyPool
pm.sendTxListToShardMembers(v)
}
}
func (pm *ProtocolManager) sendTxListToShardMembers(tlg *shard.TLGroup) {
for _, p := range pm.peerPool.PM().GetPeers(pm.coreCache.ShardID) {
peer, ok := convert(p)
if ok {
go peer.SendTransactionList(tlg.TLS[pm.coreCache.ShardID])
}
}
}
func (pm *ProtocolManager) Stop() {
log.Info("Stopping Aita protocol")
pm.txsSub.Unsubscribe()
pm.minedBlockSub.Unsubscribe()
pm.noMorePeers <- struct{}{}
close(pm.quitSync)
pm.peers.Close()
pm.wg.Wait()
log.Info("Aita protocol stopped")
}
func (pm *ProtocolManager) newPeer(pv int, p *p2p.Peer, rw p2p.MsgReadWriter) *peer {
return newPeer(pv, p, newMeteredMsgWriter(rw))
}
func (pm *ProtocolManager) handle(p *peer) error {
if pm.peers.Len() >= pm.maxPeers && !p.Peer.Info().Network.Trusted {
return p2p.DiscTooManyPeers
}
p.Log().Debug("Aita peer connected", "name", p.Name())
var (
td = new(big.Int)
)
var (
p1 common.Hash
p2 common.Hash
)
if err := p.Handshake(pm.networkID, td, p1, p2); err != nil {
p.Log().Debug("Aita handshake failed", "err", err)
return err
}
if rw, ok := p.rw.(*meteredMsgReadWriter); ok {
rw.Init(p.version)
}
// Register the peer locally
if err := pm.peers.Register(p); err != nil {
p.Log().Error("Aita peer registration failed", "err", err)
return err
}
defer pm.removePeer(p.id)
// Register the peer in the downloader. If the downloader considers it banned, we disconnect
if err := pm.downloader.RegisterPeer(p.id, p.version, p); err != nil {
return err
}
pm.syncTransactions(p)
for {
if err := pm.handleMsg(p); err != nil {
p.Log().Debug("Aita message handling failed", "err", err)
return err
}
}
}
func (pm *ProtocolManager) handleMsg(p *peer) error {
msg, err := p.rw.ReadMsg()
if err != nil {
return err
}
if msg.Size > ProtocolMaxMsgSize {
return errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
}
defer msg.Discard()
// Handle the message depending on its contents
switch {
case msg.Code == StatusMsg:
// Status messages should never arrive after the handshake
return errResp(ErrExtraStatusMsg, "uncontrolled status message")
case msg.Code == TxMsg:
// Transactions arrived, make sure we have a valid and fresh chain to handle them
if atomic.LoadUint32(&pm.acceptTxs) == 0 {
break
}
// Transactions can be processed, parse all of them and deliver to the pool
var txs []*types.Transaction
if err := msg.Decode(&txs); err != nil {
return errResp(ErrDecode, "msg %v: %v", msg, err)
}
for i, tx := range txs {
// Validate and mark the remote transaction
if tx == nil {
return errResp(ErrDecode, "transaction %d is nil", i)
}
p.MarkTransaction(tx.Hash())
}
//here is the injection
pm.txpool.AddRemotes(txs)
case msg.Code == TxListMsg:
// decode txlist
var txl = new(types.TxList)
if err := msg.Decode(txl); err != nil {
return errResp(ErrDecode, "msg %v: %v", msg, err)
}
var puk []byte
peerOfNode := pm.peerPool.PM().GetNode(pm.coreCache.ShardID, txl.SenderInShardID)
if peerOfNode != nil {
puk = peerOfNode.PublicKey()
if err := txl.VerifyTxList(puk); err != nil {
return errResp(ErrDecode, "cannot verify txlist")
}
if pm.coreCache.Role == member {
go pm.HandleTxList(txl)
}
} else {
return errResp(ErrNoPukFound, "cannot find public key")
}
//
case msg.Code == TxListDecMsg:
if pm.coreCache.Role == leader {
var txldec = new(types.TransactionListDecision)
if err := msg.Decode(txldec); err != nil {
return errResp(ErrDecode, "msg %v: %v", msg, err)
}
peerOfNode := pm.peerPool.PM().GetNode(pm.coreCache.ShardID, txldec.SenderInShardID)
if peerOfNode != nil {
if passed := txldec.VerifyTxListDec(peerOfNode.PublicKey()[:], pm.coreCache.ShardID); passed != true {
return errResp(ErrDecode, "cannot verify txlist decision")
}
pm.coreCache.TxlDecRecvCh <- txldec
go pm.HandleDecByLeader()
} else {
return errResp(ErrNoPukFound, "cannot find public key")
}
}
case msg.Code == TxListDecSetInShardMsg:
var tds = new(types.TxDecSet)
if err := msg.Decode(tds); err != nil {
return errResp(ErrDecode, "msg %v: %v", msg, err)
}
peerOfNode := pm.peerPool.PM().GetNode(tds.ShardIndexFrom, tds.SenderInShardID)
if peerOfNode != nil {
if passed := tds.VerifySig(peerOfNode.PublicKey()[:]); passed != true {
return errResp(ErrDecode, "cannot verify txlist decision set")
}
if pm.coreCache.Role == leader {
go pm.HandleTxDecSetLeader(tds)
} else {
go pm.HandleTxDecSet(tds, sameshard)
}
} else {
return errResp(ErrNoPukFound, "cannot find public key")
}
case msg.Code == TxListDecSetXShardMsg:
var tds = new(types.TxDecSet)
if err := msg.Decode(tds); err != nil {
return errResp(ErrDecode, "msg %v: %v", msg, err)
}
peerOfNode := pm.peerPool.PM().GetNode(tds.ShardIndexFrom, tds.SenderInShardID)
if peerOfNode != nil {
if passed := tds.VerifySig(peerOfNode.PublicKey()[:]); passed != true {
return errResp(ErrDecode, "cannot verify txlist decision set")
}
go pm.HandleAndSendTxDecSet(tds)
} else {
return errResp(ErrNoPukFound, "cannot find public key")
}
case msg.Code == TxListDecSetRecv:
var tdsr = new(types.TxDecSetRev)
if err := msg.Decode(tdsr); err != nil {
return errResp(ErrDecode, "msg %v: %v", msg, err)
}
go pm.HandleTxDecRecv(tdsr)
case msg.Code == TxBlockMsg:
var txblk = new(core.TxBlock)
if err := msg.Decode(txblk); err != nil {
return errResp(ErrDecode, "msg %v: %v", msg, err)
}
peerOfNode := pm.peerPool.PM().GetNode(txblk.ShardID, txblk.InShardID)
if peerOfNode != nil {
if passed := txblk.VerifySig(peerOfNode.PublicKey()[:]); passed != true {
return errResp(ErrDecode, "cannot verify txlist decision set")
}
go pm.HandleTxBlock(txblk)
} else {
return errResp(ErrNoPukFound, "cannot find public key")
}
default:
return errResp(ErrInvalidMsgCode, "%v", msg.Code)
}
return nil
}
func (pm *ProtocolManager) BroadcastTxs(txs types.Transactions) {
var txset = make(map[*peer]types.Transactions)
// Broadcast transactions to a batch of peers not knowing about it
for _, tx := range txs {
peers := pm.peers.PeersWithoutTx(tx.Hash())
for _, peer := range peers {
txset[peer] = append(txset[peer], tx)
}
log.Trace("Broadcast transaction", "hash", tx.Hash(), "recipients", len(peers))
}
for peer, txs := range txset {
peer.AsyncSendTransactions(txs)
}
}
func (pm *ProtocolManager) InShardBroadcastTx(tx *types.Transaction) {
peers := pm.peerPool.PM().GetPeers(pm.coreCache.ShardID)
if peers == nil {
return
}
for _, p := range peers {
peer, ok := convert(p)
if ok {
peer.AsyncSendTransaction(tx)
}
}
}
func (pm *ProtocolManager) CrossShardRelayTx(tx *types.Transaction, whereToGo uint32) {
p := pm.peerPool.PM().GetRandom(whereToGo)
if p == nil {
return
}
peer, ok := convert(p)
if !ok {
return
}
peer.AsyncSendTransaction(tx)
}
func (pm *ProtocolManager) txBroadcastLoop() {
lastMakeListTime := time.Now()
for {
select {
case event := <-pm.txsCh:
for _, tx := range event.Txs {
if tx.ShardId == pm.coreCache.ShardID {
pm.InShardBroadcastTx(tx)
} else {
pm.CrossShardRelayTx(tx, tx.ShardId)
}
pm.CrossShardRelayTx(tx, tx.GetOutputRelatedShardIdx())
pm.coreCache.CacheTxs = append(pm.coreCache.CacheTxs, tx)
fmt.Println("length of CacheTxs :", len(pm.coreCache.CacheTxs))
}
case <-time.After(time.Microsecond * 100):
if pm.coreCache.Role == leader {
if len(pm.coreCache.CacheTxs) >= gVar.MaxNumTxsAllowedInTXL || time.Now().After(lastMakeListTime.Add(30*time.Second)) {
if len(pm.coreCache.TxListGoroutineTokens) == 0 {
time.Sleep(time.Second * 5)
} else {
pm.makeTxList()
lastMakeListTime = time.Now()
}
}
}
case <-pm.txsSub.Err():
return
}
}
}
func (pm *ProtocolManager) HandleTxList(txl *types.TxList) error {
statusCheck := types.StatusCheck{UnknownTxNum: gVar.INITTIAL_STATUS, Valid: nil}
pm.PreprocessTxList(txl, &statusCheck)
txldec, err := pm.makeTransactionListDecision(txl)
if err == nil {
pm.sendTransactionListDecision(txldec)
}
return nil
}
func (pm *ProtocolManager) PreprocessTxList(txl *types.TxList,
statuscheck *types.StatusCheck) error {
if statuscheck == nil {
return fmt.Errorf("statuscheck is nil")
}
if statuscheck.UnknownTxNum == gVar.INITTIAL_STATUS {
p := pm.peerPool.PM().GetLeader(pm.coreCache.ShardID)
peer, ok := convert(p)
if ok && peer.InShardID != txl.SenderInShardID {
return fmt.Errorf("PreTxList: Txlist from a miner")
}
if int(txl.TxCnt) != len(txl.TxArray) {
return fmt.Errorf("PreTxList: Number of Tx wrong")
}
statuscheck.UnknownTxNum = int(txl.TxCnt)
statuscheck.Valid = make([]int, txl.TxCnt)
txl.TxArray = make([]common.Hash, txl.TxCnt)
for i := uint32(0); i < txl.TxCnt; i++ {
_, ok := pm.coreCache.TxHashCache[txl.TxArray[i]]
if !ok {
tmpWait, okW := pm.coreCache.WaitHashCache[txl.TxArray[i]]
if okW {
tmpWait.DataTL = append(tmpWait.DataTL, txl)
tmpWait.StatTL = append(tmpWait.StatTL, statuscheck)
tmpWait.IDTL = append(tmpWait.IDTL, int(i))
} else {
tmpWait = shard.WaitProcess{nil, nil, nil, nil, nil, nil, nil, nil, nil}
tmpWait.DataTL = append(tmpWait.DataTL, txl)
tmpWait.StatTL = append(tmpWait.StatTL, statuscheck)
tmpWait.IDTL = append(tmpWait.IDTL, int(i))
}
pm.coreCache.WaitHashCache[txl.TxArray[i]] = tmpWait
} else {
statuscheck.UnknownTxNum--
tmp := pm.coreCache.CacheXshardDecs.Get(txl.TxArray[i])
if tmp == nil {
fmt.Println("TXcache not ok! hash:", txl.TxArray[i])
} else if tmp.Data == nil {
fmt.Println("Tx Data is null")
}
statuscheck.Valid[i] = gVar.TX_KNOWN
}
}
}
if statuscheck.UnknownTxNum > 0 {
statuscheck.Channel = make(chan bool, statuscheck.UnknownTxNum)
}
return nil
}
func (pm *ProtocolManager) makeTxList() {
<-pm.coreCache.TxListGoroutineTokens
pm.coreCache.Mutx.Lock()
tlg, _ := pm.NewTLGInstance()
for _, tx := range pm.coreCache.CacheTxs {
tmpXsd := pm.coreCache.CacheXshardDecs.Get(tx.GetHash())
ok := yes
if tmpXsd == nil {
ok = no
tmpXsd = new(types.CrossShardDec)
tmpXsd.New(tx)
} else {
tmpXsd.Update(tx)
}
// still unknown
if tmpXsd.Check[pm.coreCache.ShardID] == gVar.DECISION_UNKNOWN {
if ok == yes {
pm.coreCache.CacheXshardDecs.Delete(tx.GetHash())
}
// not related tx, continue
continue
}
if tmpXsd.Res == gVar.RESULT_YES {
pm.coreCache.Ready = append(pm.coreCache.Ready, *tmpXsd.Data)
}
// record
pm.coreCache.CacheXshardDecs.Set(tx.GetHash(), tmpXsd)
// add tx to related list, the tls[i] will only contains txs related to the same shard
for _, i := range tmpXsd.ShardRelated {
tlg.TLS[i].AddTx(tx)
}
ch := make(chan uint32, gVar.ShardSize)
pm.coreCache.TxlDeChanMap.Set(tlg.TLS[0].Round, ch)
}
pm.coreCache.TxListGroupPool <- tlg
pm.coreCache.Mutx.Unlock()
// reset the cache
if len(pm.coreCache.CacheTxs) != 0 {
pm.coreCache.CacheTxs = make([]*types.Transaction, 0)
}
}
// generate a new TLG
func (pm *ProtocolManager) NewTLGInstance() (*shard.TLGroup, error) {
inst := new(shard.TLGroup)
pm.coreCache.TLRoundLock.Lock()
for i := uint32(0); i < gVar.ShardCnt; i++ {
inst.TDS[i] = new(types.TxDecSet)
inst.TLS[i] = new(types.TxList)
inst.TLS[i].SenderInShardID = pm.coreCache.ShardID
inst.TLS[i].Round = pm.coreCache.TLRound
pm.coreCache.TLRound++
}
pm.coreCache.TLRoundLock.Unlock()
return inst, nil
}
func (pm *ProtocolManager) makeTransactionListDecision(txl *types.TxList) (*types.TransactionListDecision, error) {
pm.coreCache.TLRoundLock.Lock()
txldec := new(types.TransactionListDecision)
txldec.Set(pm.coreCache.InShardID, pm.coreCache.ShardID, true)
txldec.TxlistHash = txl.HashID
pm.coreCache.TxCnt += txl.TxCnt
var tmpDecision [gVar.ShardCnt]types.TransactionListDecision
for i := uint32(0); i < gVar.ShardCnt; i++ {
tmpDecision[i].Set(pm.coreCache.InShardID, i, false)
}
for _, hash := range txl.TxArray {
// if the hash is found in map
for {
pm.coreCache.CacheTxsRWLock.RLock()
xsd := pm.coreCache.CacheXshardDecs.Get(hash)
if xsd != nil {
var res byte
if xsd.Check[pm.coreCache.ShardID] == gVar.DECISION_RELATED_NO_RES {
if true {
res = byte(1)
}
txldec.Add(res)
for j := 0; j < len(xsd.ShardRelated); j++ {
tmpDecision[xsd.ShardRelated[j]].Add(res)
}
}
pm.coreCache.CacheTxsRWLock.RUnlock()
break
} else {
txldec.Add(0)
pm.coreCache.CacheTxsRWLock.RUnlock()
}
time.Sleep(time.Millisecond * 20)
}
}
for i := uint32(0); i < gVar.ShardCnt; i++ {
tmpDecision[i].SignTxListDec(pm.coreCache.Prikey, 0)
txldec.Sigs[i] = tmpDecision[i].Sigs[0]
}
pm.coreCache.TLRound++
pm.coreCache.TLRoundLock.Unlock()
return txldec, nil
}
// shard member sends transaction list decision
func (pm *ProtocolManager) sendTransactionListDecision(txldec *types.TransactionListDecision) {
if txldec != nil {
p := pm.peerPool.PM().GetLeader(pm.coreCache.ShardID)
if p != nil {
peer, ok := convert(p)
if ok {
peer.SendTransactionListDecision(txldec)
}
}
}
}
// handle txlist decision coming from shard members
func (pm *ProtocolManager) HandleDecByLeader() {
var listSequence uint32
txldec := <-pm.coreCache.TxlDecRecvCh
pm.UpdateDecSetByLeader(txldec, &listSequence)
tC := pm.coreCache.TxlDeChanMap.Get(listSequence)
if tC != nil {
tC <- txldec.SenderInShardID
}
}
func (pm *ProtocolManager) UpdateDecSetByLeader(txldec *types.TransactionListDecision,
sequence *uint32) error {
if txldec.MultiShardsSigFlag == false {
return fmt.Errorf("TxDecision parameter error")
}
tmpTLG, ok := pm.coreCache.TlgMap[txldec.TxlistHash]
if !ok {
//index = nil
return fmt.Errorf("TxDecision Hash error, wrong or time out")
}
*sequence = tmpTLG.TLS[pm.coreCache.ShardID].Round - pm.coreCache.PrevHeight
tmpTDs := make([]types.TransactionListDecision, gVar.ShardCnt)
for i := uint32(0); i < gVar.ShardCnt; i++ {
tmpTDs[i].Set(0, i, false)
tmpTDs[i].TxlistHash = tmpTLG.TLS[i].HashID
tmpTDs[i].Sigs = nil
tmpTDs[i].Sigs = append(tmpTDs[i].Sigs, txldec.Sigs[i])
}
var x, y uint32 = 0, 0
for i := uint32(0); i < tmpTLG.TLS[pm.coreCache.ShardID].TxCnt; i++ {
tmpCrossShardDec := pm.coreCache.CacheXshardDecs.Get(tmpTLG.TLS[pm.coreCache.ShardID].TxArray[i])
if tmpCrossShardDec == nil {
fmt.Println("Not related tx?")
}
for j := 0; j < len(tmpCrossShardDec.ShardRelated); j++ {
tmpTDs[tmpCrossShardDec.ShardRelated[j]].Add((txldec.Decision[x] >> y) & 1)
}
if y < 7 {
y++
} else {
x++
y = 0
}
}
for i := uint32(0); i < gVar.ShardCnt; i++ {
var pukTheOneWhoOffersTxDec []byte
if !tmpTDs[i].VerifyTxListDec(pukTheOneWhoOffersTxDec, 0) {
return fmt.Errorf("Signature not match %d", i)
}
}
for i := uint32(0); i < gVar.ShardCnt; i++ {
tmpTLG.TDS[i].AddDecision(&tmpTDs[i])
}
return nil
}
// get object from interface
func convert(in interface{}) (*peer, bool) {
p, ok := in.(*peer)
return p, ok
}
|
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
//
package aws
import (
"context"
"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
)
// SecretsManagerAPI represents the series of calls we require from the AWS SDK v2 SecretsManager Client
type SecretsManagerAPI interface {
CreateSecret(ctx context.Context, params *secretsmanager.CreateSecretInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.CreateSecretOutput, error)
DeleteSecret(ctx context.Context, params *secretsmanager.DeleteSecretInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.DeleteSecretOutput, error)
RestoreSecret(ctx context.Context, params *secretsmanager.RestoreSecretInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.RestoreSecretOutput, error)
GetSecretValue(ctx context.Context, params *secretsmanager.GetSecretValueInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.GetSecretValueOutput, error)
}
|
package main
import (
"log"
"os"
"github.com/w-zengtao/socket-server/api"
"github.com/w-zengtao/socket-server/models"
"github.com/w-zengtao/socket-server/sockets"
"github.com/w-zengtao/socket-server/sources"
)
func init() {
log.SetOutput(os.Stdout)
}
var (
forever = make(chan bool)
)
func main() {
manager := sockets.NewManger()
models.Managers = append(models.Managers, manager)
go api.Run(manager)
go sources.RunRabbit(manager)
go sources.RunRedis(manager)
go manager.Exec()
models.Init()
<-forever
}
|
package dbs
import (
json "cjson/qson"
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
type DB struct {
WriteDB *sql.DB
ReadDB *sql.DB
}
func getDB(dbName string, url string) *sql.DB {
db, err := sql.Open(dbName, url)
if err != nil {
fmt.Println("数据库连接异常...", err)
}
db.SetMaxIdleConns(1)
db.SetMaxOpenConns(1)
return db
}
func (db *DB) Init(dbType string, url string) {
db.ReadDB = getDB(dbType, url)
db.WriteDB = db.ReadDB
}
func (db *DB) ReadDb(dbName string, url string) {
db.ReadDB = getDB(dbName, url)
}
func (db *DB) WriteDb(dbName string, url string) {
db.WriteDB = getDB(dbName, url)
}
func (db *DB) _Query(_sql string, array json.JSONArray) *json.JSONArray {
return db.Query(_sql, array.ToArray()...)
}
func (db *DB) Query(_sql string, param ...interface{}) *json.JSONArray {
var row *sql.Rows
var err error
if param == nil {
row, err = db.ReadDB.Query(_sql)
} else {
row, err = db.ReadDB.Query(_sql, param)
}
if err != nil {
fmt.Println(err)
}
defer row.Close()
cols, _ := row.Columns()
len := len(cols)
val := make([]interface{}, len)
scans := make([]interface{}, len)
for k, _ := range val {
scans[k] = &val[k]
}
result := json.NewJSONArray()
for row.Next() {
row.Scan(scans...)
_r := json.NewJSONObject()
for k, v := range val {
key := cols[k]
b, _ := v.([]byte)
_r.PutString(key, string(b))
}
result.Add(_r)
}
return result
}
func (db *DB) Exec(_sql string, param ...interface{}) (sql.Result, error) {
var (
r sql.Result
e error
)
if param == nil {
r, e = db.WriteDB.Exec(_sql)
} else {
r, e = db.WriteDB.Exec(_sql, param)
}
return r, e
}
func (db *DB) _Exec(sql string, array json.JSONArray) (sql.Result, error) {
return db.Exec(sql, array.ToArray()...)
}
func (db *DB) Insert(_sql string, array json.JSONArray) (int64, error) {
var (
r sql.Result
)
if array.IsEmpty() {
r, _ = db.Exec(_sql, nil)
} else {
r, _ = db.Exec(_sql, array.ToArray()...)
}
return r.LastInsertId()
}
func (db *DB) BatchExec(array []string) bool {
tx, err := db.WriteDB.Begin()
if err != nil {
fmt.Println("执行批处理异常！", err)
return false
}
for _, v := range array {
_, e := tx.Exec(v)
if e != nil {
tx.Rollback()
return false
}
}
tx.Commit()
return true
}
|
package dynamicstruct
import (
"errors"
"reflect"
"github.com/goldeneggg/structil/util"
)
const (
capBuilderField = 10
defaultStructName = "DynamicStruct"
// SampleString is sample string value
SampleString = ""
// SampleInt is sample int value
SampleInt = int(1)
// SampleByte is sample byte value
SampleByte = byte(1)
// SampleFloat32 is sample float32 value
SampleFloat32 = float32(1.1)
// SampleFloat64 is sample float64 value
SampleFloat64 = float64(1.1)
// SampleBool is sample bool value
SampleBool = false
)
var (
// ErrSample is sample init error value
ErrSample = errors.New("SampleError")
)
// Builder is the interface that builds a dynamic and runtime struct.
type Builder struct {
name string
bfMap builderFieldMap
err error
}
// NewBuilder returns a concrete Builder
func NewBuilder() *Builder {
return &Builder{
name: defaultStructName,
bfMap: make(builderFieldMap),
}
}
type builderField struct {
name string
typ reflect.Type
tag reflect.StructTag
}
type builderFieldMap map[string]*builderField
func (b *Builder) getFieldMap(key string) *builderField {
r := b.bfMap[key]
return r
}
func (b *Builder) putFieldMap(key string, bf *builderField) {
b.bfMap[key] = bf
}
func (b *Builder) deleteFieldMap(key string) {
delete(b.bfMap, key)
}
func (b *Builder) hasFieldMap(key string) bool {
_, ok := b.bfMap[key]
return ok
}
func (b *Builder) lenFieldMap() int {
return len(b.bfMap)
}
func (b *Builder) addFieldFunc(name string, isPtr bool, tag string, f func() reflect.Type) *Builder {
defer func() {
err := util.RecoverToError(recover())
// keep 1st recoverd error
if err != nil && b.err == nil {
b.err = err
}
}()
typ := f()
if isPtr {
typ = reflect.PtrTo(typ)
}
b.putFieldMap(name, &builderField{
name: name,
typ: typ,
tag: reflect.StructTag(tag),
})
return b
}
// AddString returns a Builder that was added a string field named by name parameter.
func (b *Builder) AddString(name string) *Builder {
b.AddStringWithTag(name, "")
return b
}
// AddStringWithTag returns a Builder that was added a string field with tag named by name parameter.
func (b *Builder) AddStringWithTag(name string, tag string) *Builder {
f := func() reflect.Type {
return reflect.TypeOf(SampleString)
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddInt returns a Builder that was added a int field named by name parameter.
func (b *Builder) AddInt(name string) *Builder {
b.AddIntWithTag(name, "")
return b
}
// AddIntWithTag returns a Builder that was added a int field with tag named by name parameter.
func (b *Builder) AddIntWithTag(name string, tag string) *Builder {
f := func() reflect.Type {
return reflect.TypeOf(SampleInt)
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddByte returns a Builder that was added a byte field named by name parameter.
func (b *Builder) AddByte(name string) *Builder {
b.AddByteWithTag(name, "")
return b
}
// AddByteWithTag returns a Builder that was added a byte field with tag named by name parameter.
func (b *Builder) AddByteWithTag(name string, tag string) *Builder {
f := func() reflect.Type {
return reflect.TypeOf(SampleByte)
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddFloat32 returns a Builder that was added a float32 field named by name parameter.
func (b *Builder) AddFloat32(name string) *Builder {
b.AddFloat32WithTag(name, "")
return b
}
// AddFloat32WithTag returns a Builder that was added a float32 field with tag named by name parameter.
func (b *Builder) AddFloat32WithTag(name string, tag string) *Builder {
f := func() reflect.Type {
return reflect.TypeOf(SampleFloat32)
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddFloat64 returns a Builder that was added a float64 field named by name parameter.
func (b *Builder) AddFloat64(name string) *Builder {
b.AddFloat64WithTag(name, "")
return b
}
// AddFloat64WithTag returns a Builder that was added a float64 field with tag named by name parameter.
func (b *Builder) AddFloat64WithTag(name string, tag string) *Builder {
f := func() reflect.Type {
return reflect.TypeOf(SampleFloat64)
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddBool returns a Builder that was added a bool field named by name parameter.
func (b *Builder) AddBool(name string) *Builder {
b.AddBoolWithTag(name, "")
return b
}
// AddBoolWithTag returns a Builder that was added a bool field with tag named by name parameter.
func (b *Builder) AddBoolWithTag(name string, tag string) *Builder {
f := func() reflect.Type {
return reflect.TypeOf(SampleBool)
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddMap returns a Builder that was added a map field named by name parameter.
// Type of map key is type of ki.
// Type of map value is type of vi.
func (b *Builder) AddMap(name string, ki interface{}, vi interface{}) *Builder {
b.AddMapWithTag(name, ki, vi, "")
return b
}
// AddMapWithTag returns a Builder that was added a map field with tag named by name parameter.
// Type of map key is type of ki.
// Type of map value is type of vi.
func (b *Builder) AddMapWithTag(name string, ki interface{}, vi interface{}, tag string) *Builder {
f := func() reflect.Type {
var vt reflect.Type
if vi == nil {
vt = reflect.TypeOf((*interface{})(nil)).Elem()
} else {
vt = reflect.TypeOf(vi)
}
return reflect.MapOf(reflect.TypeOf(ki), vt)
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddFunc returns a Builder that was added a func field named by name parameter.
// Types of func args are types of in.
// Types of func returns are types of out.
func (b *Builder) AddFunc(name string, in []interface{}, out []interface{}) *Builder {
b.AddFuncWithTag(name, in, out, "")
return b
}
// AddFuncWithTag returns a Builder that was added a func field with tag named by name parameter.
// Types of func args are types of in.
// Types of func returns are types of out.
func (b *Builder) AddFuncWithTag(name string, in []interface{}, out []interface{}, tag string) *Builder {
f := func() reflect.Type {
it := make([]reflect.Type, len(in))
for i := 0; i < len(in); i++ {
it[i] = reflect.TypeOf(in[i])
}
ot := make([]reflect.Type, len(out))
for i := 0; i < len(out); i++ {
ot[i] = reflect.TypeOf(out[i])
}
return reflect.FuncOf(it, ot, false)
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddChanBoth returns a Builder that was added a BothDir chan field named by name parameter.
// Type of chan is type of i.
func (b *Builder) AddChanBoth(name string, i interface{}) *Builder {
b.AddChanBothWithTag(name, i, "")
return b
}
// AddChanBothWithTag returns a Builder that was added a BothDir chan field with tag named by name parameter.
// Type of chan is type of i.
func (b *Builder) AddChanBothWithTag(name string, i interface{}, tag string) *Builder {
f := func() reflect.Type {
return reflect.ChanOf(reflect.BothDir, reflect.TypeOf(i))
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddChanRecv returns a Builder that was added a RecvDir chan field named by name parameter.
// Type of chan is type of i.
func (b *Builder) AddChanRecv(name string, i interface{}) *Builder {
b.AddChanRecvWithTag(name, i, "")
return b
}
// AddChanRecvWithTag returns a Builder that was added a RecvDir chan field with tag named by name parameter.
// Type of chan is type of i.
func (b *Builder) AddChanRecvWithTag(name string, i interface{}, tag string) *Builder {
f := func() reflect.Type {
return reflect.ChanOf(reflect.RecvDir, reflect.TypeOf(i))
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddChanSend returns a Builder that was added a SendDir chan field named by name parameter.
// Type of chan is type of i.
func (b *Builder) AddChanSend(name string, i interface{}) *Builder {
b.AddChanSendWithTag(name, i, "")
return b
}
// AddChanSendWithTag returns a Builder that was added a SendDir chan field with tag named by name parameter.
// Type of chan is type of i.
func (b *Builder) AddChanSendWithTag(name string, i interface{}, tag string) *Builder {
f := func() reflect.Type {
return reflect.ChanOf(reflect.SendDir, reflect.TypeOf(i))
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddStruct returns a Builder that was added a struct field named by name parameter.
// Type of struct is type of i.
func (b *Builder) AddStruct(name string, i interface{}, isPtr bool) *Builder {
b.AddStructWithTag(name, i, isPtr, "")
return b
}
// AddStructWithTag returns a Builder that was added a struct field with tag named by name parameter.
// Type of struct is type of i.
func (b *Builder) AddStructWithTag(name string, i interface{}, isPtr bool, tag string) *Builder {
f := func() reflect.Type {
iType := reflect.TypeOf(i)
if iType.Kind() == reflect.Ptr {
iType = iType.Elem()
}
fields := make([]reflect.StructField, iType.NumField())
for i := 0; i < iType.NumField(); i++ {
fields[i] = iType.Field(i)
}
return reflect.StructOf(fields)
}
b.addFieldFunc(name, isPtr, tag, f)
return b
}
// AddStructPtr returns a Builder that was added a struct pointer field named by name parameter.
// Type of struct is type of i.
func (b *Builder) AddStructPtr(name string, i interface{}) *Builder {
return b.AddStruct(name, i, true)
}
// AddStructPtrWithTag returns a Builder that was added a struct pointer field with tag named by name parameter.
// Type of struct is type of i.
func (b *Builder) AddStructPtrWithTag(name string, i interface{}, tag string) *Builder {
return b.AddStructWithTag(name, i, true, tag)
}
// AddSlice returns a Builder that was added a slice field named by name parameter.
// Type of slice is type of i.
func (b *Builder) AddSlice(name string, i interface{}) *Builder {
b.AddSliceWithTag(name, i, "")
return b
}
// AddSliceWithTag returns a Builder that was added a slice field with tag named by name parameter.
// Type of slice is type of i.
func (b *Builder) AddSliceWithTag(name string, i interface{}, tag string) *Builder {
f := func() reflect.Type {
return reflect.SliceOf(reflect.TypeOf(i))
}
b.addFieldFunc(name, false, tag, f)
return b
}
// AddInterface returns a Builder that was added a interface{} field named by name parameter.
func (b *Builder) AddInterface(name string, isPtr bool) *Builder {
b.AddInterfaceWithTag(name, isPtr, "")
return b
}
// AddInterfaceWithTag returns a Builder that was added a interface{} field with tag named by name parameter.
func (b *Builder) AddInterfaceWithTag(name string, isPtr bool, tag string) *Builder {
f := func() reflect.Type {
return reflect.TypeOf((*interface{})(nil)).Elem()
}
b.addFieldFunc(name, isPtr, tag, f)
return b
}
// AddDynamicStruct returns a Builder that was added a DynamicStruct field named by name parameter.
func (b *Builder) AddDynamicStruct(name string, ds *DynamicStruct, isPtr bool) *Builder {
b.AddDynamicStructWithTag(name, ds, isPtr, "")
return b
}
// AddDynamicStructWithTag returns a Builder that was added a DynamicStruct field with tag named by name parameter.
func (b *Builder) AddDynamicStructWithTag(name string, ds *DynamicStruct, isPtr bool, tag string) *Builder {
b.AddStructWithTag(name, ds.NewInterface(), isPtr, tag)
return b
}
// AddDynamicStructPtr returns a Builder that was added a DynamicStruct pointer field named by name parameter.
func (b *Builder) AddDynamicStructPtr(name string, ds *DynamicStruct) *Builder {
return b.AddDynamicStruct(name, ds, true)
}
// AddDynamicStructPtrWithTag returns a Builder that was added a DynamicStruct pointer field with tag named by name parameter.
func (b *Builder) AddDynamicStructPtrWithTag(name string, ds *DynamicStruct, tag string) *Builder {
return b.AddDynamicStructWithTag(name, ds, true, tag)
}
// AddDynamicStructSlice returns a Builder that was added a DynamicStruct slice field named by name parameter.
func (b *Builder) AddDynamicStructSlice(name string, ds *DynamicStruct) *Builder {
return b.AddDynamicStructSliceWithTag(name, ds, "")
}
// AddDynamicStructSliceWithTag returns a Builder that was added a DynamicStruct slice field with tag named by name parameter.
func (b *Builder) AddDynamicStructSliceWithTag(name string, ds *DynamicStruct, tag string) *Builder {
b.AddSliceWithTag(name, ds.NewInterface(), tag)
return b
}
// NumField returns the number of built struct fields.
func (b *Builder) NumField() int {
return b.lenFieldMap()
}
// Exists returns true if the specified name field exists
func (b *Builder) Exists(name string) bool {
return b.hasFieldMap(name)
}
// GetStructName returns the name of this DynamicStruct.
func (b *Builder) GetStructName() string {
return b.name
}
// SetStructName returns a Builder that was set the name of DynamicStruct.
// Default name is "DynamicStruct"
func (b *Builder) SetStructName(name string) *Builder {
b.name = name
return b
}
// GetTag returns the tag of the specified name field.
func (b *Builder) GetTag(name string) string {
if b.hasFieldMap(name) {
return string(b.getFieldMap(name).tag)
}
return ""
}
// SetTag returns a Builder that was set the tag for the specific field.
// Expected tag string is 'TYPE1:"FIELDNAME1" TYPEn:"FIELDNAMEn"' format (e.g. json:"id" etc)
func (b *Builder) SetTag(name string, tag string) *Builder {
if b.hasFieldMap(name) {
b.getFieldMap(name).tag = reflect.StructTag(tag)
}
return b
}
// Remove returns a Builder that was removed a field named by name parameter.
func (b *Builder) Remove(name string) *Builder {
b.deleteFieldMap(name)
return b
}
// Build returns a concrete struct pointer built by Builder.
func (b *Builder) Build() (*DynamicStruct, error) {
return b.build(true)
}
// BuildNonPtr returns a concrete struct built by Builder.
func (b *Builder) BuildNonPtr() (*DynamicStruct, error) {
return b.build(false)
}
func (b *Builder) build(isPtr bool) (ds *DynamicStruct, err error) {
if b.err != nil {
err = b.err
return
}
var i int
// DON'T use b.lenFieldMap() method because of dead lock
fields := make([]reflect.StructField, len(b.bfMap))
for key, bf := range b.bfMap {
fields[i] = reflect.StructField{
Name: key,
Type: bf.typ,
Tag: bf.tag,
}
i++
}
ds, err = newDynamicStruct(fields, isPtr, b.GetStructName())
return
}
|
package users
import (
"errors"
"fmt"
"net/mail"
"strings"
"github.com/globalsign/mgo/bson"
"golang.org/x/crypto/bcrypt"
)
var bcryptCost = 13
//User represents a user account in the database
type User struct {
ID bson.ObjectId `json:"id" bson:"_id"`
Email string `json:"email"`
PassHash []byte `json:"-"` //stored, but not encoded to clients
FirstName string `json:"firstName"`
LastName string `json:"lastName"`
}
//Credentials represents user sign-in credentials
type Credentials struct {
Email string `json:"email"`
Password string `json:"password"`
}
//NewUser represents a new user signing up for an account
type NewUser struct {
Email string `json:"email"`
Password string `json:"password"`
PasswordConf string `json:"passwordConf"`
FirstName string `json:"firstName"`
LastName string `json:"lastName"`
}
func (nu *NewUser) Validate() error {
if _, err := mail.ParseAddress(nu.Email); err != nil {
return fmt.Errorf("%v %v", invalidEmailError, nu.Email)
}
if len(nu.FirstName) == 0 {
return errors.New(emptyFirstNameError)
}
if len(nu.LastName) == 0 {
return errors.New(emptyLastNameError)
}
if len(nu.Password) < 6 {
return fmt.Errorf("%v %v", newPasswordLengthError, len(nu.Password))
}
if nu.Password != nu.PasswordConf {
return errors.New(newPasswordConfError)
}
return nil
}
func (nu *NewUser) ToUser() (*User, error) {
if err := nu.Validate(); err != nil {
return nil, err
}
email := strings.TrimSpace(nu.Email)
email = strings.ToLower(email)
usr := User{
ID: bson.NewObjectId(),
Email: email,
FirstName: nu.FirstName,
LastName: nu.LastName,
}
if err := usr.SetPassword(nu.Password); err != nil {
return nil, err
}
return &usr, nil
}
func (u *User) FullName() string {
return strings.Trim(u.FirstName+" "+u.LastName, " ")
}
func (u *User) SetPassword(password string) error {
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcryptCost)
if err != nil {
return fmt.Errorf("%v %v", passwordHashError, err)
}
u.PassHash = hash
return nil
}
func (u *User) Authenticate(password string) error {
if err := bcrypt.CompareHashAndPassword(u.PassHash, []byte(password)); err != nil {
return errors.New(authenticationFailure)
}
return nil
} |
package cmd
import (
"fmt"
"github.com/ddspog/doni/project"
"github.com/spf13/cobra"
)
// versionCmd represents the version command
var versionCmd = &cobra.Command{
Use: "version",
Short: "Print the version of Hugo",
Long: `All softwares has versions. This is doni's`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("dino experiment tool v" + project.Version())
},
}
func init() {
rootCmd.AddCommand(versionCmd)
}
|
package main
func minCut(s string) int {
n := len(s)
dp := make([]int, n+1)
dp[0] = -1
for i := 1; i <= n; i++ {
dp[i] = i
for j := 0; j < i; j++ {
if isPal(s, j, i-1) {
dp[i] = Min(dp[j]+1, dp[i])
}
}
}
return dp[n]
}
func isPal(s string, l, r int) bool {
for l < r {
if s[l] != s[r] {
return false
}
l++
r--
}
return true
}
func Min(x, y int) int {
if x < y {
return x
}
return y
}
func main() {
println(minCut("abac"))
}
|
package activity
import (
"github.com/gin-gonic/gin"
"net/http"
"xj_web_server/httpserver/servermiddleware"
"xj_web_server/model"
"xj_web_server/module"
"xj_web_server/util"
)
type ActivityReq struct {
servermiddleware.BaseReq
Number int `form:"number" json:"number"` //分页数
Page int `from:"page" json:"page"` //当前页
}
type ActivityResp struct {
Total int `json:"total"` //总数
CurrentPage int `json:"current_page"` //当前页
List []model.Activity `json:"list"` //活动列表
}
func ActivityList(c *gin.Context) {
var baseReq ActivityReq
err := c.ShouldBindJSON(&baseReq)
if err != nil {
util.Logger.Errorf("ActivityList 接口 参数绑定 出错 err: %s ", err.Error())
c.JSON(http.StatusOK, module.ApiResp{ErrorNo: util.ErrorLackCode, ErrorMsg: err.Error()})
return
}
// todo: 获取活动信息 分页
var resp ActivityResp
resp.List, resp.Total, resp.CurrentPage, err = model.GetActivityByPaging(baseReq.Number, baseReq.Page)
if err != nil {
util.Logger.Errorf("ActivityList 接口 sql查询 出错 err: %s ", err.Error())
c.JSON(http.StatusOK, module.ApiResp{ErrorNo: util.ErrorSqlCode, ErrorMsg: err.Error()})
return
}
c.JSON(http.StatusOK, module.ApiResp{ErrorNo: util.SuccessCode, Data: resp})
}
|
package function
import (
"testing"
)
func Test_isPossible(t *testing.T) {
type args struct {
x int
}
tests := []struct {
name string
args args
want int
}{
{"test1", args{111111}, 1},
{"test2", args{122345}, 1},
{"test3", args{223450}, 0},
{"test4", args{123789}, 0},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := isPossible(tt.args.x); got != tt.want {
t.Errorf("isPossible() = %v, want %v", got, tt.want)
}
})
}
}
func Test_isPossible2(t *testing.T) {
type args struct {
x int
}
tests := []struct {
name string
args args
want int
}{
{"test1", args{112233}, 1},
{"test2", args{123444}, 0},
{"test3", args{111122}, 1},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := isPossible2(tt.args.x); got != tt.want {
t.Errorf("isPossible2(%d) = %v, want %v", tt.args.x, got, tt.want)
}
})
}
}
func Test_getPossible(t *testing.T) {
type args struct {
start int
end int
}
tests := []struct {
name string
args args
want int
}{
{"test1", args{111000, 111222}, 46},
{"test2", args{111111, 111111}, 1},
{"test3", args{223450, 223455}, 1},
{"test4", args{223450, 223454}, 0},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := getPossible(tt.args.start, tt.args.end, isPossible); got != tt.want {
t.Errorf("getPossible() = %v, want %v", got, tt.want)
}
})
}
} |
package routers
import (
"github.com/astaxie/beego"
"github.com/astaxie/beego/context/param"
)
func init() {
beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"] = append(beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"] = append(beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"] = append(beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"] = append(beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"] = append(beego.GlobalControllerRouter["Android-api/controllers:Barcode2Controller"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutriMeterialController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDietnutricrawlController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChDrisController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChineseFoodGroupController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodgoodsnutriController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutriController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesefoodnutrifromhkController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"] = append(beego.GlobalControllerRouter["Android-api/controllers:ChinesevegetableController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:CookbookController"] = append(beego.GlobalControllerRouter["Android-api/controllers:CookbookController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:CookbookController"] = append(beego.GlobalControllerRouter["Android-api/controllers:CookbookController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:CookbookController"] = append(beego.GlobalControllerRouter["Android-api/controllers:CookbookController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:CookbookController"] = append(beego.GlobalControllerRouter["Android-api/controllers:CookbookController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:CookbookController"] = append(beego.GlobalControllerRouter["Android-api/controllers:CookbookController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:DeliciousFoodInfoController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodDataController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodfrombhcpController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsafenewsController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodsecurityfromzccwController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:FoodvideoController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"] = append(beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"] = append(beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"] = append(beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"] = append(beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"] = append(beego.GlobalControllerRouter["Android-api/controllers:KitchenstroriesController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"] = append(beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"] = append(beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"] = append(beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"] = append(beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"] = append(beego.GlobalControllerRouter["Android-api/controllers:Media2WebController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"] = append(beego.GlobalControllerRouter["Android-api/controllers:MediaVideoController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:NewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:NewsController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:NewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:NewsController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:NewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:NewsController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:NewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:NewsController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:NewsController"] = append(beego.GlobalControllerRouter["Android-api/controllers:NewsController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SportsDataController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"] = append(beego.GlobalControllerRouter["Android-api/controllers:SporttypeController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"],
beego.ControllerComments{
Method: "Get",
Router: `/v1/:Mobile`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserBasicController"],
beego.ControllerComments{
Method: "Update",
Router: `/v2/:Mobile/:oldpwd/:newpwd`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserGoalController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"],
beego.ControllerComments{
Method: "GetAll",
Router: `/`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"],
beego.ControllerComments{
Method: "GetOne",
Router: `/:id`,
AllowHTTPMethods: []string{"get"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"],
beego.ControllerComments{
Method: "Put",
Router: `/:id`,
AllowHTTPMethods: []string{"put"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"] = append(beego.GlobalControllerRouter["Android-api/controllers:UserMonitorController"],
beego.ControllerComments{
Method: "Delete",
Router: `/:id`,
AllowHTTPMethods: []string{"delete"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
}
|
package main
import "unicode"
//864. 获取所有钥匙的最短路径
//给定一个二维网格 grid ，其中：
//
//'.' 代表一个空房间
//'#' 代表一堵
//'@' 是起点
//小写字母代表钥匙
//大写字母代表锁
//我们从起点开始出发，一次移动是指向四个基本方向之一行走一个单位空间。我们不能在网格外面行走，也无法穿过一堵墙。如果途经一个钥匙，我们就把它捡起来。除非我们手里有对应的钥匙，否则无法通过锁。
//
//假设 k 为 钥匙/锁 的个数，且满足 1 <= k <= 6，字母表中的前 k 个字母在网格中都有自己对应的一个小写和一个大写字母。换言之，每个锁有唯一对应的钥匙，每个钥匙也有唯一对应的锁。另外，代表钥匙和锁的字母互为大小写并按字母顺序排列。
//
//返回获取所有钥匙所需要的移动的最少次数。如果无法获取所有钥匙，返回 -1 。
//
//
//
//示例 1：
//
//
//
//输入：grid = ["@.a.#","###.#","b.A.B"]
//输出：8
//解释：目标是获得所有钥匙，而不是打开所有锁。
//示例 2：
//
//
//
//输入：grid = ["@..aA","..B#.","....b"]
//输出：6
//示例 3:
//
//
//输入: grid = ["@Aa"]
//输出: -1
//
//
//提示：
//
//m == grid.length
//n == grid[i].length
//1 <= m, n <= 30
//grid[i][j] 只含有 '.', '#', '@', 'a'-'f' 以及 'A'-'F'
//钥匙的数目范围是 [1, 6]
//每个钥匙都对应一个 不同 的字母
//每个钥匙正好打开一个对应的锁
var dirs = []struct{ x, y int }{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}
func shortestPathAllKeys(grid []string) int {
m, n := len(grid), len(grid[0])
sx, sy := 0, 0
keyToIdx := map[rune]int{}
for i, row := range grid {
for j, c := range row {
if c == '@' {
sx, sy = i, j
} else if unicode.IsLower(c) {
if _, ok := keyToIdx[c]; !ok {
keyToIdx[c] = len(keyToIdx)
}
}
}
}
dist := make([][][]int, m)
for i := range dist {
dist[i] = make([][]int, n)
for j := range dist[i] {
dist[i][j] = make([]int, 1<<len(keyToIdx))
for k := range dist[i][j] {
dist[i][j][k] = -1
}
}
}
dist[sx][sy][0] = 0
q := [][3]int{{sx, sy, 0}}
for len(q) > 0 {
p := q[0]
q = q[1:]
x, y, mask := p[0], p[1], p[2]
for _, d := range dirs {
nx, ny := x+d.x, y+d.y
if 0 <= nx && nx < m && 0 <= ny && ny < n && grid[nx][ny] != '#' {
c := rune(grid[nx][ny])
if c == '.' || c == '@' {
if dist[nx][ny][mask] == -1 {
dist[nx][ny][mask] = dist[x][y][mask] + 1
q = append(q, [3]int{nx, ny, mask})
}
} else if unicode.IsLower(c) {
t := mask | 1<<keyToIdx[c]
if dist[nx][ny][t] == -1 {
dist[nx][ny][t] = dist[x][y][mask] + 1
if t == 1<<len(keyToIdx)-1 {
return dist[nx][ny][t]
}
q = append(q, [3]int{nx, ny, t})
}
} else {
idx := keyToIdx[unicode.ToLower(c)]
if mask>>idx&1 > 0 && dist[nx][ny][mask] == -1 {
dist[nx][ny][mask] = dist[x][y][mask] + 1
q = append(q, [3]int{nx, ny, mask})
}
}
}
}
}
return -1
}
|
// Package records contains functions to generate resource records from
// mesos master states to serve through a dns server
package records
import (
"crypto/sha1"
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"net"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"github.com/mesosphere/mesos-dns/errorutil"
"github.com/mesosphere/mesos-dns/logging"
"github.com/mesosphere/mesos-dns/records/labels"
"github.com/mesosphere/mesos-dns/records/state"
"github.com/tv42/zbase32"
)
// Map host/service name to DNS answer
// REFACTOR - when discoveryinfo is integrated
// Will likely become map[string][]discoveryinfo
type rrs map[string][]string
// RecordGenerator contains DNS records and methods to access and manipulate
// them. TODO(kozyraki): Refactor when discovery id is available.
type RecordGenerator struct {
As rrs
SRVs rrs
SlaveIPs map[string]string
httpClient http.Client
}
// NewRecordGenerator returns a RecordGenerator that's been configured with a timeout.
func NewRecordGenerator(httpTimeout time.Duration) *RecordGenerator {
rg := &RecordGenerator{httpClient: http.Client{Timeout: httpTimeout}}
return rg
}
// ParseState retrieves and parses the Mesos master /state.json and converts it
// into DNS records.
func (rg *RecordGenerator) ParseState(c Config, masters ...string) error {
// find master -- return if error
sj, err := rg.findMaster(masters...)
if err != nil {
logging.Error.Println("no master")
return err
}
if sj.Leader == "" {
logging.Error.Println("Unexpected error")
err = errors.New("empty master")
return err
}
hostSpec := labels.RFC1123
if c.EnforceRFC952 {
hostSpec = labels.RFC952
}
return rg.InsertState(sj, c.Domain, c.SOARname, c.Listener, masters, c.IPSources, hostSpec)
}
// Tries each master and looks for the leader
// if no leader responds it errors
func (rg *RecordGenerator) findMaster(masters ...string) (state.State, error) {
var sj state.State
var leader string
if len(masters) > 0 {
leader, masters = masters[0], masters[1:]
}
// Check if ZK leader is correct
if leader != "" {
logging.VeryVerbose.Println("Zookeeper says the leader is: ", leader)
ip, port, err := getProto(leader)
if err != nil {
logging.Error.Println(err)
}
if sj, err = rg.loadWrap(ip, port); err == nil && sj.Leader != "" {
return sj, nil
}
logging.Verbose.Println("Warning: Zookeeper is wrong about leader")
if len(masters) == 0 {
return sj, errors.New("no master")
}
logging.Verbose.Println("Warning: falling back to Masters config field: ", masters)
}
// try each listed mesos master before dying
for i, master := range masters {
ip, port, err := getProto(master)
if err != nil {
logging.Error.Println(err)
}
if sj, err = rg.loadWrap(ip, port); err == nil && sj.Leader == "" {
logging.VeryVerbose.Println("Warning: not a leader - trying next one")
if len(masters)-1 == i {
return sj, errors.New("no master")
}
} else {
return sj, nil
}
}
return sj, errors.New("no master")
}
// Loads state.json from mesos master
func (rg *RecordGenerator) loadFromMaster(ip string, port string) (state.State, error) {
// REFACTOR: state.json security
var sj state.State
u := url.URL{
Scheme: "http",
Host: net.JoinHostPort(ip, port),
Path: "/master/state.json",
}
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
logging.Error.Println(err)
return state.State{}, err
}
req.Header.Set("Content-Type", "application/json")
resp, err := rg.httpClient.Do(req)
if err != nil {
logging.Error.Println(err)
return state.State{}, err
}
defer errorutil.Ignore(resp.Body.Close)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
logging.Error.Println(err)
return state.State{}, err
}
err = json.Unmarshal(body, &sj)
if err != nil {
logging.Error.Println(err)
return state.State{}, err
}
return sj, nil
}
// Catches an attempt to load state.json from a mesos master
// attempts can fail from down server or mesos master secondary
// it also reloads from a different master if the master it attempted to
// load from was not the leader
func (rg *RecordGenerator) loadWrap(ip string, port string) (state.State, error) {
var err error
var sj state.State
logging.VeryVerbose.Println("reloading from master " + ip)
sj, err = rg.loadFromMaster(ip, port)
if err != nil {
return state.State{}, err
}
if rip := leaderIP(sj.Leader); rip != ip {
logging.VeryVerbose.Println("Warning: master changed to " + ip)
sj, err = rg.loadFromMaster(rip, port)
return sj, err
}
return sj, nil
}
// hashes a given name using a truncated sha1 hash
// 5 characters extracted from the zbase32 encoded hash provides
// enough entropy to avoid collisions
// zbase32: http://philzimmermann.com/docs/human-oriented-base-32-encoding.txt
// is used to promote human-readable names
func hashString(s string) string {
hash := sha1.Sum([]byte(s))
return zbase32.EncodeToString(hash[:])[:5]
}
// attempt to translate the hostname into an IPv4 address. logs an error if IP
// lookup fails. if an IP address cannot be found, returns the same hostname
// that was given. upon success returns the IP address as a string.
func hostToIP4(hostname string) (string, bool) {
ip := net.ParseIP(hostname)
if ip == nil {
t, err := net.ResolveIPAddr("ip4", hostname)
if err != nil {
logging.Error.Printf("cannot translate hostname %q into an ip4 address", hostname)
return hostname, false
}
ip = t.IP
}
return ip.String(), true
}
// InsertState transforms a StateJSON into RecordGenerator RRs
func (rg *RecordGenerator) InsertState(sj state.State, domain, ns, listener string, masters, ipSources []string, spec labels.Func) error {
rg.SlaveIPs = map[string]string{}
rg.SRVs = rrs{}
rg.As = rrs{}
rg.frameworkRecords(sj, domain, spec)
rg.slaveRecords(sj, domain, spec)
rg.listenerRecord(listener, ns)
rg.masterRecord(domain, masters, sj.Leader)
rg.taskRecords(sj, domain, spec, ipSources)
return nil
}
// frameworkRecords injects A and SRV records into the generator store:
// frameworkname.domain. // resolves to IPs of each framework
// _framework._tcp.frameworkname.domain. // resolves to the driver port and IP of each framework
func (rg *RecordGenerator) frameworkRecords(sj state.State, domain string, spec labels.Func) {
for _, f := range sj.Frameworks {
fname := labels.DomainFrag(f.Name, labels.Sep, spec)
host, port := f.HostPort()
if address, ok := hostToIP4(host); ok {
a := fname + "." + domain + "."
if !strings.HasPrefix(address, "172") {
rg.insertRR(a, address, "A")
}
if port != "" {
srv := net.JoinHostPort(a, port)
rg.insertRR("_framework._tcp."+a, srv, "SRV")
}
}
}
}
// slaveRecords injects A and SRV records into the generator store:
// slave.domain. // resolves to IPs of all slaves
// _slave._tc.domain. // resolves to the driver port and IP of all slaves
func (rg *RecordGenerator) slaveRecords(sj state.State, domain string, spec labels.Func) {
for _, slave := range sj.Slaves {
address, ok := hostToIP4(slave.PID.Host)
if ok {
a := "slave." + domain + "."
if !strings.HasPrefix(address, "172") {
rg.insertRR(a, address, "A")
}
srv := net.JoinHostPort(a, slave.PID.Port)
rg.insertRR("_slave._tcp."+domain+".", srv, "SRV")
} else {
logging.VeryVerbose.Printf("string '%q' for slave with id %q is not a valid IP address", address, slave.ID)
address = labels.DomainFrag(address, labels.Sep, spec)
}
rg.SlaveIPs[slave.ID] = address
}
}
// masterRecord injects A and SRV records into the generator store:
// master.domain. // resolves to IPs of all masters
// masterN.domain. // one IP address for each master
// leader.domain. // one IP address for the leading master
//
// The current func implementation makes an assumption about the order of masters:
// it's the order in which you expect the enumerated masterN records to be created.
// This is probably important: if a new leader is elected, you may not want it to
// become master0 simply because it's the leader. You probably want your DNS records
// to change as little as possible. And this func should have the least impact on
// enumeration order, or name/IP mappings - it's just creating the records. So let
// the caller do the work of ordering/sorting (if desired) the masters list if a
// different outcome is desired.
//
// Another consequence of the current overall mesos-dns app implementation is that
// the leader may not even be in the masters list at some point in time. masters is
// really fallback-masters (only consider these to be masters if I can't find a
// leader via ZK). At some point in time, they may not actually be masters any more.
// Consider a cluster of 3 nodes that suffers the loss of a member, and gains a new
// member (VM crashed, was replaced by another VM). And the cycle repeats several
// times. You end up with a set of running masters (and leader) that's different
// than the set of statically configured fallback masters.
//
// So the func tries to index the masters as they're listed and begrudgingly assigns
// the leading master an index out-of-band if it's not actually listed in the masters
// list. There are probably better ways to do it.
func (rg *RecordGenerator) masterRecord(domain string, masters []string, leader string) {
// create records for leader
// A records
h := strings.Split(leader, "@")
if len(h) < 2 {
logging.Error.Println(leader)
return // avoid a panic later
}
leaderAddress := h[1]
ip, port, err := getProto(leaderAddress)
if err != nil {
logging.Error.Println(err)
return
}
arec := "leader." + domain + "."
if !strings.HasPrefix(ip, "172") {
rg.insertRR(arec, ip, "A")
}
arec = "master." + domain + "."
if !strings.HasPrefix(ip, "172") {
rg.insertRR(arec, ip, "A")
}
// SRV records
tcp := "_leader._tcp." + domain + "."
udp := "_leader._udp." + domain + "."
host := "leader." + domain + "." + ":" + port
rg.insertRR(tcp, host, "SRV")
rg.insertRR(udp, host, "SRV")
// if there is a list of masters, insert that as well
addedLeaderMasterN := false
idx := 0
for _, master := range masters {
masterIP, _, err := getProto(master)
if err != nil {
logging.Error.Println(err)
continue
}
// A records (master and masterN)
if master != leaderAddress {
arec := "master." + domain + "."
if !strings.HasPrefix(masterIP, "172") {
added := rg.insertRR(arec, masterIP, "A")
if !added {
// duplicate master?!
continue
}
}
}
if master == leaderAddress && addedLeaderMasterN {
// duplicate leader in masters list?!
continue
}
arec := "master" + strconv.Itoa(idx) + "." + domain + "."
if !strings.HasPrefix(masterIP, "172") {
rg.insertRR(arec, masterIP, "A")
}
idx++
if master == leaderAddress {
addedLeaderMasterN = true
}
}
// flake: we ended up with a leader that's not in the list of all masters?
if !addedLeaderMasterN {
// only a flake if there were fallback masters configured
if len(masters) > 0 {
logging.Error.Printf("warning: leader %q is not in master list", leader)
}
arec = "master" + strconv.Itoa(idx) + "." + domain + "."
if !strings.HasPrefix(ip, "172") {
rg.insertRR(arec, ip, "A")
}
}
}
// A record for mesos-dns (the name is listed in SOA replies)
func (rg *RecordGenerator) listenerRecord(listener string, ns string) {
if listener == "0.0.0.0" {
rg.setFromLocal(listener, ns)
} else if listener == "127.0.0.1" {
rg.insertRR(ns, "127.0.0.1", "A")
} else {
rg.insertRR(ns, listener, "A")
}
}
func (rg *RecordGenerator) taskRecords(sj state.State, domain string, spec labels.Func, ipSources []string) {
for _, f := range sj.Frameworks {
fname := labels.DomainFrag(f.Name, labels.Sep, spec)
// insert taks records
tail := "." + domain + "."
for _, task := range f.Tasks {
var ok bool
task.SlaveIP, ok = rg.SlaveIPs[task.SlaveID]
// skip not running or not discoverable tasks
if !ok || (task.State != "TASK_RUNNING") {
continue
}
// define context
ctx := struct{ taskName, taskID, slaveID, taskIP, slaveIP string }{
spec(task.Name),
hashString(task.ID),
slaveIDTail(task.SlaveID),
task.IP(ipSources...),
task.SlaveIP,
}
// use DiscoveryInfo name if defined instead of task name
if task.HasDiscoveryInfo() {
ctx.taskName = task.DiscoveryInfo.Name
}
// insert canonical A records
canonical := ctx.taskName + "-" + ctx.taskID + "-" + ctx.slaveID + "." + fname
arec := ctx.taskName + "." + fname
shortArec := ctx.taskName
if !strings.HasPrefix(ctx.taskIP, "172") {
rg.insertRR(arec+tail, ctx.taskIP, "A")
rg.insertRR(shortArec+tail, ctx.taskIP, "A")
rg.insertRR(canonical+tail, ctx.taskIP, "A")
}
if !strings.HasPrefix(ctx.slaveIP, "172") {
rg.insertRR(shortArec+".slave"+tail, ctx.slaveIP, "A")
rg.insertRR(arec+".slave"+tail, ctx.slaveIP, "A")
rg.insertRR(canonical+".slave"+tail, ctx.slaveIP, "A")
}
// Add RFC 2782 SRV records
slaveHost := canonical + ".slave" + tail
tcpName := "_" + ctx.taskName + "._tcp." + fname
udpName := "_" + ctx.taskName + "._udp." + fname
shortTcpName := "_" + ctx.taskName + "._tcp"
shortUdpName := "_" + ctx.taskName + "._udp"
for _, port := range task.Ports() {
slaveTarget := slaveHost + ":" + port
if !task.HasDiscoveryInfo() {
rg.insertRR(shortTcpName+tail, slaveTarget, "SRV")
rg.insertRR(shortUdpName+tail, slaveTarget, "SRV")
rg.insertRR(tcpName+tail, slaveTarget, "SRV")
rg.insertRR(udpName+tail, slaveTarget, "SRV")
}
rg.insertRR(tcpName+".slave"+tail, slaveTarget, "SRV")
rg.insertRR(udpName+".slave"+tail, slaveTarget, "SRV")
rg.insertRR(shortTcpName+".slave"+tail, slaveTarget, "SRV")
rg.insertRR(shortUdpName+".slave"+tail, slaveTarget, "SRV")
}
if !task.HasDiscoveryInfo() {
continue
}
for _, port := range task.DiscoveryInfo.Ports.DiscoveryPorts {
target := canonical + tail + ":" + strconv.Itoa(port.Number)
// use protocol if defined, fallback to tcp+udp
proto := spec(port.Protocol)
if proto != "" {
name := "_" + ctx.taskName + "._" + proto + "." + fname
shortName := "_" + ctx.taskName + "._" + proto
rg.insertRR(shortName+tail, target, "SRV")
rg.insertRR(name+tail, target, "SRV")
} else {
rg.insertRR(shortTcpName+tail, target, "SRV")
rg.insertRR(shortUdpName+tail, target, "SRV")
rg.insertRR(tcpName+tail, target, "SRV")
rg.insertRR(udpName+tail, target, "SRV")
}
}
}
}
}
// A records for each local interface
// If this causes problems you should explicitly set the
// listener address in config.json
func (rg *RecordGenerator) setFromLocal(host string, ns string) {
ifaces, err := net.Interfaces()
if err != nil {
logging.Error.Println(err)
}
// handle err
for _, i := range ifaces {
addrs, err := i.Addrs()
if err != nil {
logging.Error.Println(err)
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue
}
if strings.HasPrefix(ip.String(), "172") {
continue
}
rg.insertRR(ns, ip.String(), "A")
}
}
}
func (rg *RecordGenerator) exists(name, host, rtype string) bool {
if rtype == "A" {
if val, ok := rg.As[name]; ok {
// check if A record already exists
// identical tasks on same slave
for _, b := range val {
if b == host {
return true
}
}
}
} else {
if val, ok := rg.SRVs[name]; ok {
// check if SRV record already exists
for _, b := range val {
if b == host {
return true
}
}
}
}
return false
}
// insertRR adds a record to the appropriate record map for the given name/host pair,
// but only if the pair is unique. returns true if added, false otherwise.
// TODO(???): REFACTOR when storage is updated
func (rg *RecordGenerator) insertRR(name, host, rtype string) bool {
if host == "" || rg.exists(name, host, rtype) {
return false
}
logging.VeryVerbose.Println("[" + rtype + "]\t" + name + ": " + host)
if rtype == "A" {
val := rg.As[name]
rg.As[name] = append(val, host)
} else {
val := rg.SRVs[name]
rg.SRVs[name] = append(val, host)
}
return true
}
// leaderIP returns the ip for the mesos master
// input format master@ip:port
func leaderIP(leader string) string {
pair := strings.Split(leader, "@")[1]
return strings.Split(pair, ":")[0]
}
// return the slave number from a Mesos slave id
func slaveIDTail(slaveID string) string {
fields := strings.Split(slaveID, "-")
return strings.ToLower(fields[len(fields)-1])
}
// should be able to accept
// ip:port
// zk://host1:port1,host2:port2,.../path
// zk://username:password@host1:port1,host2:port2,.../path
// file:///path/to/file (where file contains one of the above)
func getProto(pair string) (string, string, error) {
h := strings.SplitN(pair, ":", 2)
if len(h) != 2 {
return "", "", fmt.Errorf("unable to parse proto from %q", pair)
}
return h[0], h[1], nil
}
|
package main
//216. 组合总和 III
//找出所有相加之和为n 的k个数的组合。组合中只允许含有 1 -9 的正整数，并且每种组合中不存在重复的数字。
//
//说明：
//
//所有数字都是正整数。
//解集不能包含重复的组合。
//示例 1:
//
//输入: k = 3, n = 7
//输出: [[1,2,4]]
//示例 2:
//
//输入: k = 3, n = 9
//输出: [[1,2,6], [1,3,5], [2,3,4]]
func combinationSum3(k int, n int) [][]int {
var dfs func(s, target, dep int) [][]int
dfs = func(s, target, dep int) [][]int {
var result [][]int
for i := s; i < 10; i++ {
if i > target || dep > k {
break
} else if dep == k && i == target {
result = append(result, []int{i})
break
}
res := dfs(i+1, target-i, dep+1)
for _, v := range res {
result = append(result, append([]int{i}, v...))
}
}
return result
}
return dfs(1, n, 1)
}
|
/*
Copyright 2015 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package examples
import "k8s.io/kubernetes/pkg/runtime"
// ExampleBuilder fetches examples and templates for Kubernetes
// API object kinds.
type ExampleBuilder interface {
// NewExample fetches a new copy of an example object of
// the given version and kind, prepopulated with common values.
// If no example is found, it should return false for the boolean,
// but still return an emtpy object of the correct version and kind.
NewExample(version, kind string) (runtime.Object, bool, error)
}
|
package controller
import (
"fmt"
"io"
"net"
"code.aliyun.com/runningguys/agent/registry"
"github.com/coreos/etcd/clientv3"
)
type providerAgent struct {
port string
destPort string
}
func startProviderAgent(property registry.Property, cli *clientv3.Client) {
reg := new(registry.EtcdRegistry)
reg.Init(cli, property)
pa := &providerAgent{property.Port, property.DestPort}
pa.listenAndServe()
}
func (pa *providerAgent) listenAndServe() {
ln, err := net.Listen("tcp", ":"+pa.port)
if err != nil {
panic(err)
}
for {
conn, err := ln.Accept()
if err != nil {
panic(err)
}
go pa.serve(conn)
}
}
func (pa *providerAgent) serve(conn net.Conn) {
defer conn.Close()
pcon, err := net.Dial("tcp", "127.0.0.1:"+pa.destPort)
if err != nil {
panic(err)
}
go copy(conn, pcon)
_, err = io.Copy(pcon, conn)
if err != nil {
fmt.Println(err)
}
}
func copy(conn net.Conn, pcon net.Conn) {
defer pcon.Close()
_, err := io.Copy(conn, pcon)
if err != nil {
fmt.Println(err)
}
}
|
// Copyright 2022 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package bluetooth
// DeviceCapability is a name of a device capability, matching keys of the
// capabilities map returned from calling PeripheralKit.GetCapabilities().
type DeviceCapability string
const (
// DeviceCapabilityTransports is the DeviceCapability for supported transport
// methods.
DeviceCapabilityTransports DeviceCapability = "CAP_TRANSPORTS"
// DeviceCapabilityHasPin is the DeviceCapability denoting whether the device
// has a pin code.
DeviceCapabilityHasPin DeviceCapability = "CAP_HAS_PIN"
// DeviceCapabilityInitConnect is the DeviceCapability denoting whether the
// device can initiate a bluetooth connection.
DeviceCapabilityInitConnect DeviceCapability = "CAP_INIT_CONNECT"
)
// String returns DeviceCapability as a string.
func (dc DeviceCapability) String() string {
return string(dc)
}
// TransportMethod refers to a type of transport method that a bluetooth
// device may support.
type TransportMethod string
const (
// TransportMethodLE refers to the LE TransportMethod.
TransportMethodLE TransportMethod = "TRANSPORT_LE"
// TransportMethodBREDR refers to the BREDR TransportMethod.
TransportMethodBREDR TransportMethod = "TRANSPORT_BREDR"
)
// String returns TransportMethod as a string.
func (tm TransportMethod) String() string {
return string(tm)
}
// DeviceType refers to the type of bluetooth device, as returned by
// calling PeripheralKit.GetDeviceType().
type DeviceType string
const (
// DeviceTypeKeyboard is the DeviceType for keyboard devices.
DeviceTypeKeyboard DeviceType = "KEYBOARD"
// DeviceTypeGamepad is the DeviceType for gamepad devices.
DeviceTypeGamepad DeviceType = "GAMEPAD"
// DeviceTypeMouse is the DeviceType for mouse devices.
DeviceTypeMouse DeviceType = "MOUSE"
// DeviceTypeCombo is the DeviceType for combo devices.
DeviceTypeCombo DeviceType = "COMBO"
// DeviceTypeJoystick is the DeviceType for joystick devices.
DeviceTypeJoystick DeviceType = "JOYSTICK"
// DeviceTypeA2DPSink is the DeviceType for A2DP sink devices.
DeviceTypeA2DPSink DeviceType = "A2DP_SINK"
// DeviceTypePhone is the DeviceType for phone devices.
DeviceTypePhone DeviceType = "PHONE"
// DeviceTypeBluetoothAudio is the DeviceType for audio devices.
DeviceTypeBluetoothAudio DeviceType = "BLUETOOTH_AUDIO"
// DeviceTypeFastPair is the DeviceType for fast pair devices.
DeviceTypeFastPair DeviceType = "FAST_PAIR"
)
// String returns DeviceType as a string.
func (dt DeviceType) String() string {
return string(dt)
}
// AuthenticationMode refers to the bluetooth authentication mode of a device, as
// returned by calling PeripheralKit.GetAuthenticationMode().
type AuthenticationMode string
const (
// AuthenticationModeOpen is the "OPEN" AuthenticationMode.
AuthenticationModeOpen AuthenticationMode = "OPEN"
// AuthenticationModeSSPKeyboard is the "SSP_KEYBOARD" AuthenticationMode.
AuthenticationModeSSPKeyboard AuthenticationMode = "SSP_KEYBOARD"
// AuthenticationModeSSPJustWork is the "SSP_JUST_WORK" AuthenticationMode.
AuthenticationModeSSPJustWork AuthenticationMode = "SSP_JUST_WORK"
// AuthenticationModePinCode is the "PIN_CODE" AuthenticationMode.
AuthenticationModePinCode AuthenticationMode = "PIN_CODE"
)
// String returns AuthenticationMode as a string.
func (am AuthenticationMode) String() string {
return string(am)
}
|
// Copyright (c) 2017-present Mattermost, Inc. All Rights Reserved.
// See License for license information.
package main
import (
"io"
"github.com/mattermost/mattermost-server/model"
)
func AsSlackAttachment(in io.Reader) (func(post *model.Post), error) {
parsed, err := parse(in, nil)
if err != nil {
return nil, err
}
a := newSlackAttachment(parsed)
// Return a function that adds to a post as a SlackAttachment
return func(post *model.Post) {
model.ParseSlackAttachment(post, []*model.SlackAttachment{a})
}, nil
}
func newSlackAttachment(parsed *parsedWebhook) *model.SlackAttachment {
if parsed.headline == "" {
return nil
}
a := &model.SlackAttachment{
Color: "#95b7d0",
Fallback: parsed.headline,
Pretext: parsed.headline,
Text: parsed.edited,
}
text := parsed.mdIssueLongLink() + "\n"
if parsed.edited != "" {
text += "\n"
text += parsed.edited + "\n"
}
var fields []*model.SlackAttachmentField
if parsed.WebhookEvent == "jira:issue_created" {
if parsed.Issue.Fields.Assignee != nil {
fields = append(fields, &model.SlackAttachmentField{
Title: "Assignee",
Value: parsed.Issue.Fields.Assignee.DisplayName,
Short: true,
})
}
if parsed.Issue.Fields.Priority != nil {
fields = append(fields, &model.SlackAttachmentField{
Title: "Priority",
Value: parsed.Issue.Fields.Priority.Name,
Short: true,
})
}
}
a.Text = text
a.Fields = fields
return a
}
|
package controllers
import (
"fmt"
"github.com/gin-gonic/gin"
)
type User struct{}
//login
func (u *User) Login(c *gin.Context) {
fmt.Println("ni hao")
return
}
|
package core
import (
"fmt"
"log"
"net/http"
)
type Config struct {
Port int
Mysql *MysqlConfig
}
type Instance struct {
config *Config
channels *Channels
}
func (config *Config) NewInstance() *Instance {
this := &Instance{
config: config,
channels: config.NewChannels(),
}
return this
}
var objectMap map[string]string
func (this *Instance) Init() error {
this.buildEventService()
portString := fmt.Sprintf(":%d", this.config.Port)
go http.ListenAndServeTLS(portString, "keys/local.crt", "keys/local.key", nil)
log.Printf("Serving requests on port %d\n", this.config.Port)
objectMap = map[string]string{
"X-Secondlife-Owner-Key": "owner_key",
"X-Secondlife-Owner-Name": "owner_name",
"X-Secondlife-Local-Position": "position",
"X-Secondlife-Region": "region",
"X-Secondlife-Object-Key": "object_key",
"X-Secondlife-Object-Name": "object_name",
}
return nil
}
|
package main
import (
"github.com/CRUD-Gin-Gorm/Route"
"github.com/CRUD-Gin-Gorm/Config"
"github.com/jinzhu/gorm"
_ "github.com/lib/pq"
)
var err error
func main() {
Config.Db, err = gorm.Open("postgres", "user=sirawich dbname=booker sslmode=disable")
if err != nil {
panic(err)
}
defer Config.Db.Close()
dbase := Config.Db.DB()
err = dbase.Ping()
if err != nil {
panic(err.Error())
}
println("Connection to database established")
println("Done!")
r := Route.InitRouter()
r.Run()
}
|
package LeetCode
import "fmt"
func Code35() {
nums := []int{1, 3, 5, 6}
target := 0
fmt.Println(searchInsert(nums, target))
}
/**
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0
输出: 0
```
*/
func searchInsert(nums []int, target int) int {
if target < nums[0] {
return 0
}
for i, item := range nums {
if item == target {
return i
}
if target < item {
return i - 1
}
}
return len(nums)
}
|
package pdf
import (
"fmt"
"io"
)
type Object interface {
String() string
}
type NullObject struct {}
func NewNullObject() *NullObject {
return &NullObject{}
}
func (obj *NullObject) String() string {
return "null"
}
type IndirectObject struct {
Number int64
Generation int64
Value Object
Stream []byte
}
func NewIndirectObject(number int64) *IndirectObject {
return &IndirectObject{number, 0, NewNullObject(), nil}
}
func (obj *IndirectObject) Fprint(w io.Writer) {
value := obj.Value.String()
if value != "null" {
fmt.Fprintf(w, "%d %d obj\n", obj.Number, obj.Generation)
fmt.Fprintln(w, obj.Value.String())
if obj.Stream != nil {
fmt.Fprintln(w, "stream")
fmt.Fprintln(w, string(obj.Stream))
fmt.Fprintln(w, "endstream")
}
fmt.Fprintln(w, "endobj")
}
}
|
package wasmvm
import (
"fmt"
"github.com/zhaohaijun/matrixchain/common/log"
"github.com/zhaohaijun/matrixchain/errors"
"github.com/zhaohaijun/matrixchain/vm/wasmvm/exec"
"github.com/zhaohaijun/matrixchain/vm/wasmvm/util"
)
type LogLevel byte
const (
Debug LogLevel = iota
Info
Error
)
type ParamType byte
const (
Json ParamType = iota
Raw
)
type WasmStateMachine struct {
*WasmStateReader
}
func NewWasmStateMachine() *WasmStateMachine {
stateMachine := WasmStateMachine{WasmStateReader: NewWasmStateReader()}
//only for debug test
stateMachine.Register("ContractLogDebug", stateMachine.contractLogDebug)
stateMachine.Register("ContractLogInfo", stateMachine.contractLogInfo)
stateMachine.Register("ContractLogError", stateMachine.contractLogError)
return &stateMachine
}
func (s *WasmStateMachine) contractLogDebug(engine *exec.ExecutionEngine) (bool, error) {
_, err := contractLog(Debug, engine)
if err != nil {
return false, err
}
engine.GetVM().RestoreCtx()
return true, nil
}
func (s *WasmStateMachine) contractLogInfo(engine *exec.ExecutionEngine) (bool, error) {
_, err := contractLog(Info, engine)
if err != nil {
return false, err
}
engine.GetVM().RestoreCtx()
return true, nil
}
func (s *WasmStateMachine) contractLogError(engine *exec.ExecutionEngine) (bool, error) {
_, err := contractLog(Error, engine)
if err != nil {
return false, err
}
engine.GetVM().RestoreCtx()
return true, nil
}
func contractLog(lv LogLevel, engine *exec.ExecutionEngine) (bool, error) {
vm := engine.GetVM()
envCall := vm.GetEnvCall()
params := envCall.GetParams()
if len(params) != 1 {
return false, errors.NewErr("parameter count error while call contractLong")
}
Idx := params[0]
addr, err := vm.GetPointerMemory(Idx)
if err != nil {
return false, errors.NewErr("get Contract address failed")
}
msg := fmt.Sprintf("[WASM Contract] Address:%s message:%s", vm.ContractAddress.ToHexString(), util.TrimBuffToString(addr))
switch lv {
case Debug:
log.Debug(msg)
case Info:
log.Info(msg)
case Error:
log.Error(msg)
}
return true, nil
}
|
// Copyright 2022 YuWenYu All rights reserved.
// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.
package adapter
import (
"fmt"
"github.com/go-xorm/xorm"
"github.com/spf13/cast"
"github.com/yuw-pot/pot/data"
E "github.com/yuw-pot/pot/modules/err"
//E "github.com/yuw-pot/pot/modules/err"
P "github.com/yuw-pot/pot/modules/properties"
U "github.com/yuw-pot/pot/modules/utils"
"strings"
"time"
)
const (
Master string = "master"
Slaver string = "slaver"
Mysql string = "mysql"
PostgreSQL string = "postgres"
)
type (
PoT struct {
vPoT *U.PoT
dn interface{}
name string
sConns *srcConns
sParam *srcParam
timeLocation *time.Location
}
srcParam struct {
MaxOpen int
MaxIdle int
ShowedSQL bool
CachedSQL bool
}
srcConns struct {
Host string
Port int
Username string
Password string
}
)
var (
dModes []interface{} = []interface{}{
Master,
Slaver,
}
dNames []interface{} = []interface{}{
Mysql,
PostgreSQL,
}
// - map[DriverName][dbName][]*xorm.Engine
adapterMaster map[interface{}]map[interface{}][]*xorm.Engine = map[interface{}]map[interface{}][]*xorm.Engine{
Mysql: {},
PostgreSQL: {},
}
adapterSlaver map[interface{}]map[interface{}][]*xorm.Engine = map[interface{}]map[interface{}][]*xorm.Engine{
Mysql: {},
PostgreSQL: {},
}
)
func Made(driverName string, name string, mode ... interface{}) (*xorm.Engine, error) {
v := U.New()
if ok := v.Contains(driverName, dNames); ok == false {
return nil, E.Err(data.ErrPfx, "AdapterMadeDN")
}
var modeAdapter interface{}
if len(mode) == 0 {
modeAdapter = Master
} else {
if ok := v.Contains(mode[0], dModes); ok {
modeAdapter = mode[0]
} else {
return nil, E.Err(data.ErrPfx, "AdapterMadeMode")
}
}
switch modeAdapter {
case Master:
_, okd := adapterMaster[driverName]
if okd == false {
return nil, E.Err(data.ErrPfx, "AdapterMadeDN")
}
_, okn := adapterMaster[driverName][name]
if okn == false {
return nil, E.Err(data.ErrPfx, "AdapterMadeName")
}
break
case Slaver:
_, okd := adapterSlaver[driverName]
if okd == false {
return nil, E.Err(data.ErrPfx, "AdapterMadeDN")
}
_, okn := adapterSlaver[driverName][name]
if okn == false {
return nil, E.Err(data.ErrPfx, "AdapterMadeName")
}
break
default:
return nil, E.Err(data.ErrPfx, "AdapterMadeMode")
break
}
var (
mLen int = len(adapterMaster[driverName][name])
sLen int = len(adapterSlaver[driverName][name])
)
if len(mode) == 0 {
return adapterMaster[driverName][name][v.NumRandom(0, mLen)], nil
}
var x *xorm.Engine
switch strings.ToLower(cast.ToString(mode[0])) {
case "master":
x = adapterMaster[driverName][name][v.NumRandom(0, mLen)]
break
case "slaver":
x = adapterSlaver[driverName][name][v.NumRandom(0, sLen)]
break
default:
return nil, E.Err(data.ErrPfx, "AdapterMadeMode")
}
return x, nil
}
func New() *PoT {
return &PoT {
vPoT: U.New(),
}
}
func (adapterPoT *PoT) Made() {
// Set db Time Location
// - GeT Configure
adapterTimeLocation := P.PropertyPoT.GeT("PoT.TimeLocation", data.TimeLocation)
d, err := adapterPoT.vPoT.SetTimeLocation(cast.ToString(adapterTimeLocation))
if err != nil {
panic(err)
}
adapterPoT.timeLocation = d
// - SeT Adapter data
for _, dn := range dNames {
var sParam *srcParam
_ = P.PropertyPoT.UsK(
fmt.Sprintf("Adapter.%v.Param", cast.ToString(dn)),
&sParam,
)
if sParam == nil {
continue
}
adapterPoT.dn = dn
adapterPoT.sParam = sParam
adapterConns := P.PropertyPoT.GeT(
fmt.Sprintf("Adapter.%v.Conns", cast.ToString(dn)),
nil,
)
if adapterConns == nil {
continue
}
for db, conns := range adapterConns.(map[string]interface{}) {
dbTag := strings.Split(db, "_")
if len(dbTag) != 2 {
continue
}
if dbTag[1] == "" {
continue
}
adapterPoT.name = dbTag[1]
master, okMaster := conns.(map[string]interface{})["master"]
if okMaster == false || master == nil {
continue
}
adapterMaster[dn][adapterPoT.name] = make([]*xorm.Engine, len(master.([]interface{})))
adapterMaster[dn][adapterPoT.name] = adapterPoT.check(master.([]interface{}) ...)
slaver, okSlaver := conns.(map[string]interface{})["slaver"]
if okSlaver == false || slaver == nil {
continue
}
adapterSlaver[dn][adapterPoT.name] = make([]*xorm.Engine, len(slaver.([]interface{})))
adapterSlaver[dn][adapterPoT.name] = adapterPoT.check(slaver.([]interface{}) ...)
}
}
}
func (adapterPoT *PoT) check(d ... interface{}) []*xorm.Engine {
var adapters []*xorm.Engine = make([]*xorm.Engine, len(d))
for k, v := range d {
adapterPoT.sConns = &srcConns {
Host: "",
Port: 0,
Username: "",
Password: "",
}
if _, ok := v.(map[interface{}]interface{})["Host"]; ok {
adapterPoT.sConns.Host = cast.ToString(v.(map[interface{}]interface{})["Host"])
}
if _, ok := v.(map[interface{}]interface{})["Port"]; ok {
adapterPoT.sConns.Port = cast.ToInt(v.(map[interface{}]interface{})["Port"])
}
if _, ok := v.(map[interface{}]interface{})["Username"]; ok {
adapterPoT.sConns.Username = cast.ToString(v.(map[interface{}]interface{})["Username"])
}
if _, ok := v.(map[interface{}]interface{})["Password"]; ok {
adapterPoT.sConns.Password = cast.ToString(v.(map[interface{}]interface{})["Password"])
}
adapters[k] = adapterPoT.instance()
}
return adapters
}
func (adapterPoT *PoT) instance() *xorm.Engine {
db := dbNew()
db.dn = adapterPoT.dn
db.name = adapterPoT.name
db.sParam = adapterPoT.sParam
db.sConns = adapterPoT.sConns
db.timeLocation = adapterPoT.timeLocation
db.instance()
return db.xEngine()
}
|
//112 interfaces & polymorphism
// 一個值可以有很多種type
// func (容器 類型) 接收器
// type 名稱 interface {內容...}
package main
import "fmt"
type person struct {
fname string
lname string
}
type scagent struct {
person
ltk bool
}
type human interface { //如果你可以執行 speak() 你就有我 human 的 type // 增加type
speak() // 在speak()的func 接收器裡 增加 可執行speak()的type
}
func (s scagent) speak() {
fmt.Println("程序speak() 接收器條件為(s scagent):", s.fname, s.lname)
}
//有 此type的人才可以使用
func (p person) speak() {
fmt.Println("程序speak() 接收器條件為(p person):", p.fname, p.lname)
}
//bar 只能放有 human type的 // 運用方面配合 interface可以多種type
func bar(h human) {
//type 細分過濾 human 有 scagent 和 person
switch h.(type) {
case person:
fmt.Printf("程序 bar(h human)_caseing_caseh.(類型): %T , 值: %v%v\n", h, h.(person).fname, h.(person).lname)
case scagent:
fmt.Printf("程序 bar(h human)_caseing_caseh.(類型): %T , 值: %v%v\n", h, h.(scagent).fname, h.(scagent).lname)
}
// fmt.Println("func bar(h hyman)default no switch:h", h)
}
func main() {
sa1 := scagent{
person: person{
fname: "eous(scagent)",
lname: "gyou(scagent)",
},
ltk: true,
}
sa2 := person{
fname: "ming(person)",
lname: "andy(person)",
}
p3 := person{
fname: "The(person)",
lname: "FOX(person)",
}
sa1.speak()
sa2.speak()
p3.speak()
fmt.Println(p3)
fmt.Printf("%T\n", sa1)
bar(sa1)
bar(sa2)
bar(p3)
sa1.speak()
// 型別轉換 ex sample
type hotdog int
var x hotdog = 42
fmt.Println(x)
fmt.Printf("%T\n", x)
var y int
// 型別轉換 x(hotdog) -> y(int)
y = int(x)
fmt.Println(y)
fmt.Printf("%T\n", y)
}
|
package main
import (
"html/template"
)
var tmplHtml = `
<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Bybit Funding</title>
<link rel="stylesheet" href="/static/css/bootstrap.css" />
<link rel="stylesheet" href="/static/css/style.css" />
</head>
<body>
<div class="container">
<div class="row my-3">
<div class="col col-md-4 offset-md-4">
<div class="row">
<div class="col">
Current:
</div>
<div class="col">
{{ .Current }}%
</div>
</div>
<div class="row">
<div class="col">
Predicted:
</div>
<div class="col">
{{ .Predicted }}%
</div>
</div>
</div>
</div>
</div>
</body>
</html>
`
var tmpl = template.Must(template.New("index").Parse(tmplHtml))
|
package main
import (
"fmt"
"github.com/dropbox/godropbox/database/sqlbuilder"
)
func main() {
t1 := sqlbuilder.NewTable(
"tickets",
sqlbuilder.IntColumn("id", false),
sqlbuilder.IntColumn("number", false),
)
// t1_id := t1.C("id")
t1_number := t1.C("number")
query := t1.Select(t1_number).Where(sqlbuilder.Eql(t1_id, 123))
fmt.Println(query.String("shard1"))
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.