text stringlengths 11 4.05M |
|---|
package main
import (
"fmt"
"math/rand"
"sort"
"time"
)
func init() {
rand.Seed(time.Now().UnixNano())
}
func main() {
array := make([]int, 0)
for i := 0; i < 500; i++ {
num := rand.Intn(1000)
array = append(array, num)
}
//fmt.Println("---array----", array)
// 冒泡法
tBegin := time.Now().UnixNano()
for i := 0; i < len(array); i++ {
for j := 0; j < len(array)-i-1; j++ {
if array[j] < array[j+1] {
array[j], array[j+1] = array[j+1], array[j]
}
}
}
//fmt.Println(array)
tEnd := time.Now().UnixNano()
fmt.Println("---冒泡------", tEnd-tBegin)
// 库函数
timeBegin := time.Now().UnixNano()
sort.Ints(array)
timeEnd := time.Now().UnixNano()
fmt.Println("-------库函数--------", timeEnd-timeBegin)
// 堆排序
tHeapBegin := time.Now().UnixNano()
duiSort(array)
tHeapEnd := time.Now().UnixNano()
//fmt.Println("----", array)
fmt.Println("-----堆排序-----", tHeapEnd-tHeapBegin)
}
func duiSort(array []int) {
n := len(array) - 1
for root := n / 2; root >= 0; root-- {
minHeap(root, n, array)
}
for end := n; end >= 0; end-- {
if array[0] > array[end] {
array[0], array[end] = array[end], array[0]
minHeap(0, end, array)
}
}
}
func minHeap(root int, end int, arr []int) {
child := 2*root + 1
for {
if child > end {
break
}
if child+1 <= end && arr[child] > arr[child+1] {
child++
}
if arr[root] > arr[child] {
arr[root], arr[child] = arr[child], arr[root]
root = child
} else {
break
}
}
}
|
package currency
import (
"strconv"
)
// ConvertPenniesToDollarString takes a penny amount as
// an int64 and returns a dollar string representation
func ConvertPenniesToDollarString(amount int64) string {
// parse the pennies as a base 10 int
result := strconv.FormatInt(amount, 10)
// check if negative, will set it back later
negative := false
if result[0] == '-' {
result = result[1:]
negative = true
}
// left pad with 0 if we're passed in value < 100
for len(result) < 3 {
result = "0" + result
}
length := len(result)
// add in the decimal
result = result[0:length-2] + "." + result[length-2:]
// from the negative we stored earlier!
if negative {
result = "-" + result
}
return result
}
|
package user
import (
"GP/db"
"GP/model"
"database/sql"
"log"
)
func GetOneUser(id string) (userInfo []*model.User, err error) {
userInfo = []*model.User{}
querySql := "select id, username, nickname, role, phone, label, fonttype, fontcolor, isban from gp.user where id = ?;"
stmt, err := db.DB.Prepare(querySql)
if err != nil {
log.Println("GetUser Querysql prepare fail")
return nil, err
}
defer stmt.Close()
rows, err := stmt.Query(id)
if err != nil {
log.Println("GetUser Querysql query fail")
return nil, err
}
for rows.Next() {
var user model.User
err := rows.Scan(&user.Id, &user.UserName, &user.NickName, &user.Role, &user.Phone, &user.Label, &user.FontType, &user.FontColor, &user.IsBan)
if err != nil {
return nil, err
}
userInfo = append(userInfo, &user)
}
//fmt.Println(userInfo)
return userInfo, nil
}
func GetUserList() (userInfo []*model.User, err error) {
userInfo = []*model.User{}
querySql := "select id, username, nickname, role, phone, label, fonttype, fontcolor, isban from gp.user"
stmt, err := db.DB.Prepare(querySql)
if err != nil {
log.Println("GetUserList Querysql prepare fail")
return nil, err
}
defer stmt.Close()
rows, err := stmt.Query()
if err != nil {
log.Println("GetUserList Querysql query fail")
return nil, err
}
for rows.Next() {
var user model.User
err := rows.Scan(&user.Id, &user.UserName, &user.NickName, &user.Role, &user.Phone, &user.Label, &user.FontType, &user.FontColor, &user.IsBan)
if err != nil {
return nil, err
}
userInfo = append(userInfo, &user)
}
//fmt.Println(userInfo)
return userInfo, nil
}
func UpdateUser(id, nickname, phone, label, fonttype, fontcolor string) (err error) {
updateSql := "update gp.user set nickname = ?, phone = ?, label = ?, fonttype = ?,fontcolor = ? where id = ?"
stmt, err := db.DB.Prepare(updateSql)
if err != nil {
log.Println("UpdateUser updateSql fail")
return err
}
defer stmt.Close()
_, err = stmt.Exec(nickname, phone, label, fonttype, fontcolor, id)
if err != nil {
log.Println("UpdateUser exec fail")
return err
}
return nil
}
func UpdatePassword(id, password string) (err error) {
updateSql := "update gp.user set password = ? where id = ?"
stmt, err := db.DB.Prepare(updateSql)
if err != nil {
log.Println("UpdatePassword updateSql fail")
return err
}
defer stmt.Close()
_, err = stmt.Exec(password, id)
if err != nil {
log.Println("UpdatePassword exec fail")
return err
}
return nil
}
func BanUser(id string) (err error) {
updateSql := "update gp.user set isban = 1 where id = ?"
stmt, err := db.DB.Prepare(updateSql)
if err != nil {
log.Println("BanUser updateSql fail")
return err
}
defer stmt.Close()
_, err = stmt.Exec(id)
if err != nil {
log.Println("BanUser exec fail")
return err
}
return nil
}
func CancelBanUser(id string) (err error) {
updateSql := "update gp.user set isban = 0 where id = ?"
stmt, err := db.DB.Prepare(updateSql)
if err != nil {
log.Println("CancelBanUser updateSql fail")
return err
}
defer stmt.Close()
_, err = stmt.Exec(id)
if err != nil {
log.Println("CancelBanUser exec fail")
return err
}
return nil
}
func UpUserRole(id string) (err error) {
updateSql := "update gp.user set role = 'manager' where id = ?"
stmt, err := db.DB.Prepare(updateSql)
if err != nil {
log.Println("UpUserRole updateSql fail")
return err
}
defer stmt.Close()
_, err = stmt.Exec(id)
if err != nil {
log.Println("UpUserRole exec fail")
return err
}
return nil
}
func DownUserRole(id string) (err error) {
updateSql := "update gp.user set role = 'member' where id = ?"
stmt, err := db.DB.Prepare(updateSql)
if err != nil {
log.Println("DownUserRoleupdateSql fail")
return err
}
defer stmt.Close()
_, err = stmt.Exec(id)
if err != nil {
log.Println("DownUserRole exec fail")
return err
}
return nil
}
func FindUser(findstring string) (userInfo []*model.User, err error) {
userInfo = []*model.User{}
querySql := "select id, username, nickname, role, phone, label, fonttype, fontcolor, isban from gp.user where nickname like ? or label like ?;"
stmt, err := db.DB.Prepare(querySql)
if err != nil {
log.Println("FindUser Querysql prepare fail")
return nil, err
}
defer stmt.Close()
rows, err := stmt.Query("%"+findstring+"%", "%"+findstring+"%")
if err != nil {
log.Println("FindUser Querysql query fail")
return nil, err
}
for rows.Next() {
var user model.User
err := rows.Scan(&user.Id, &user.UserName, &user.NickName, &user.Role, &user.Phone, &user.Label, &user.FontType, &user.FontColor, &user.IsBan)
if err != nil {
return nil, err
}
userInfo = append(userInfo, &user)
}
return userInfo, nil
}
func GetUserRole(id string) (role string, err error) {
querySql := "select role from gp.user where id = ?"
err = db.DB.QueryRow(querySql, id).Scan(&role)
if err != nil {
if err == sql.ErrNoRows {
log.Println("user not account found")
return "null", nil
} else {
log.Println("GetUserRole query fail" + err.Error())
return "null", err
}
}
return role, nil
}
|
package main
import "fmt"
func main() {
fmt.Println("sum is", 45+59)
fmt.Println("string concat of go and lang is", "go"+"lang")
fmt.Println("division of floats", 7.0/3, 7.0/3.0, 7/3.0)
fmt.Println("testing and, or operations", true || false, true && false)
}
|
package middleware
import (
"net/http"
"net/url"
"strings"
"github.com/gobuffalo/buffalo"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/module"
"github.com/gomods/athens/pkg/paths"
)
// NewFilterMiddleware builds a middleware function that implements the
// filters configured in the filter file.
func NewFilterMiddleware(mf *module.Filter, upstreamEndpoint string) buffalo.MiddlewareFunc {
const op errors.Op = "actions.NewFilterMiddleware"
return func(next buffalo.Handler) buffalo.Handler {
return func(c buffalo.Context) error {
mod, err := paths.GetModule(c)
if err != nil {
// if there is no module the path we are hitting is not one related to modules, like /
return next(c)
}
rule := mf.Rule(mod)
switch rule {
case module.Exclude:
// Exclude: ignore request for this module
return c.Render(http.StatusForbidden, nil)
case module.Include:
// Include: please handle this module in a usual way
return next(c)
case module.Direct:
// Direct: do not store modules locally, use upstream proxy
newURL := redirectToUpstreamURL(upstreamEndpoint, c.Request().URL)
return c.Redirect(http.StatusSeeOther, newURL)
}
return next(c)
}
}
}
func redirectToUpstreamURL(upstreamEndpoint string, u *url.URL) string {
return strings.TrimSuffix(upstreamEndpoint, "/") + u.Path
}
|
package main
import (
"github.com/beego/beego/v2/client/orm/migration"
)
// DO NOT MODIFY
type User_20210628_144749 struct {
migration.Migration
}
// DO NOT MODIFY
func init() {
m := &User_20210628_144749{}
m.Created = "20210628_144749"
migration.Register("User_20210628_144749", m)
}
// Run the migrations
func (m *User_20210628_144749) Up() {
// use m.SQL("CREATE TABLE ...") to make schema update
m.SQL("ALTER TABLE user ADD email VARCHAR(255)")
}
// Reverse the migrations
func (m *User_20210628_144749) Down() {
// use m.SQL("DROP TABLE ...") to reverse schema update
}
|
package frida_go
type RemoteDeviceOptions struct {
Certificate string
Origin string
Token string
KeepaliveInterval int
} |
package mysqldb
import (
"context"
"path/filepath"
"testing"
"time"
"github.com/jinmukeji/jiujiantang-services/service/auth"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
// TokenTestSuite 是 Token 的 testSuite
type TokenTestSuite struct {
suite.Suite
db *DbClient
}
// SetupSuite 准备设置 Test Suite 执行
func (suite *TokenTestSuite) SetupSuite() {
envFilepath := filepath.Join("testdata", "local.svc-biz-core.env")
db, _ := newTestingDbClientFromEnvFile(envFilepath)
suite.db = db
}
// TestCreateTokenSuccess 测试 token 成功创建
func (suite *TokenTestSuite) TestCreateTokenSuccess() {
t := suite.T()
ctx := context.Background()
const userID = int32(1)
token := auth.GenerateToken()
// 创建 token
tk, err := suite.db.GetDB(ctx).CreateToken(ctx, token, userID, time.Hour*12)
assert.NoError(t, err)
assert.Equal(t, userID, tk.UserID)
}
// TestFindUserIDByTokenSuccess 测试成功从 token 获取 userID
func (suite *TokenTestSuite) TestFindUserIDByTokenSuccess() {
t := suite.T()
ctx := context.Background()
const userID = int32(1)
token := auth.GenerateToken()
// 创建 token
tk, err := suite.db.GetDB(ctx).CreateToken(ctx, token, userID, time.Hour*12)
assert.NoError(t, err)
// 从 token 取出 accoount
user, _ := suite.db.GetDB(ctx).FindUserIDByToken(ctx, tk.Token)
assert.Equal(t, user, userID)
}
// TestFindUserIDByTokenFail 测试 token 超时 返回空的account
func (suite *TokenTestSuite) TestFindUserIDByTokenFail() {
t := suite.T()
ctx := context.Background()
token := auth.GenerateToken()
// 插入一条 1 秒后失效的记录
_, errCreateToken := suite.db.GetDB(ctx).CreateToken(ctx, token, 1, time.Second)
assert.Error(t, errCreateToken)
// 休眠2秒
time.Sleep(time.Second * 2)
userID, err := suite.db.GetDB(ctx).FindUserIDByToken(ctx, token)
// 失效返回error
assert.True(t, userID == int32(0))
assert.Error(t, err)
}
// TestDeleteToken 测试删除 token
func (suite *TokenTestSuite) TestDeleteToken() {
t := suite.T()
ctx := context.Background()
const userID = int32(1)
token := auth.GenerateToken()
// 生成 token
tk, err := suite.db.GetDB(ctx).CreateToken(ctx, token, userID, time.Hour*12)
assert.NoError(t, err)
assert.Equal(t, userID, tk.UserID)
// 删除 token
err = suite.db.GetDB(ctx).DeleteToken(ctx, tk.Token)
assert.NoError(t, err)
// 删除后找不到 token
user, err := suite.db.GetDB(ctx).FindUserIDByToken(ctx, tk.Token)
assert.Equal(t, int32(0), user)
assert.Error(t, err)
}
// TestTokenTestSuite 启动测试
func TestTokenTestSuite(t *testing.T) {
suite.Run(t, new(TokenTestSuite))
}
|
package Problem0290
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
// tcs is testcase slice
var tcs = []struct {
pattern string
str string
ans bool
}{
{"abba", "dog cat cat dog", true},
{"abba", "dog cat cat fish", false},
{"aaaa", "dog cat cat dog", false},
{"abba", "dog dog dog dog", false},
{"aaa", "aa aa aa aa", false},
// 可以有多个 testcase
}
func Test_wordPattern(t *testing.T) {
ast := assert.New(t)
for _, tc := range tcs {
fmt.Printf("~~%v~~\n", tc)
ast.Equal(tc.ans, wordPattern(tc.pattern, tc.str), "输入:%v", tc)
}
}
func Benchmark_wordPattern(b *testing.B) {
for i := 0; i < b.N; i++ {
for _, tc := range tcs {
wordPattern(tc.pattern, tc.str)
}
}
}
|
package grap
import (
DDBB "github.com/siulfe/gql/Database"
"github.com/siulfe/gql/crypto"
"errors"
)
func (u *User) Create() error{
err := DDBB.GetDB().QueryRow(DDBB.CREATE_USER, u.Name,u.LastName,u.Identification,u.Age,u.Direccion.ID,u.Password,u.Rol).Scan(&u.ID)
return err
}
func (u *User) Delete() error{
row,err := DDBB.GetDB().Exec(DDBB.DELETE_USER,u.ID)
if err != nil{
return err
}
count,err := row.RowsAffected()
if count == 0{
return errors.New("No se ha eliminado ningun usuario")
}
return err
}
func (u *User) Update() error{
row,err := DDBB.GetDB().Exec(DDBB.UPDATE_USER,u.ID,u.Name,u.LastName,u.Identification,u.Age)
if err != nil{
return err
}
count, err:= row.RowsAffected()
if count == 0{
return errors.New("No se ha actualizado ningun usuario")
}
return err
}
func GetAllUsers() ([]*User,error){
var users []*User
rows, err := DDBB.GetDB().Query(DDBB.SELECT_USERS)
if err != nil{
return nil,err
}
for rows.Next(){
var user User = User{
Direccion: &Direccion{},
}
err :=rows.Scan(&user.ID,&user.Name,&user.LastName,&user.Identification,&user.Age,
&user.CreateAt,&user.UpdateAt,&user.Password,&user.Direccion.ID,&user.Direccion.Casa)
if err != nil{
return nil, err
}
users = append(users, &user)
}
return users,nil
}
func (u *User) Login() error{
var user User
err := DDBB.GetDB().QueryRow(DDBB.SELECT_USER_NAME, u.Name).Scan(&user.Password,&u.Rol,&u.ID)
if err != nil{
return err
}
if !crypto.ComparePassword(*u.Password, *user.Password){
return errors.New("Usuario invalido")
}
err = loged(u.ID)
return err
}
func loged(w int) error{
_,err := DDBB.GetDB().Exec(DDBB.LOGGED,w)
return err
}
func logoutUser(w int) error{
_,err := DDBB.GetDB().Exec(DDBB.DESLOGED,w)
return err
} |
package main
import "fmt"
const LIM = 40
func fibonacci() (func() int) {
back1, back2 := 0, 1
return func() int {
// 重新赋值
back1, back2 = back2, (back1 + back2)
return back1
}
}
func main() {
f := fibonacci() //返回一个闭包函数
var array [LIM]int
for i := 0; i < LIM; i++ {
array[i] = f()
}
fmt.Println(array)
}
|
package function
func NextPermutation(arr []int) bool {
// calculate the left index to swap
l := len(arr) - 2
for l >= 0 && arr[l] >= arr[l+1] {
l--
}
if l < 0 {
return false
}
// calculate the right index to swap
r := len(arr) - 1
for arr[l] >= arr[r] {
r--
}
// swap
arr[l], arr[r] = arr[r], arr[l]
// reverse elements between l and r
for l, r = l+1, len(arr)-1; l < r; l, r = l+1, r-1 {
arr[l], arr[r] = arr[r], arr[l]
}
return true
}
|
package machine
// RigStat is a status of machine
type RigStat struct {
GHS5s string
GHSAvarage string
MHS5s string
MHSAvarage string
KHS5s string
KHSAvarage string
Accepted string
Rejected string
HardwareErrors string
Utility string
System SystemStat
Devices []DeviceStat
Pools []PoolStat
}
type SystemStat struct {
TempCPU string
}
// DeviceStat is a status of each chip
type DeviceStat struct {
TempPCB string
TempChip string
Frequency string
Chips int
HardwareErrors string
Hashrate string
}
// PoolStat is a status of pool connection
type PoolStat struct {
URL string
User string
Algo string
Status string
StratumActive bool
Priority int
Getworks string
Accepted string
Rejected string
Discarded string
Stale string
DifficultyAccepted string
DifficultyRejected string
DifficultyStale string
LastShareDifficulty string
LastShareTime string
}
|
package game
import (
"fmt"
"testing"
"github.com/stretchr/testify/require"
)
func TestSuit_Left(t *testing.T) {
checkSuit := func(s, expected Suit) func(*testing.T) {
return func(t *testing.T) {
require.Equal(t, expected, s.Left())
}
}
t.Run("Clubs", checkSuit(SuitClubs, SuitSpades))
t.Run("Diamonds", checkSuit(SuitDiamonds, SuitHearts))
t.Run("Spades", checkSuit(SuitSpades, SuitClubs))
t.Run("Hearts", checkSuit(SuitHearts, SuitDiamonds))
}
func TestCard_Score(t *testing.T) {
checkScore := func(c Card, expected int, trump, lead Suit) func(*testing.T) {
return func(t *testing.T) {
require.Equal(t, expected, c.Score(trump, lead))
}
}
t.Run("Trump", func(t *testing.T) {
t.Run("Right Bower", checkScore(Card{SuitDiamonds, RankJack}, ScoreRightBower, SuitDiamonds, SuitDiamonds))
t.Run("Left Bower", checkScore(Card{SuitDiamonds.Left(), RankJack}, ScoreLeftBower, SuitDiamonds, SuitDiamonds))
t.Run("Ace", checkScore(Card{SuitDiamonds, RankAce}, TrumpScoreOffset+int(RankAce), SuitDiamonds, SuitDiamonds))
t.Run("King", checkScore(Card{SuitDiamonds, RankKing}, TrumpScoreOffset+int(RankKing), SuitDiamonds, SuitDiamonds))
t.Run("Queen", checkScore(Card{SuitDiamonds, RankQueen}, TrumpScoreOffset+int(RankQueen), SuitDiamonds, SuitDiamonds))
t.Run("10", checkScore(Card{SuitDiamonds, RankTen}, TrumpScoreOffset+int(RankTen), SuitDiamonds, SuitDiamonds))
t.Run("9", checkScore(Card{SuitDiamonds, RankNine}, TrumpScoreOffset+int(RankNine), SuitDiamonds, SuitDiamonds))
})
t.Run("Lead Suit", func(t *testing.T) {
t.Run("Ace", checkScore(Card{SuitDiamonds, RankAce}, int(RankAce), SuitClubs, SuitDiamonds))
t.Run("King", checkScore(Card{SuitDiamonds, RankKing}, int(RankKing), SuitClubs, SuitDiamonds))
t.Run("Queen", checkScore(Card{SuitDiamonds, RankQueen}, int(RankQueen), SuitClubs, SuitDiamonds))
t.Run("Jack", checkScore(Card{SuitDiamonds, RankJack}, int(RankJack), SuitClubs, SuitDiamonds))
t.Run("10", checkScore(Card{SuitDiamonds, RankTen}, int(RankTen), SuitClubs, SuitDiamonds))
t.Run("9", checkScore(Card{SuitDiamonds, RankNine}, int(RankNine), SuitClubs, SuitDiamonds))
t.Run("Left Bower", checkScore(Card{SuitDiamonds, RankJack}, ScoreLeftBower, SuitHearts, SuitDiamonds))
})
t.Run("Other Suits", func(t *testing.T) {
for r := RankNine; r <= RankAce; r++ {
t.Run(fmt.Sprintf("Rank %d", r), checkScore(Card{SuitDiamonds, r}, 0, SuitClubs, SuitClubs))
}
})
}
func TestCard_BetterThan(t *testing.T) {
checkBeats := func(c, other Card, trump, lead Suit) func(*testing.T) {
return func(t *testing.T) {
require.True(t, c.BetterThan(&other, trump, lead))
}
}
checkBeatsAllInSuit := func(c Card, target, trump, lead Suit) func(*testing.T) {
return func(t *testing.T) {
for r := RankAce; r >= RankNine; r-- {
t.Run(fmt.Sprintf("Beats Rank %d in Suit %d", r, target), checkBeats(c, Card{target, r}, trump, lead))
}
}
}
t.Run("Right Bower", func(t *testing.T) {
bower := Card{SuitClubs, RankJack}
for s := SuitDiamonds; s <= SuitSpades; s++ {
t.Run(fmt.Sprintf("Beats everythign in suit %d", s), checkBeatsAllInSuit(bower, s, SuitClubs, SuitClubs))
}
})
t.Run("Left Bower", func(t *testing.T) {
bower := Card{SuitSpades, RankJack}
t.Run("Beats Ace of Trump", checkBeats(bower, Card{SuitClubs, RankAce}, SuitClubs, SuitClubs))
t.Run("Beats King of Trump", checkBeats(bower, Card{SuitClubs, RankKing}, SuitClubs, SuitClubs))
t.Run("Beats Queen of Trump", checkBeats(bower, Card{SuitClubs, RankQueen}, SuitClubs, SuitClubs))
t.Run("Beats Ten of Trump", checkBeats(bower, Card{SuitClubs, RankTen}, SuitClubs, SuitClubs))
t.Run("Beats Nine of Trump", checkBeats(bower, Card{SuitClubs, RankNine}, SuitClubs, SuitClubs))
for s := SuitDiamonds; s <= SuitSpades; s++ {
t.Run(fmt.Sprintf("Beats everythign in suit %d", s), checkBeatsAllInSuit(bower, s, SuitClubs, SuitClubs))
}
})
t.Run("Lead beats non-trump", checkBeats(Card{SuitClubs, RankAce}, Card{SuitSpades, RankAce}, SuitDiamonds, SuitClubs))
}
|
package database
import (
"reflect"
"testing"
"github.com/DATA-DOG/go-sqlmock"
"github.com/google/uuid"
"github.com/jmoiron/sqlx"
"github.com/sumelms/microservice-course/internal/course/domain"
utils "github.com/sumelms/microservice-course/tests"
)
var (
course = domain.Course{
ID: 1,
UUID: utils.CourseUUID,
Code: "SUME123",
Name: "Course Name",
Underline: "Course Underline",
Image: "image.png",
ImageCover: "image_cover.png",
Excerpt: "Course Excerpt",
Description: "Course Description",
CreatedAt: utils.Now,
UpdatedAt: utils.Now,
DeletedAt: nil,
}
)
func newCourseTestDB() (*sqlx.DB, sqlmock.Sqlmock, map[string]*sqlmock.ExpectedPrepare) {
return utils.NewTestDB(queriesCourse())
}
func TestRepository_Course(t *testing.T) {
validRows := sqlmock.NewRows([]string{"id", "uuid", "code", "name", "underline", "image", "image_cover", "excerpt",
"description", "created_at", "updated_at", "deleted_at"}).
AddRow(course.ID, course.UUID, course.Code, course.Name, course.Underline, course.Image, course.ImageCover,
course.Excerpt, course.Description, course.CreatedAt, course.UpdatedAt, course.DeletedAt)
type args struct {
id uuid.UUID
}
tests := []struct {
name string
args args
rows *sqlmock.Rows
want domain.Course
wantErr bool
}{
{
name: "get course",
args: args{id: course.UUID},
rows: validRows,
want: course,
wantErr: false,
},
{
name: "course not found error",
args: args{id: uuid.MustParse("6cd7a01c-ff18-4cfb-9b35-16e710115c5f")},
rows: utils.EmptyRows,
want: domain.Course{},
wantErr: true,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
db, _, stmts := newCourseTestDB()
r, err := NewCourseRepository(db)
if err != nil {
t.Fatalf("an error '%s' was not expected when creating the courseRepository", err)
}
prep, ok := stmts[getCourse]
if !ok {
t.Fatalf("prepared statement %s not found", getCourse)
}
prep.ExpectQuery().WithArgs(utils.CourseUUID).WillReturnRows(validRows)
got, err := r.Course(tt.args.id)
if (err != nil) != tt.wantErr {
t.Errorf("Course() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("Course() got = %v, want %v", got, tt.want)
}
})
}
}
func TestRepository_Courses(t *testing.T) {
validRows := sqlmock.NewRows([]string{"id", "uuid", "code", "name", "underline", "image", "image_cover", "excerpt",
"description", "created_at", "updated_at", "deleted_at"}).
AddRow(course.ID, course.UUID, course.Code, course.Name, course.Underline, course.Image, course.ImageCover,
course.Excerpt, course.Description, course.CreatedAt, course.UpdatedAt, course.DeletedAt).
AddRow(2, uuid.MustParse("7aec21ad-2fa8-4ddd-b5af-073144031ecc"), course.Code, course.Name,
course.Underline, course.Image, course.ImageCover, course.Excerpt, course.Description, course.CreatedAt,
course.UpdatedAt, course.DeletedAt)
tests := []struct {
name string
rows *sqlmock.Rows
wantLen int
wantErr bool
}{
{
name: "get all courses",
rows: validRows,
wantLen: 2,
wantErr: false,
},
{
name: "get no courses",
rows: utils.EmptyRows,
wantLen: 0,
wantErr: false,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
db, _, stmts := newCourseTestDB()
r, err := NewCourseRepository(db)
if err != nil {
t.Fatalf("an error '%s' was not expected when creating the courseRepository", err)
}
prep, ok := stmts[listCourse]
if !ok {
t.Fatalf("prepared statement %s not found", getCourse)
}
prep.ExpectQuery().WillReturnRows(tt.rows)
got, err := r.Courses()
if (err != nil) != tt.wantErr {
t.Errorf("Courses() error = %v, wantErr %v", err, tt.wantErr)
return
}
if len(got) != tt.wantLen {
t.Errorf("Courses() got = %v, want %v", got, tt.wantLen)
}
})
}
}
func TestRepository_CreateCourse(t *testing.T) {
validRows := sqlmock.NewRows([]string{"id", "uuid", "code", "name", "underline", "image", "image_cover", "excerpt",
"description", "created_at", "updated_at", "deleted_at"}).
AddRow(course.ID, course.UUID, course.Code, course.Name, course.Underline, course.Image, course.ImageCover,
course.Excerpt, course.Description, course.CreatedAt, course.UpdatedAt, course.DeletedAt)
type args struct {
c *domain.Course
}
tests := []struct {
name string
rows *sqlmock.Rows
args args
wantErr bool
}{
{
name: "create course",
rows: validRows,
args: args{c: &course},
wantErr: false,
},
{
name: "empty fields",
rows: utils.EmptyRows,
args: args{c: &course},
wantErr: true,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
db, _, stmts := newCourseTestDB()
r, err := NewCourseRepository(db)
if err != nil {
t.Fatalf("an error '%s' was not expected when creating the courseRepository", err)
}
prep, ok := stmts[createCourse]
if !ok {
t.Fatalf("prepared statement %s not found", getCourse)
}
prep.ExpectQuery().WillReturnRows(tt.rows)
if err := r.CreateCourse(tt.args.c); (err != nil) != tt.wantErr {
t.Errorf("CreateCourse() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestRepository_UpdateCourse(t *testing.T) {
validRows := sqlmock.NewRows([]string{"id", "uuid", "code", "name", "underline", "image", "image_cover", "excerpt",
"description", "created_at", "updated_at", "deleted_at"}).
AddRow(course.ID, course.UUID, course.Code, course.Name, course.Underline, course.Image, course.ImageCover,
course.Excerpt, course.Description, course.CreatedAt, course.UpdatedAt, course.DeletedAt)
type args struct {
c *domain.Course
}
tests := []struct {
name string
args args
rows *sqlmock.Rows
wantErr bool
}{
{
name: "update course",
args: args{c: &course},
rows: validRows,
wantErr: false,
},
{
name: "empty course",
args: args{c: &domain.Course{}},
rows: utils.EmptyRows,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
db, _, stmts := newCourseTestDB()
r, err := NewCourseRepository(db)
if err != nil {
t.Fatalf("an error '%s' was not expected when creating the courseRepository", err)
}
prep, ok := stmts[updateCourse]
if !ok {
t.Fatalf("prepared statement %s not found", updateCourse)
}
prep.ExpectQuery().WillReturnRows(tt.rows)
if err := r.UpdateCourse(tt.args.c); (err != nil) != tt.wantErr {
t.Errorf("UpdateCourse() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
|
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
package helpers
import (
"bytes"
"crypto/rand"
"crypto/rsa"
"crypto/x509"
"crypto/x509/pkix"
"encoding/pem"
"errors"
"fmt"
"math/big"
"net"
"time"
"golang.org/x/sync/errgroup"
log "github.com/sirupsen/logrus"
)
const (
// ValidityDuration specifies the duration an TLS certificate is valid
ValidityDuration = time.Hour * 24 * 365 * 30
)
// PkiParams is used when we create Pki
type PkiParams struct {
ExtraFQDNs []string
ExtraIPs []net.IP
ClusterDomain string
CaPair *PkiKeyCertPair
MasterCount int
PkiKeySize int
}
// PkiKeyCertPairParams is the params when we create the pki key cert pair.
type PkiKeyCertPairParams struct {
CommonName string
PkiKeySize int
}
// PkiKeyCertPair represents an PKI public and private cert pair
type PkiKeyCertPair struct {
CertificatePem string
PrivateKeyPem string
}
// CreatePkiKeyCertPair generates a pair of PKI certificate and private key
func CreatePkiKeyCertPair(params PkiKeyCertPairParams) (*PkiKeyCertPair, error) {
certPram := certParams{
commonName: params.CommonName,
caCertificate: nil,
caPrivateKey: nil,
isEtcd: false,
isServer: false,
extraFQDNs: nil,
extraIPs: nil,
organization: nil,
keySize: params.PkiKeySize,
}
caCertificate, caPrivateKey, err := createCertificate(certPram)
if err != nil {
return nil, err
}
caPair := &PkiKeyCertPair{CertificatePem: string(certificateToPem(caCertificate.Raw)), PrivateKeyPem: string(privateKeyToPem(caPrivateKey))}
return caPair, nil
}
// CreatePki creates PKI certificates
func CreatePki(pkiParams PkiParams) (*PkiKeyCertPair, *PkiKeyCertPair, *PkiKeyCertPair, *PkiKeyCertPair, *PkiKeyCertPair, []*PkiKeyCertPair, error) {
start := time.Now()
defer func(s time.Time) {
log.Debugf("pki: PKI asset creation took %s", time.Since(s))
}(start)
pkiParams.ExtraFQDNs = append(pkiParams.ExtraFQDNs, "kubernetes")
pkiParams.ExtraFQDNs = append(pkiParams.ExtraFQDNs, "kubernetes.default")
pkiParams.ExtraFQDNs = append(pkiParams.ExtraFQDNs, "kubernetes.default.svc")
pkiParams.ExtraFQDNs = append(pkiParams.ExtraFQDNs, fmt.Sprintf("kubernetes.default.svc.%s", pkiParams.ClusterDomain))
pkiParams.ExtraFQDNs = append(pkiParams.ExtraFQDNs, "kubernetes.kube-system")
pkiParams.ExtraFQDNs = append(pkiParams.ExtraFQDNs, "kubernetes.kube-system.svc")
pkiParams.ExtraFQDNs = append(pkiParams.ExtraFQDNs, fmt.Sprintf("kubernetes.kube-system.svc.%s", pkiParams.ClusterDomain))
var (
caCertificate *x509.Certificate
caPrivateKey *rsa.PrivateKey
apiServerCertificate *x509.Certificate
apiServerPrivateKey *rsa.PrivateKey
clientCertificate *x509.Certificate
clientPrivateKey *rsa.PrivateKey
kubeConfigCertificate *x509.Certificate
kubeConfigPrivateKey *rsa.PrivateKey
etcdServerCertificate *x509.Certificate
etcdServerPrivateKey *rsa.PrivateKey
etcdClientCertificate *x509.Certificate
etcdClientPrivateKey *rsa.PrivateKey
etcdPeerCertPairs []*PkiKeyCertPair
)
var group errgroup.Group
var err error
caCertificate, err = pemToCertificate(pkiParams.CaPair.CertificatePem)
if err != nil {
return nil, nil, nil, nil, nil, nil, err
}
caPrivateKey, err = pemToKey(pkiParams.CaPair.PrivateKeyPem)
if err != nil {
return nil, nil, nil, nil, nil, nil, err
}
group.Go(func() (err error) {
certPram := certParams{
commonName: "apiserver",
caCertificate: caCertificate,
caPrivateKey: caPrivateKey,
isEtcd: false,
isServer: true,
extraFQDNs: pkiParams.ExtraFQDNs,
extraIPs: pkiParams.ExtraIPs,
organization: nil,
keySize: pkiParams.PkiKeySize,
}
apiServerCertificate, apiServerPrivateKey, err = createCertificate(certPram)
return err
})
group.Go(func() (err error) {
organization := make([]string, 1)
organization[0] = "system:masters"
certPram := certParams{
commonName: "client",
caCertificate: caCertificate,
caPrivateKey: caPrivateKey,
isEtcd: false,
isServer: false,
extraFQDNs: nil,
extraIPs: nil,
organization: organization,
keySize: pkiParams.PkiKeySize,
}
clientCertificate, clientPrivateKey, err = createCertificate(certPram)
return err
})
group.Go(func() (err error) {
organization := make([]string, 1)
organization[0] = "system:masters"
certPram := certParams{
commonName: "client",
caCertificate: caCertificate,
caPrivateKey: caPrivateKey,
isEtcd: false,
isServer: false,
extraFQDNs: nil,
extraIPs: nil,
organization: organization,
keySize: pkiParams.PkiKeySize,
}
kubeConfigCertificate, kubeConfigPrivateKey, err = createCertificate(certPram)
return err
})
group.Go(func() (err error) {
certPram := certParams{
commonName: "etcdserver",
caCertificate: caCertificate,
caPrivateKey: caPrivateKey,
isEtcd: true,
isServer: true,
extraFQDNs: nil,
extraIPs: pkiParams.ExtraIPs,
organization: nil,
keySize: pkiParams.PkiKeySize,
}
etcdServerCertificate, etcdServerPrivateKey, err = createCertificate(certPram)
return err
})
group.Go(func() (err error) {
certPram := certParams{
commonName: "etcdclient",
caCertificate: caCertificate,
caPrivateKey: caPrivateKey,
isEtcd: true,
isServer: false,
extraFQDNs: nil,
extraIPs: pkiParams.ExtraIPs,
organization: nil,
keySize: pkiParams.PkiKeySize,
}
etcdClientCertificate, etcdClientPrivateKey, err = createCertificate(certPram)
return err
})
etcdPeerCertPairs = make([]*PkiKeyCertPair, pkiParams.MasterCount)
for i := 0; i < pkiParams.MasterCount; i++ {
i := i
group.Go(func() (err error) {
certPram := certParams{
commonName: "etcdpeer",
caCertificate: caCertificate,
caPrivateKey: caPrivateKey,
isEtcd: true,
isServer: false,
extraFQDNs: nil,
extraIPs: pkiParams.ExtraIPs,
organization: nil,
keySize: pkiParams.PkiKeySize,
}
etcdPeerCertificate, etcdPeerPrivateKey, err := createCertificate(certPram)
etcdPeerCertPairs[i] = &PkiKeyCertPair{CertificatePem: string(certificateToPem(etcdPeerCertificate.Raw)), PrivateKeyPem: string(privateKeyToPem(etcdPeerPrivateKey))}
return err
})
}
if err := group.Wait(); err != nil {
return nil, nil, nil, nil, nil, nil, err
}
return &PkiKeyCertPair{CertificatePem: string(certificateToPem(apiServerCertificate.Raw)), PrivateKeyPem: string(privateKeyToPem(apiServerPrivateKey))},
&PkiKeyCertPair{CertificatePem: string(certificateToPem(clientCertificate.Raw)), PrivateKeyPem: string(privateKeyToPem(clientPrivateKey))},
&PkiKeyCertPair{CertificatePem: string(certificateToPem(kubeConfigCertificate.Raw)), PrivateKeyPem: string(privateKeyToPem(kubeConfigPrivateKey))},
&PkiKeyCertPair{CertificatePem: string(certificateToPem(etcdServerCertificate.Raw)), PrivateKeyPem: string(privateKeyToPem(etcdServerPrivateKey))},
&PkiKeyCertPair{CertificatePem: string(certificateToPem(etcdClientCertificate.Raw)), PrivateKeyPem: string(privateKeyToPem(etcdClientPrivateKey))},
etcdPeerCertPairs,
nil
}
type certParams struct {
commonName string
caCertificate *x509.Certificate
caPrivateKey *rsa.PrivateKey
isEtcd bool
isServer bool
extraFQDNs []string
extraIPs []net.IP
organization []string
keySize int
}
func createCertificate(options certParams) (*x509.Certificate, *rsa.PrivateKey, error) {
var err error
isCA := (options.caCertificate == nil)
now := time.Now()
template := x509.Certificate{
Subject: pkix.Name{CommonName: options.commonName},
NotBefore: now,
NotAfter: now.Add(ValidityDuration),
KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
BasicConstraintsValid: true,
}
if options.organization != nil {
template.Subject.Organization = options.organization
}
if isCA {
template.KeyUsage |= x509.KeyUsageCertSign
template.IsCA = isCA
} else if options.isEtcd {
if options.commonName == "etcdServer" {
template.IPAddresses = options.extraIPs
template.ExtKeyUsage = append(template.ExtKeyUsage, x509.ExtKeyUsageServerAuth)
} else if options.commonName == "etcdClient" {
template.IPAddresses = options.extraIPs
template.ExtKeyUsage = append(template.ExtKeyUsage, x509.ExtKeyUsageClientAuth)
} else {
template.IPAddresses = options.extraIPs
template.ExtKeyUsage = append(template.ExtKeyUsage, x509.ExtKeyUsageServerAuth)
template.ExtKeyUsage = append(template.ExtKeyUsage, x509.ExtKeyUsageClientAuth)
}
} else if options.isServer {
template.DNSNames = options.extraFQDNs
template.IPAddresses = options.extraIPs
template.ExtKeyUsage = append(template.ExtKeyUsage, x509.ExtKeyUsageServerAuth)
} else {
template.ExtKeyUsage = append(template.ExtKeyUsage, x509.ExtKeyUsageClientAuth)
}
snMax := new(big.Int).Lsh(big.NewInt(1), 128)
template.SerialNumber, err = rand.Int(rand.Reader, snMax)
if err != nil {
return nil, nil, err
}
privateKey, _ := rsa.GenerateKey(rand.Reader, options.keySize)
var privateKeyToUse *rsa.PrivateKey
var certificateToUse *x509.Certificate
if !isCA {
privateKeyToUse = options.caPrivateKey
certificateToUse = options.caCertificate
} else {
privateKeyToUse = privateKey
certificateToUse = &template
}
certDerBytes, err := x509.CreateCertificate(rand.Reader, &template, certificateToUse, &privateKey.PublicKey, privateKeyToUse)
if err != nil {
return nil, nil, err
}
certificate, err := x509.ParseCertificate(certDerBytes)
if err != nil {
return nil, nil, err
}
return certificate, privateKey, nil
}
func certificateToPem(derBytes []byte) []byte {
pemBlock := &pem.Block{
Type: "CERTIFICATE",
Bytes: derBytes,
}
pemBuffer := bytes.Buffer{}
_ = pem.Encode(&pemBuffer, pemBlock)
return pemBuffer.Bytes()
}
func privateKeyToPem(privateKey *rsa.PrivateKey) []byte {
pemBlock := &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
}
pemBuffer := bytes.Buffer{}
_ = pem.Encode(&pemBuffer, pemBlock)
return pemBuffer.Bytes()
}
func pemToCertificate(raw string) (*x509.Certificate, error) {
cpb, _ := pem.Decode([]byte(raw))
if cpb == nil {
return nil, errors.New("The raw pem is not a valid PEM formatted block")
}
return x509.ParseCertificate(cpb.Bytes)
}
func pemToKey(raw string) (*rsa.PrivateKey, error) {
kpb, _ := pem.Decode([]byte(raw))
if kpb == nil {
return nil, errors.New("The raw pem is not a valid PEM formatted block")
}
return x509.ParsePKCS1PrivateKey(kpb.Bytes)
}
|
package base
import (
"errors"
"fmt"
"gengine/context"
"gengine/internal/core"
"reflect"
)
//support map or array
type MapVar struct {
SourceCode
Name string // map name
Intkey int64 // array index
Strkey string // map key
Varkey string // array index or map key
}
func (m *MapVar) Evaluate(dc *context.DataContext, Vars map[string]reflect.Value) (reflect.Value, error) {
value, e := dc.GetValue(Vars, m.Name)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
var newValue reflect.Value
if value.Kind() == reflect.Ptr {
newValue = value.Elem()
if newValue.Kind() == reflect.Map {
keyType := newValue.Type().Key()
if len(m.Varkey) > 0 {
key, e := dc.GetValue(Vars, m.Varkey)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
wantedKey, e := core.GetWantedValue(key, keyType)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
mv := value.Elem().MapIndex(wantedKey)
if mv.IsValid() {
return mv, nil
} else {
return reflect.Zero(value.Type().Elem().Elem()), nil
}
}
if len(m.Strkey) > 0 {
mv := value.Elem().MapIndex(reflect.ValueOf(m.Strkey))
if mv.IsValid() {
return mv, nil
} else {
return reflect.Zero(value.Type().Elem().Elem()), nil
}
}
wantedKey, e := core.GetWantedValue(reflect.ValueOf(m.Intkey), keyType)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
mv := value.Elem().MapIndex(wantedKey)
if mv.IsValid() {
return mv, nil
} else {
return reflect.Zero(value.Type().Elem().Elem()), nil
}
}
if newValue.Kind() == reflect.Slice || newValue.Kind() == reflect.Array {
if len(m.Varkey) > 0 {
wantedKey, e := dc.GetValue(Vars, m.Varkey)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
return value.Elem().Index(int(wantedKey.Int())), nil
}
if len(m.Strkey) > 0 {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %s", m.LineNum, m.Column, m.Code, " the index of array and slice should not be string"))
}
if m.Intkey >= 0 {
return value.Elem().Index(int(m.Intkey)), nil
} else {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code %s, Slice or Array index must be non-negative!", m.LineNum, m.Column, m.Code))
}
}
} else {
newValue = value
if newValue.Kind() == reflect.Map {
keyType := newValue.Type().Key()
if len(m.Varkey) > 0 {
key, e := dc.GetValue(Vars, m.Varkey)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
wantedKey, e := core.GetWantedValue(key, keyType)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
mv := value.MapIndex(wantedKey)
if mv.IsValid() {
return mv, nil
} else {
return reflect.Zero(value.Type().Elem()), nil
}
}
if len(m.Strkey) > 0 {
mv := value.MapIndex(reflect.ValueOf(m.Strkey))
if mv.IsValid() {
return mv, nil
} else {
return reflect.Zero(value.Type().Elem()), nil
}
}
wantedKey, e := core.GetWantedValue(reflect.ValueOf(m.Intkey), keyType)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
mv := value.MapIndex(wantedKey)
if mv.IsValid() {
return mv, nil
} else {
return reflect.Zero(value.Type().Elem()), nil
}
}
if newValue.Kind() == reflect.Slice || newValue.Kind() == reflect.Array {
if len(m.Varkey) > 0 {
wantedKey, e := dc.GetValue(Vars, m.Varkey)
if e != nil {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %+v", m.LineNum, m.Column, m.Code, e))
}
return value.Index(int(wantedKey.Int())), nil
}
if len(m.Strkey) > 0 {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, %s", m.LineNum, m.Column, m.Code, " the index of array and slice should not be string"))
}
if m.Intkey >= 0 {
return value.Index(int(m.Intkey)), nil
} else {
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code %s, Slice or Array index must be non-negative!", m.LineNum, m.Column, m.Code))
}
}
}
return reflect.ValueOf(nil), errors.New(fmt.Sprintf("line %d, column %d, code: %s, Evaluate MapVarValue Only support directly-Pointer-Map, directly-Pointer-Slice and directly-Pointer-Array or Map, Slice and Array in Pointer-Struct!", m.LineNum, m.Column, m.Code))
}
func (m *MapVar) AcceptVariable(name string) error {
if len(m.Name) == 0 {
m.Name = name
return nil
}
if len(m.Varkey) == 0 {
m.Varkey = name
return nil
}
return errors.New("MapVar's Varkey set three times! ")
}
func (m *MapVar) AcceptInteger(i64 int64) error {
m.Intkey = i64
return nil
}
func (m *MapVar) AcceptString(str string) error {
if len(m.Strkey) == 0 {
m.Strkey = str
return nil
}
return errors.New("MapVar's Strkey set three times! ")
}
|
package openssl
import (
"github.com/root-gg/utils"
)
// Config object
type Config struct {
Openssl string
Cipher string
Passphrase string
Options string
}
// NewOpenSSLBackendConfig instantiate a new Backend Configuration
// from config map passed as argument
func NewOpenSSLBackendConfig(params map[string]interface{}) (config *Config) {
config = new(Config)
config.Openssl = "/usr/bin/openssl"
config.Cipher = "aes-256-cbc"
config.Options = "-md sha512 -pbkdf2 -iter 120000"
utils.Assign(config, params)
return
}
|
package auth
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider"
"github.com/gofor-little/xerror"
)
// ChangePassword changes a user's password.
//
// - Use auth.ForgotPassword if the user doesn't know their password.
//
// - Use auth.UpdateExpiredPassword if the user has a requirement for their password to be changed.
func ChangePassword(ctx context.Context, accessToken string, oldPassword string, newPassword string) error {
if err := checkPackage(); err != nil {
return xerror.Wrap("checkPackage call failed", err)
}
if _, err := CognitoClient.ChangePassword(ctx, &cognitoidentityprovider.ChangePasswordInput{
AccessToken: aws.String(accessToken),
PreviousPassword: aws.String(oldPassword),
ProposedPassword: aws.String(newPassword),
}); err != nil {
return xerror.Wrap("failed to change password", err)
}
return nil
}
|
package i2pgateconfig
import (
"os"
"testing"
"github.com/RTradeLtd/go-garlic-tcp-transport"
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
)
var configPath = "./"
// Test_config tries to create a config file
func Test_Config(t *testing.T) {
err := os.Setenv("KEYS_PATH", configPath)
if err != nil {
t.Fatal("")
}
config, err := fsrepo.ConfigAt(configPath)
if err != nil {
t.Fatal(err)
}
rpcaddressbytes, err := config.Addresses.API.MarshalJSON()
if err != nil {
t.Fatal(err)
}
forwardRPC := string(rpcaddressbytes)
httpaddressbytes, err := config.Addresses.Gateway.MarshalJSON()
if err != nil {
t.Fatal(err)
}
forwardHTTP := string(httpaddressbytes)
i2pconfig, err := ConfigAt(configPath)
if err != nil {
t.Fatal(err)
}
err = AddressRPC(forwardRPC, i2pconfig)
if err != nil {
t.Fatal(err)
}
err = AddressHTTP(forwardHTTP, i2pconfig)
if err != nil {
t.Fatal(err)
}
_, err = i2pconfig.Save(configPath)
if err != nil {
t.Fatal(err)
}
transportHTTP(i2pconfig)
transportRPC(i2pconfig)
}
func transportHTTP(i2pconfig *Config) error {
GarlicTCPTransport, err := i2ptcp.NewGarlicTCPTransportFromOptions(
i2ptcp.SAMHost(i2pconfig.SAMHost),
i2ptcp.SAMPort(i2pconfig.SAMPort),
i2ptcp.SAMPass(""),
i2ptcp.KeysPath(configPath+".i2pkeys"),
i2ptcp.OnlyGarlic(i2pconfig.OnlyI2P),
i2ptcp.GarlicOptions(i2pconfig.Print()),
)
if err != nil {
return err
}
GarlicTCPConn, err := GarlicTCPTransport.ListenI2P()
if err != nil {
return err
}
err = ListenerBase32(GarlicTCPConn.Base32(), i2pconfig)
if err != nil {
return err
}
err = ListenerBase64(GarlicTCPConn.Base64(), i2pconfig)
if err != nil {
return err
}
_, err = i2pconfig.Save(configPath)
if err != nil {
return err
}
return nil
}
func transportRPC(i2pconfig *Config) error {
GarlicTCPTransport, err := i2ptcp.NewGarlicTCPTransportFromOptions(
i2ptcp.SAMHost(i2pconfig.SAMHost),
i2ptcp.SAMPort(i2pconfig.SAMPort),
i2ptcp.SAMPass(""),
i2ptcp.KeysPath(configPath+".i2pkeys"),
i2ptcp.OnlyGarlic(i2pconfig.OnlyI2P),
i2ptcp.GarlicOptions(i2pconfig.Print()),
)
if err != nil {
return err
}
GarlicTCPConn, err := GarlicTCPTransport.ListenI2P()
if err != nil {
return err
}
err = ListenerBase32RPC(GarlicTCPConn.Base32(), i2pconfig)
if err != nil {
return err
}
err = ListenerBase64RPC(GarlicTCPConn.Base64(), i2pconfig)
if err != nil {
return err
}
_, err = i2pconfig.Save(configPath)
if err != nil {
return err
}
return nil
}
|
package toggle
var Symbol = map[string]map[string]string{
"star": map[string]string{
"filled": "★",
"empty": "☆",
},
"flag": map[string]string{
"filled": "⚑",
"empty": "⚐",
},
"heart": map[string]string{
"filled": "♡",
"empty": "♡",
},
}
|
package schema
import (
"time"
"entgo.io/ent"
"entgo.io/ent/schema/edge"
"entgo.io/ent/schema/field"
)
// GroupBandwidth holds the schema definition for the GroupBandwidth entity.
type GroupBandwidth struct {
ent.Schema
}
// Fields of the GroupBandwidth.
func (GroupBandwidth) Fields() []ent.Field {
return []ent.Field{
field.Int("gbw_download_speed"),
field.Int("gbw_upload_speed"),
field.Time("gbw_created_at").Default(time.Now).Optional(),
}
}
// Edges of the GroupBandwidth.
func (GroupBandwidth) Edges() []ent.Edge {
return []ent.Edge{
edge.To("groups", Groups.Type),
}
}
|
package main
import (
"errors"
"fmt"
"strconv"
"strings"
)
// This file is the most likely to change between years and contains specific intcode instruction implementations
const IntCodeCpy = "cpy";
const IntCodeInc = "inc";
const IntCodeDec = "dec";
const IntCodeJump = "jnz";
func ParseIntcodeInstruction(line string, lineNum int) (IntcodeInstruction, error){
parts := strings.Split(line, " ");
var res IntcodeInstruction;
op := strings.TrimSpace(parts[0]);
switch(op){
case IntCodeCpy:
res = &IntCodeInstructionCopy{};
case IntCodeInc:
res = &IntCodeInstructionInc{};
case IntCodeDec:
res = &IntCodeInstructionDec{};
case IntCodeJump:
res = &IntCodeInstructionJump{};
break;
}
if(res == nil){
return nil, errors.New("Unknown op code " + op);
}
res.Init(lineNum);
err := res.Parse(parts);
if(err != nil){
return nil, err;
}
return res, nil;
}
type IntCodeInstructionCopy struct{
RegisterSource int;
HasLiteralSource bool;
RegisterTarget int;
LineNum int;
}
func (this *IntCodeInstructionCopy) Init(lineNum int){
this.LineNum = lineNum
}
func (this *IntCodeInstructionCopy) Execute(machine *IntcodeMachine) (bool, error) {
val := this.RegisterSource;
if(!this.HasLiteralSource){
val = machine.GetRegisterValue(val);
}
machine.SetRegisterValue(this.RegisterTarget, val);
machine.AdvanceInstructionPointer();
return false, nil;
}
func (this *IntCodeInstructionCopy) Describe() string {
if(this.HasLiteralSource){
return fmt.Sprintf("%d.) %s %d %c", this.LineNum, IntCodeCpy, this.RegisterSource, this.RegisterTarget);
} else{
return fmt.Sprintf("%d.) %s %c %c", this.LineNum, IntCodeCpy, this.RegisterSource, this.RegisterTarget);
}
}
func (this *IntCodeInstructionCopy) Parse(lineParts []string) error {
if(len(lineParts) != 3){
return errors.New("Incorrect number of args to copy instruction");
}
regRaw := strings.TrimSpace(lineParts[1]);
val, err := strconv.Atoi(regRaw);
if(err != nil){
this.RegisterSource = int(lineParts[1][0]); // Interpret this as an ascii value instead
} else{
this.RegisterSource = val;
this.HasLiteralSource = true;
}
regTarget := strings.TrimSpace(lineParts[2]);
val, err = strconv.Atoi(regTarget);
if(err != nil){
this.RegisterTarget = int(lineParts[2][0]); // Interpret this as an ascii value instead
} else{
this.RegisterTarget = val;
}
return nil;
}
type IntCodeInstructionJump struct{
RegisterSource int;
HasLiteralSource bool;
JumpAmount int;
LineNum int;
}
func (this *IntCodeInstructionJump) Init(lineNum int){
this.LineNum = lineNum
}
func (this *IntCodeInstructionJump) Execute(machine *IntcodeMachine) (bool, error) {
val := this.RegisterSource;
if(!this.HasLiteralSource){
val = machine.GetRegisterValue(val);
}
if(val != 0){
machine.AdvanceInstructionPointerByAmount(this.JumpAmount);
} else{
machine.AdvanceInstructionPointer();
}
return false, nil;
}
func (this *IntCodeInstructionJump) Describe() string {
if(this.HasLiteralSource){
return fmt.Sprintf("%d.) %s %d %c", this.LineNum, IntCodeJump, this.RegisterSource, this.JumpAmount);
} else{
return fmt.Sprintf("%d.) %s %c %c", this.LineNum, IntCodeJump, this.RegisterSource, this.JumpAmount);
}
}
func (this *IntCodeInstructionJump) Parse(lineParts []string) error {
if(len(lineParts) != 3){
return errors.New("Incorrect number of args to jump instruction");
}
regRaw := strings.TrimSpace(lineParts[1]);
val, err := strconv.Atoi(regRaw);
if(err != nil){
this.RegisterSource = int(lineParts[1][0]); // Interpret this as an ascii value instead
} else{
this.RegisterSource = val;
this.HasLiteralSource = true;
}
regTarget := strings.TrimSpace(lineParts[2]);
val, err = strconv.Atoi(regTarget);
if(err != nil){
return err;
} else{
this.JumpAmount = val;
}
return nil;
}
type IntCodeInstructionInc struct{
RegisterTarget int;
LineNum int;
}
func (this *IntCodeInstructionInc) Init(lineNum int){
this.LineNum = lineNum
}
func (this *IntCodeInstructionInc) Execute(machine *IntcodeMachine) (bool, error) {
val := this.RegisterTarget;
val = machine.GetRegisterValue(val);
val++;
machine.SetRegisterValue(this.RegisterTarget, val);
machine.AdvanceInstructionPointer();
return false, nil;
}
func (this *IntCodeInstructionInc) Describe() string {
return fmt.Sprintf("%d.) %s %c", this.LineNum, IntCodeInc, this.RegisterTarget);
}
func (this *IntCodeInstructionInc) Parse(lineParts []string) error {
if(len(lineParts) != 2){
return errors.New("Incorrect number of args to inc instruction");
}
this.RegisterTarget = int(lineParts[1][0]); // Interpret this as an ascii value
return nil;
}
type IntCodeInstructionDec struct{
RegisterTarget int;
LineNum int;
}
func (this *IntCodeInstructionDec) Init(lineNum int){
this.LineNum = lineNum
}
func (this *IntCodeInstructionDec) Execute(machine *IntcodeMachine) (bool, error) {
val := this.RegisterTarget;
val = machine.GetRegisterValue(val);
val--;
machine.SetRegisterValue(this.RegisterTarget, val);
machine.AdvanceInstructionPointer();
return false, nil;
}
func (this *IntCodeInstructionDec) Describe() string {
return fmt.Sprintf("%d.) %s %c", this.LineNum, IntCodeDec, this.RegisterTarget);
}
func (this *IntCodeInstructionDec) Parse(lineParts []string) error {
if(len(lineParts) != 2){
return errors.New("Incorrect number of args to dec instruction");
}
this.RegisterTarget = int(lineParts[1][0]); // Interpret this as an ascii value
return nil;
}
|
package resources
import (
"code.cloudfoundry.org/cli/cf/api/resources"
"encoding/json"
"fmt"
"github.com/andreasf/cf-mysql-plugin/cfmysql/models"
"strconv"
"strings"
)
type ServiceBindingResource struct {
resources.Resource
Entity ServiceBindingEntity
}
type ServiceBindingEntity struct {
AppGUID string `json:"app_guid"`
ServiceInstanceGUID string `json:"service_instance_guid"`
Credentials MysqlCredentials `json:"credentials"`
}
type MysqlCredentials struct {
Uri string `json:"uri"`
DbName string `json:"name"`
Hostname string `json:"hostname"`
Port string
RawPort json.RawMessage `json:"port"`
Username string `json:"username"`
Password string `json:"password"`
Tls TlsResource `json:"tls"`
}
type TlsResource struct {
Cert TlsCertResource `json:"cert"`
}
type TlsCertResource struct {
Ca string `json:"ca"`
}
type PaginatedServiceInstanceResources struct {
TotalResults int `json:"total_results"`
NextUrl string `json:"next_url"`
Resources []ServiceInstanceResource
}
type ServiceInstanceResource struct {
resources.Resource
Entity ServiceInstanceEntity
}
type PaginatedServiceKeyResources struct {
TotalResults int `json:"total_results"`
NextUrl string `json:"next_url"`
Resources []ServiceKeyResource
}
type ServiceKeyResource struct {
resources.Resource
Entity ServiceKeyEntity
}
type ServiceKeyEntity struct {
ServiceInstanceName string `json:"name"`
ServiceInstanceGuid string `json:"service_instance_guid"`
Credentials MysqlCredentials
}
type ServiceInstanceEntity struct {
Name string `json:"name"`
DashboardURL string `json:"dashboard_url"`
Tags []string `json:"tags"`
ServiceBindings []ServiceBindingResource `json:"service_bindings"`
ServiceKeys []resources.ServiceKeyResource `json:"service_keys"`
ServicePlan resources.ServicePlanResource `json:"service_plan"`
LastOperation resources.LastOperation `json:"last_operation"`
SpaceUrl string `json:"space_url"`
}
func (self *PaginatedServiceInstanceResources) ToModel() []models.ServiceInstance {
var convertedModels []models.ServiceInstance
for _, resource := range self.Resources {
model := models.ServiceInstance{}
model.Guid = resource.Metadata.GUID
model.Name = resource.Entity.Name
pathParts := strings.Split(resource.Entity.SpaceUrl, "/")
model.SpaceGuid = pathParts[len(pathParts)-1]
convertedModels = append(convertedModels, model)
}
return convertedModels
}
func (self *PaginatedServiceKeyResources) ToModel() ([]models.ServiceKey, error) {
var convertedModels []models.ServiceKey
for _, resource := range self.Resources {
model, err := resource.ToModel()
if err != nil {
return nil, err
}
convertedModels = append(convertedModels, model)
}
return convertedModels, nil
}
func (self *ServiceKeyResource) ToModel() (models.ServiceKey, error) {
var port string
if len(self.Entity.Credentials.RawPort) > 0 {
var portInt int
var portString string
err := json.Unmarshal(self.Entity.Credentials.RawPort, &portString)
if err != nil {
err = json.Unmarshal(self.Entity.Credentials.RawPort, &portInt)
if err != nil {
return models.ServiceKey{}, fmt.Errorf("unable to deserialize port in service key: '%s'", string(self.Entity.Credentials.RawPort))
}
portString = strconv.Itoa(portInt)
}
port = portString
}
return models.ServiceKey{
ServiceInstanceGuid: self.Entity.ServiceInstanceGuid,
Uri: self.Entity.Credentials.Uri,
DbName: self.Entity.Credentials.DbName,
Hostname: self.Entity.Credentials.Hostname,
Port: port,
Username: self.Entity.Credentials.Username,
Password: self.Entity.Credentials.Password,
CaCert: self.Entity.Credentials.Tls.Cert.Ca,
}, nil
}
|
package main
import (
"example.com/greetings"
"fmt"
"log"
//"rsc.io/quote"
)
func main() {
//fmt.Println(quote.Go())
log.SetPrefix("greetings: ")
//log.SetFlags(0)
explore_multiple_return_values()
explore_slice()
explore_map()
}
func explore_multiple_return_values() {
message, err := greetings.Hello("Rambo")
if err != nil {
log.Fatal(err)
}
fmt.Println(message)
}
func explore_map() {
//in: list of names
//out: map of greetings and name
names := []string{"John", "Jani", "Janardhan"}
messages, err := greetings.Hellos(names)
if err != nil {
log.Fatal(err)
}
fmt.Println(messages)
}
func explore_slice() {
var s []byte
s = make([]byte, 5, 5)
log.Printf("initial s capacity %v and lenth %v", cap(s), len(s))
s = s[2:4]
log.Printf("modified s capacity %v and lenth %v", cap(s), len(s))
//double the capacity of s
t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
s = t
log.Printf("increased s capacity %v and lenth %v", cap(s), len(s))
}
|
/*
Images can be described as 3D arrays.
// This image has only one white pixel:
[
[[255, 255, 255]]
]
// This one is a 2 by 2 black image:
[
[[0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 0]]
]
Your task is to create a function that takes a 3D array representation of an image and returns the grayscale version of that.
Examples
grayscale([
[[0, 0, 0], [0, 0, 157]],
[[1, 100, 0], [0, 10, 0]]
]) ➞ [
[[0, 0, 0], [52, 52, 52]],
[[34, 34, 34], [3, 3, 3]]
]
Notes
A valid RGB value ranges from 0 to 255 (inclusive).
If the given array contains out of bound values, convert them to the nearest valid one.
Previous challenge in this series: Image Manipulation: Invert (Part 1)
Grayscaling an image is adjusting to have the same amount of (Red, Green, Blue) from their combined average to produce different shades of gray.
*/
package main
import (
"reflect"
)
func main() {
m1 := [][][3]int{
{{0, 0, 0}, {0, 0, 157}},
{{1, 100, 0}, {0, 10, 0}},
}
r1 := [][][3]int{
{{0, 0, 0}, {52, 52, 52}},
{{34, 34, 34}, {3, 3, 3}},
}
m2 := [][][3]int{
{{0, 0, 0}, {0, 0, 157}, {100, 229, 4}},
{{1, 100, 0}, {0, 10, 0}, {0, 168, 0}},
{{0, 125, 0}, {15, 0, 9}, {0, 139, 0}},
{{0, 125, 0}, {0, 0, 9}, {0, 200, 0}},
}
r2 := [][][3]int{
{{0, 0, 0}, {52, 52, 52}, {111, 111, 111}},
{{34, 34, 34}, {3, 3, 3}, {56, 56, 56}},
{{42, 42, 42}, {8, 8, 8}, {46, 46, 46}},
{{42, 42, 42}, {3, 3, 3}, {67, 67, 67}},
}
m3 := [][][3]int{
{{0, 0, 255}, {0, 0, 0}, {0, 0, 157}, {100, 229, 4}},
{{100, 0, 3}, {1, 100, 0}, {0, 10, 0}, {0, 168, 0}},
{{16, 30, 0}, {0, 125, 0}, {15, 0, 9}, {0, 139, 0}},
{{200, 2, 0}, {0, 125, 0}, {0, 0, 9}, {0, 200, 0}},
}
r3 := [][][3]int{
{{85, 85, 85}, {0, 0, 0}, {52, 52, 52}, {111, 111, 111}},
{{34, 34, 34}, {34, 34, 34}, {3, 3, 3}, {56, 56, 56}},
{{15, 15, 15}, {42, 42, 42}, {8, 8, 8}, {46, 46, 46}},
{{67, 67, 67}, {42, 42, 42}, {3, 3, 3}, {67, 67, 67}},
}
m4 := [][][3]int{
{{0, -1, -120}, {300, 0, 157}},
{{1, 100, 0}, {256, 10, 0}},
}
r4 := [][][3]int{
{{0, 0, 0}, {137, 137, 137}},
{{34, 34, 34}, {88, 88, 88}},
}
test(m1, r1)
test(m2, r2)
test(m3, r3)
test(m4, r4)
}
func test(m, r [][][3]int) {
p := grayscale(m)
assert(reflect.DeepEqual(p, r))
}
func assert(x bool) {
if !x {
panic("assertion failed")
}
}
func grayscale(m [][][3]int) [][][3]int {
p := make([][][3]int, len(m))
for i := range m {
p[i] = make([][3]int, len(m[i]))
}
for i := range p {
for j := range p[i] {
g := 0
for k := range m[i][j] {
g += clamp(m[i][j][k], 0, 255)
}
g = int(float64(g)/3 + 0.5)
g = clamp(g, 0, 255)
for k := range p[i][j] {
p[i][j][k] = g
}
}
}
return p
}
func clamp(x, a, b int) int {
if x < a {
x = a
} else if x > b {
x = b
}
return x
}
|
package main
import(
"fmt"
"errors"
"os"
"net"
"net/rpc"
"math"
)
type Args struct{
A, B int
}
type Response struct{
Quo, res int
}
type Math byte
func (m*Math)Add(args *Args, res *int) error {
*res = args.A + args.B
return nil
}
func (m *Math) Divide(args *Args, res *Response) error {
if args.B == 0 {
return errors.New("You are trying divide by zero")
}
res.Quo = args.A / args.B
res.Res = args.A % args.B
return nil
}
func (m *Math) Major(slice *[]int, res *int) error {
var major = math.MinInt32
for _, v := range *slice {
if v > major {
major = v
}
}
*res = major
return nil
}
func (m *Math) Minor(slice *[]int, res *int) error {
var minor = math.MaxInt32
for _, v := range *slice {
if v < minor {
minor = v
}
}
*res = minor
return nil
}
func checkError(err error){
if err != nil{
fmt.Println("Erro! %v", err.Error())
os.Exit(1)
}
}
func main() {
// DEFER PANIC RECOVER
defer func() {
if err := recover(); err != nil {
fmt.Println("A Error has happen and I Survived, the error was: ", err)
}
}()
if len(os.Args) != 2 {
fmt.Println("Put a server port")
os.Exit(1)
}
var service = os.Args[1]
var reader = bufio.NewReader(os.Stdin)
client, err := rpc.Dial("tcp", service)
checkError(err, "Dialing")
// Synchronous Call
if err == nil {
message := ""
out:
for {
printMenu()
option := setValue(reader, &message)
switch option {
case 1:
var reply int
var args = Args{}
setArgs(reader, &args)
if err = client.Call("Math.Add", args, &reply); err == nil {
fmt.Printf("Math %d + %d = %d\n", args.A, args.B, reply)
}
checkError(err, "Math.Add Call")
case 2:
response := Response{}
var args = Args{}
setArgs(reader, &args)
if err = func main() {
defer func() {
if err := recover(); err != nil {
fmt.Println("A Error has happen and I Survived, the error was: ", err)
}
}()
if len(os.Args) != 2 {
fmt.Println("Put a server port")
os.Exit(1)
}
var service = os.Args[1]
var reader = bufio.NewReader(os.Stdin)
client, err := rpc.Dial("tcp", service)
checkError(err, "Dialing")
// Synchronous Call
if err == nil {
message := ""
out:
for {
printMenu()
option := setValue(reader, &message)
switch option {
case 1:
var reply int
var args = Args{}
setArgs(reader, &args)
if err = client.Call("Math.Add", args, &reply); err == nil {
fmt.Printf("Math %d + %d = %d\n", args.A, args.B, reply)
}
checkError(err, "Math.Add Call")
case 2:
response := Response{}
var args = Args{}
setArgs(reader, &args)
if err = client.Call("Math.Divide", args, &response); err == nil {
fmt.Printf("Math %d/%d = %d it's residue is %d \n", args.A, args.B, response.Quo, response.Res)
}
checkError(err, "Math.Divide Call")
case 3:
operation := "Math.Major"
majorOrMinor(&service, reader, &operation)
case 4:
operation := "Math.Minor"
majorOrMinor(&service, reader, &operation)
case 5:
fmt.Printf("Good Bye!\n")
break out
default:
fmt.Printf("Invalid Option\n")
}
}
defer client.Close()
}
}
; err == nil {
fmt.Printf("Math %d/%d = %d it's residue is %d \n", args.A, args.B, response.Quo, response.Res)
}
checkError(err, "Math.Divide Call")
case 3:
operation := "Math.Major"
majorOrMinor(&service, reader, &operation)
case 4:
operation := "Math.Minor"
majorOrMinor(&service, reader, &operation)
case 5:
fmt.Printf("Good Bye!\n")
break out
default:
fmt.Printf("Invalid Option\n")
}
}
defer client.Close()
}
} |
/*
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 controllers
import (
"context"
"math/rand"
"time"
"github.com/google/uuid"
"github.com/go-logr/logr"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/event"
"sigs.k8s.io/controller-runtime/pkg/predicate"
corev1beta1 "github.com/julienstroheker/kube-pokeapi-arena/pkg/api/v1beta1"
"github.com/julienstroheker/kube-pokeapi-arena/pkg/random"
)
const requeueAfter = 30 * time.Second
// InstanceReconciler reconciles a Instance object
type InstanceReconciler struct {
client.Client
Log logr.Logger
Scheme *runtime.Scheme
}
// +kubebuilder:rbac:groups=core.kube-pokeapi-arena.io,resources=instances,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=core.kube-pokeapi-arena.io,resources=instances/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=core,resources=pods,verbs=get;list;watch;create;update;patch;delete
func (r *InstanceReconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) {
ctx := context.Background()
log := r.Log.WithValues("instance", req.NamespacedName)
var instance corev1beta1.Instance
if err := r.Get(ctx, req.NamespacedName, &instance); err != nil {
log.Error(err, "unable to fetch Instance")
// we'll ignore not-found errors, since they can't be fixed by an immediate
// requeue (we'll need to wait for a new notification), and we can get them
// on deleted requests.
return ctrl.Result{}, client.IgnoreNotFound(err)
}
// On Schedule every 30sec
// Check status of living instance and compare with Max
// Randomize between living and max
// Spawn the randomized pokemon
// Reschedule for 30sec
var pokemonList corev1.PodList
err := r.List(ctx, &pokemonList, client.InNamespace(req.Namespace))
if err != nil {
log.Error(err, "unable to list pokemons")
return ctrl.Result{Requeue: true, RequeueAfter: requeueAfter}, client.IgnoreNotFound(err)
}
switch missingPokemons := int(instance.Spec.Settings.MaxPokemons) - len(pokemonList.Items); {
// WIll try to spwan more pokemons
case missingPokemons > 0:
var src random.Source
rnd := rand.New(src)
randomSpawn := rnd.Intn(missingPokemons + 1)
log.Info("Random magic number is now", "number", randomSpawn)
for i := 0; i < randomSpawn; i++ {
aNewPokemon := corev1.Pod{
ObjectMeta: metav1.ObjectMeta{
Name: "pokemon-" + uuid.New().String(),
Namespace: req.Namespace,
},
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "pokemon",
Image: "nginx:1.12",
Ports: []corev1.ContainerPort{
{
Name: "http",
Protocol: corev1.ProtocolTCP,
ContainerPort: 80,
},
},
},
},
},
}
err := r.Create(ctx, &aNewPokemon)
if err != nil {
log.Error(err, "unable to create pokemon")
return ctrl.Result{Requeue: true, RequeueAfter: requeueAfter}, client.IgnoreNotFound(err)
}
instance.Status.Living = uint64(len(pokemonList.Items)) + 1
instance.Status.Spawn = instance.Status.Spawn + 1
err = r.Update(ctx, &instance)
if err != nil {
return ctrl.Result{Requeue: true, RequeueAfter: requeueAfter}, err
}
}
// Need to remove some pokemons
case missingPokemons < 0:
var src random.Source
rnd := rand.New(src)
// Pod to delete
podNumberToDelete := rnd.Intn(len(pokemonList.Items) + 1)
log.Info("Random magic number is now", "number", podNumberToDelete)
podToDelete := pokemonList.Items[podNumberToDelete]
err = r.Delete(ctx, &podToDelete)
if err != nil {
return ctrl.Result{Requeue: true, RequeueAfter: requeueAfter}, err
}
default:
return ctrl.Result{Requeue: true, RequeueAfter: requeueAfter}, nil
}
return ctrl.Result{Requeue: true, RequeueAfter: requeueAfter}, nil
}
func (r *InstanceReconciler) SetupWithManager(mgr ctrl.Manager) error {
return ctrl.NewControllerManagedBy(mgr).
For(&corev1beta1.Instance{}).
WithEventFilter(predicate.Funcs{
DeleteFunc: func(e event.DeleteEvent) bool {
// Suppress Delete events to avoid filtering them out in the Reconcile function
return false
},
}).
Complete(r)
}
|
package models
type RankModel struct {
FBId string `json:"fb_id" bson:"fb_id"`
Name string `json:"name" bson:"name"`
Data []LevelModel `json:"data" bson:"data"`
} |
package skylark
import (
"github.com/google/skylark"
"github.com/google/skylark/skylarkstruct"
"github.com/pkg/errors"
)
// inconsistent behaviour described here
// https://docs.bazel.build/versions/master/skylark/rules.html#files
// https://docs.bazel.build/versions/master/skylark/lib/ctx.html#outputs
func processOutputs(ctx *context, ruleAttrs *skylark.Dict, ruleOutputs *skylark.Dict) ([]string, error) {
outputs := []string{}
if ruleOutputs != nil && len(ruleOutputs.Keys()) > 0 {
outs := skylark.StringDict{}
for _, tup := range ruleOutputs.Items() {
if formatted, err := format(tup[1].(skylark.String), ctx.Attrs()); err == nil {
outputs = append(outputs, formatted)
if name, ok := skylark.AsString(tup[0]); ok {
_ = name
outs[name] = output(formatted)
}
}
}
ctx.outputs = skylarkstruct.FromStringDict(skylarkstruct.Default, outs)
return outputs, nil
}
return outputs, nil
}
type output string
func (f output) String() string { return string(f) }
func (f output) Type() string { return "file" }
func (f output) Freeze() {}
func (f output) Truth() skylark.Bool { return true }
func (f output) Hash() (uint32, error) { return hashString(string(f)), nil }
func (f output) Attr(name string) (skylark.Value, error) {
switch name {
case "path":
return skylark.String(string(f)), nil
default:
return nil, errors.New("not implemented")
}
}
func (f output) AttrNames() []string {
panic("not implemented")
}
|
// Copyright (c) 2020 by meng. All rights reserved.
// Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file.
/**
* @Author: meng
* @Description:
* @File: condition
* @Version: 1.0.0
* @Date: 2020/4/9 20:23
*/
package base_behavior
import (
"math/rand"
"time"
"github.com/mx5566/behavior-tree/common"
)
type BaseCondition struct {
BaseBehavior
BehaviorWork
negation bool
}
func (this *BaseCondition) Init(neg bool, name common.BehaviorName) {
this.SetNegation(neg)
this.BaseBehavior.Init(name)
}
func (this *BaseCondition) IsNegation() bool {
return this.negation
}
func (this *BaseCondition) SetNegation(neg bool) {
this.negation = neg
}
func (this *BaseCondition) GetRandom() int {
rand.Seed(time.Now().UnixNano())
r := rand.Intn(100)
// int i = random.intValue();
return r
}
|
package model
import (
"context"
"github.com/k-komarov/passbase-currency-api/internal/pkg/constants"
)
func ProjectFromContext(ctx context.Context) *Project {
if p, ok := ctx.Value(constants.CTX_PROJECT).(*Project); ok {
return p
}
return nil
}
|
package api
import (
"github.com/kataras/iris/v12"
"github.com/qor/admin"
"github.com/qor/qor"
"go-tenancy/config/application"
"go-tenancy/config/db"
"go-tenancy/models/users"
)
// New new api app
func New(config *Config) *App {
if config.Prefix == "" {
config.Prefix = "/api"
}
return &App{Config: config}
}
// App api app
type App struct {
Config *Config
}
// Config api config struct
type Config struct {
Prefix string
}
// ConfigureApplication configure application
func (app App) ConfigureApplication(application *application.Application) {
API := admin.New(&qor.Config{DB: db.DB})
API.AddResource(&users.User{})
// User := API.AddResource(&users.User{})
// userOrders, _ := User.AddSubResource("Orders")
// userOrders.AddSubResource("OrderItems", &admin.Config{Name: "Items"})
application.IrisApp.Any(app.Config.Prefix, iris.FromStd(API.NewServeMux(app.Config.Prefix)))
}
|
package acronym
import (
"strings"
"unicode"
)
// Abbreviate will create an acronym of the given string
// hyphenated words are treated as separate words
func Abbreviate(s string) (acronym string) {
var abbreviation []byte
s = strings.Replace(s, "-", " ", -1)
s = strings.ToUpper(s)
trimmedText := strings.Split(s, " ")
for _, char := range trimmedText {
if len(char) <= 0 || !unicode.IsLetter(rune(char[0])) {
continue
}
abbreviation = append(abbreviation, char[0])
}
return string(abbreviation)
}
|
// Copyright 2023 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package globalconn
import (
"errors"
"fmt"
"math"
"strconv"
"github.com/ngaut/sync2"
"github.com/pingcap/tidb/util/logutil"
"go.uber.org/zap"
)
// GCID is the Global Connection ID, providing UNIQUE connection IDs across the whole TiDB cluster.
// Used when GlobalKill feature is enable.
// See https://github.com/pingcap/tidb/blob/master/docs/design/2020-06-01-global-kill.md
// 32 bits version:
//
// 31 21 20 1 0
// +--------+------------------+------+
// |serverID| local connID |markup|
// | (11b) | (20b) | =0 |
// +--------+------------------+------+
//
// 64 bits version:
//
// 63 62 41 40 1 0
// +--+---------------------+--------------------------------------+------+
// | | serverID | local connID |markup|
// |=0| (22b) | (40b) | =1 |
// +--+---------------------+--------------------------------------+------+
//
// NOTE:
// 1. `serverId“ in 64 bits version can be less than 2^11. This will happen when the 32 bits local connID has been used up, while `serverID` stay unchanged.
// 2. The local connID of a 32 bits GCID can be the same with another 64 bits GCID. This will not violate the uniqueness of GCID.
type GCID struct {
ServerID uint64
LocalConnID uint64
Is64bits bool
}
var (
// ServerIDBits32 is the number of bits of serverID for 32bits global connection ID.
ServerIDBits32 uint = 11
// MaxServerID32 is maximum serverID for 32bits global connection ID.
MaxServerID32 uint64 = 1<<ServerIDBits32 - 1
// LocalConnIDBits32 is the number of bits of localConnID for 32bits global connection ID.
LocalConnIDBits32 uint = 20
// MaxLocalConnID32 is maximum localConnID for 32bits global connection ID.
MaxLocalConnID32 uint64 = 1<<LocalConnIDBits32 - 1
)
const (
// MaxServerID64 is maximum serverID for 64bits global connection ID.
MaxServerID64 = 1<<22 - 1
// LocalConnIDBits64 is the number of bits of localConnID for 64bits global connection ID.
LocalConnIDBits64 = 40
// MaxLocalConnID64 is maximum localConnID for 64bits global connection ID.
MaxLocalConnID64 = 1<<LocalConnIDBits64 - 1
// ReservedCount is the count of reserved connection IDs for internal processes.
ReservedCount = 200
)
// ToConnID returns the 64bits connection ID
func (g *GCID) ToConnID() uint64 {
var id uint64
if g.Is64bits {
if g.LocalConnID > MaxLocalConnID64 {
panic(fmt.Sprintf("unexpected localConnID %d exceeds %d", g.LocalConnID, MaxLocalConnID64))
}
if g.ServerID > MaxServerID64 {
panic(fmt.Sprintf("unexpected serverID %d exceeds %d", g.ServerID, MaxServerID64))
}
id |= 0x1
id |= g.LocalConnID << 1 // 40 bits local connID.
id |= g.ServerID << 41 // 22 bits serverID.
} else {
if g.LocalConnID > MaxLocalConnID32 {
panic(fmt.Sprintf("unexpected localConnID %d exceeds %d", g.LocalConnID, MaxLocalConnID32))
}
if g.ServerID > MaxServerID32 {
panic(fmt.Sprintf("unexpected serverID %d exceeds %d", g.ServerID, MaxServerID32))
}
id |= g.LocalConnID << 1 // 20 bits local connID.
id |= g.ServerID << 21 // 11 bits serverID.
}
return id
}
// ParseConnID parses an uint64 connection ID to GlobalConnID.
//
// `isTruncated` indicates that older versions of the client truncated the 64-bit GlobalConnID to 32-bit.
func ParseConnID(id uint64) (g GCID, isTruncated bool, err error) {
if id&0x80000000_00000000 > 0 {
return GCID{}, false, errors.New("unexpected connectionID exceeds int64")
}
if id&0x1 > 0 { // 64bits
if id&0xffffffff_00000000 == 0 {
return GCID{}, true, nil
}
return GCID{
Is64bits: true,
LocalConnID: (id >> 1) & MaxLocalConnID64,
ServerID: (id >> 41) & MaxServerID64,
}, false, nil
}
// 32bits
if id&0xffffffff_00000000 > 0 {
return GCID{}, false, errors.New("unexpected connectionID exceeds uint32")
}
return GCID{
Is64bits: false,
LocalConnID: (id >> 1) & MaxLocalConnID32,
ServerID: (id >> 21) & MaxServerID32,
}, false, nil
}
///////////////////////////////// Class Diagram ///////////////////////////////////
// //
// +----------+ +-----------------+ +-----------------------+ //
// | Server | ---> | ConnIDAllocator | <<--+-- | GlobalConnIDAllocator | --+ //
// +----------+ +-----------------+ | +-----------------------+ | //
// +-- | SimpleConnIDAllocator | | //
// +----------+------------+ | //
// | | //
// V | //
// +--------+ +----------------------+ | //
// | IDPool | <<--+-- | AutoIncPool | <--+ //
// +--------+ | +----------------------+ | //
// +-- | LockFreeCircularPool | <--+ //
// +----------------------+ //
// //
///////////////////////////////////////////////////////////////////////////////////
type serverIDGetterFn func() uint64
// Allocator allocates global connection IDs.
type Allocator interface {
// NextID returns next connection ID.
NextID() uint64
// Release releases connection ID to allocator.
Release(connectionID uint64)
// GetReservedConnID returns reserved connection ID.
GetReservedConnID(reservedNo uint64) uint64
}
var (
_ Allocator = (*SimpleAllocator)(nil)
_ Allocator = (*GlobalAllocator)(nil)
)
// SimpleAllocator is a simple connection id allocator used when GlobalKill feature is disable.
type SimpleAllocator struct {
pool AutoIncPool
}
// NewSimpleAllocator creates a new SimpleAllocator.
func NewSimpleAllocator() *SimpleAllocator {
a := &SimpleAllocator{}
a.pool.Init(math.MaxUint64 - ReservedCount)
return a
}
// NextID implements ConnIDAllocator interface.
func (a *SimpleAllocator) NextID() uint64 {
id, _ := a.pool.Get()
return id
}
// Release implements ConnIDAllocator interface.
func (a *SimpleAllocator) Release(id uint64) {
a.pool.Put(id)
}
// GetReservedConnID implements ConnIDAllocator interface.
func (*SimpleAllocator) GetReservedConnID(reservedNo uint64) uint64 {
if reservedNo >= ReservedCount {
panic("invalid reservedNo exceed ReservedCount")
}
return math.MaxUint64 - reservedNo
}
// GlobalAllocator is global connection ID allocator.
type GlobalAllocator struct {
is64bits sync2.AtomicInt32 // !0: true, 0: false
serverIDGetter func() uint64
local32 LockFreeCircularPool
local64 AutoIncPool
}
// is64 indicates allocate 64bits global connection ID or not.
func (g *GlobalAllocator) is64() bool {
return g.is64bits.Get() != 0
}
// upgradeTo64 upgrade allocator to 64bits.
func (g *GlobalAllocator) upgradeTo64() {
g.is64bits.Set(1)
logutil.BgLogger().Info("GlobalAllocator upgrade to 64 bits")
}
func (g *GlobalAllocator) downgradeTo32() {
g.is64bits.Set(0)
logutil.BgLogger().Info("GlobalAllocator downgrade to 32 bits")
}
// LocalConnIDAllocator64TryCount is the try count of 64bits local connID allocation.
const LocalConnIDAllocator64TryCount = 10
// NewGlobalAllocator creates a GlobalAllocator.
func NewGlobalAllocator(serverIDGetter serverIDGetterFn, enable32Bits bool) *GlobalAllocator {
g := &GlobalAllocator{
serverIDGetter: serverIDGetter,
}
g.local32.InitExt(1<<LocalConnIDBits32, math.MaxUint32)
g.local64.InitExt((1<<LocalConnIDBits64)-ReservedCount, true, LocalConnIDAllocator64TryCount)
var is64 int32
if enable32Bits {
is64 = 0
} else {
is64 = 1
}
g.is64bits.Set(is64)
return g
}
// NextID returns next connection ID.
func (g *GlobalAllocator) NextID() uint64 {
globalConnID := g.Allocate()
return globalConnID.ToConnID()
}
// GetReservedConnID implements ConnIDAllocator interface.
func (g *GlobalAllocator) GetReservedConnID(reservedNo uint64) uint64 {
if reservedNo >= ReservedCount {
panic("invalid reservedNo exceed ReservedCount")
}
serverID := g.serverIDGetter()
globalConnID := GCID{
ServerID: serverID,
LocalConnID: (1 << LocalConnIDBits64) - 1 - reservedNo,
Is64bits: true,
}
return globalConnID.ToConnID()
}
// Allocate allocates a new global connection ID.
func (g *GlobalAllocator) Allocate() GCID {
serverID := g.serverIDGetter()
// 32bits.
if !g.is64() && serverID <= MaxServerID32 {
localConnID, ok := g.local32.Get()
if ok {
return GCID{
ServerID: serverID,
LocalConnID: localConnID,
Is64bits: false,
}
}
g.upgradeTo64() // go on to 64bits.
}
// 64bits.
localConnID, ok := g.local64.Get()
if !ok {
// local connID with 40bits pool size is big enough and should not be exhausted, as `MaxServerConnections` is no more than math.MaxUint32.
panic(fmt.Sprintf("Failed to allocate 64bits local connID after try %v times. Should never happen", LocalConnIDAllocator64TryCount))
}
return GCID{
ServerID: serverID,
LocalConnID: localConnID,
Is64bits: true,
}
}
// Release releases connectionID to pool.
func (g *GlobalAllocator) Release(connectionID uint64) {
globalConnID, isTruncated, err := ParseConnID(connectionID)
if err != nil || isTruncated {
logutil.BgLogger().Error("failed to ParseGlobalConnID", zap.Error(err), zap.Uint64("connectionID", connectionID), zap.Bool("isTruncated", isTruncated))
return
}
if globalConnID.Is64bits {
g.local64.Put(globalConnID.LocalConnID)
} else {
if ok := g.local32.Put(globalConnID.LocalConnID); ok {
if g.local32.Len() < g.local32.Cap()/2 {
g.downgradeTo32()
}
} else {
logutil.BgLogger().Error("failed to release 32bits connection ID", zap.Uint64("connectionID", connectionID), zap.Uint64("localConnID", globalConnID.LocalConnID))
}
}
}
var (
ldflagIsGlobalKillTest = "0" // 1:Yes, otherwise:No.
ldflagServerIDBits32 = "11" // Bits of ServerID32.
ldflagLocalConnIDBits32 = "20" // Bits of LocalConnID32.
)
func initByLDFlagsForGlobalKill() {
if ldflagIsGlobalKillTest == "1" {
var (
i int
err error
)
if i, err = strconv.Atoi(ldflagServerIDBits32); err != nil {
panic("invalid ldflagServerIDBits32")
}
ServerIDBits32 = uint(i)
MaxServerID32 = 1<<ServerIDBits32 - 1
if i, err = strconv.Atoi(ldflagLocalConnIDBits32); err != nil {
panic("invalid ldflagLocalConnIDBits32")
}
LocalConnIDBits32 = uint(i)
MaxLocalConnID32 = 1<<LocalConnIDBits32 - 1
logutil.BgLogger().Info("global_kill_test is enabled",
zap.Uint("ServerIDBits32", ServerIDBits32),
zap.Uint64("MaxServerID32", MaxServerID32),
zap.Uint("LocalConnIDBits32", LocalConnIDBits32),
zap.Uint64("MaxLocalConnID32", MaxLocalConnID32),
)
}
}
func init() {
initByLDFlagsForGlobalKill()
}
|
package main
import "fmt"
// https://leetcode-cn.com/problems/word-search/
func exist(board [][]byte, word string) bool {
n := len(board)
if n == 0 {
return false
}
m := len(board[0])
if m == 0 {
return false
}
mark := make([]bool, n*m)
st := &wordStack{nums: make([]int, 0, 3*len(word))}
var search func(row, col int) bool
search = func(row, col int) bool {
wordLen := len(word)
st.push(row, col, 0)
for i := m*n - 1; i >= 0; i-- {
mark[i] = false
}
for st.len() > 0 {
i, j, pos := st.pop()
if pos < 0 {
return false
}
if mark[i*m+j] || board[i][j] != word[pos] {
mark[i*m+j] = false
continue
}
mark[i*m+j] = true
if pos+1 == wordLen {
return true
}
// save the mark status of (i,j)
st.push(i, j, pos)
if i > 0 && !mark[(i-1)*m+j] {
st.push(i-1, j, pos+1)
}
if i < n-1 && !mark[(i+1)*m+j] {
st.push(i+1, j, pos+1)
}
if j > 0 && !mark[i*m+j-1] {
st.push(i, j-1, pos+1)
}
if j < m-1 && !mark[i*m+j+1] {
st.push(i, j+1, pos+1)
}
}
return false
}
for i := 0; i < n; i++ {
for j := 0; j < m; j++ {
if board[i][j] == word[0] {
if search(i, j) {
return true
}
for st.len() > 0 {
st.pop()
}
}
}
}
return false
}
type wordStack struct {
nums []int
}
func (ws *wordStack) len() int {
return len(ws.nums)
}
func (ws *wordStack) push(i, j, pos int) {
ws.nums = append(ws.nums, i, j, pos)
}
func (ws *wordStack) pop() (i, j, pos int) {
n := len(ws.nums)
if n == 0 {
return -1, -1, -1
}
i, j, pos = ws.nums[n-3], ws.nums[n-2], ws.nums[n-1]
ws.nums = ws.nums[:n-3]
return i, j, pos
}
func main() {
cases := []struct {
word string
board [][]byte
}{
{
word: "ABCCED",
board: [][]byte{
{'A', 'B', 'C', 'E'},
{'S', 'F', 'C', 'S'},
{'A', 'D', 'E', 'E'},
},
},
{
word: "ABCESEEEFS",
board: [][]byte{
{'A', 'B', 'C', 'E'},
{'S', 'F', 'E', 'S'},
{'A', 'D', 'E', 'E'},
},
},
{
word: "a",
board: [][]byte{
{'a'},
},
},
}
realCase := cases[0:]
for i, c := range realCase {
fmt.Println("## case", i)
// solve
fmt.Println(exist(c.board, c.word))
}
}
|
/*
* Copyright (c) 2020 - present Kurtosis Technologies LLC.
* All Rights Reserved.
*/
package services
import (
"github.com/kurtosis-tech/kurtosis-go/lib/services"
)
type ExampleService interface {
services.Service
GetHelloWorldSocket() Socket
}
|
package weather_provider
import (
"interface-testing/api/clients/restclient"
"interface-testing/api/domain/weather_domain"
"io/ioutil"
"net/http"
"os"
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
var (
getRequestFunc func(url string) (*http.Response, error)
)
type getClientMock struct{}
//We are mocking the client method "Get"
func (cm *getClientMock) Get(request string) (*http.Response, error) {
return getRequestFunc(request)
}
//When the everything is good
func TestGetWeatherNoError(t *testing.T) {
// The error we will get is from the "response" so we make the second parameter of the function is nil
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusOK,
Body: ioutil.NopCloser(strings.NewReader(`{"latitude": 44.3601, "longitude": -71.0589, "timezone": "America/New_York", "currently": {"summary": "Clear", "temperature": 40.22, "dewPoint": 50.22, "pressure": 12.90, "humidity": 16.54}}`)),
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"anything", 44.3601, -71.0589})
assert.NotNil(t, response)
assert.Nil(t, err)
assert.EqualValues(t, 44.3601, response.Latitude)
assert.EqualValues(t, -71.0589, response.Longitude)
assert.EqualValues(t, "America/New_York", response.TimeZone)
assert.EqualValues(t, "Clear", response.Currently.Summary)
assert.EqualValues(t, 40.22, response.Currently.Temperature)
assert.EqualValues(t, 50.22, response.Currently.DewPoint)
assert.EqualValues(t, 16.54, response.Currently.Humidity)
assert.EqualValues(t, 12.90, response.Currently.Pressure)
}
func TestGetWeatherInvalidApiKey(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusForbidden,
Body: ioutil.NopCloser(strings.NewReader(`{"code": 403, "error": "permission denied"}`)),
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"wrong_anything", 44.3601, -71.0589})
assert.NotNil(t, err)
assert.Nil(t, response)
assert.EqualValues(t, http.StatusForbidden, err.Code)
assert.EqualValues(t, "permission denied", err.ErrorMessage)
}
func TestGetWeatherInvalidLatitude(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusBadRequest,
Body: ioutil.NopCloser(strings.NewReader(`{"code": 400, "error": "The given location is invalid"}`)),
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"anything", 34223.3445, -71.0589})
assert.NotNil(t, err)
assert.Nil(t, response)
assert.EqualValues(t, http.StatusBadRequest, err.Code)
assert.EqualValues(t, "The given location is invalid", err.ErrorMessage)
}
func TestGetWeatherInvalidLongitude(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusBadRequest,
Body: ioutil.NopCloser(strings.NewReader(`{"code": 400, "error": "The given location is invalid"}`)),
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"anything", 44.3601, -74331.0589})
assert.NotNil(t, err)
assert.Nil(t, response)
assert.EqualValues(t, http.StatusBadRequest, err.Code)
assert.EqualValues(t, "The given location is invalid", err.ErrorMessage)
}
func TestGetWeatherInvalidFormat(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusBadRequest,
Body: ioutil.NopCloser(strings.NewReader(`{"code": 400, "error": "Poorly formatted request"}`)),
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"anything", 0, -74331.0589})
assert.NotNil(t, err)
assert.Nil(t, response)
assert.EqualValues(t, http.StatusBadRequest, err.Code)
assert.EqualValues(t, "Poorly formatted request", err.ErrorMessage)
}
//When no body is provided
func TestGetWeatherInvalidRestClient(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusBadRequest,
Body: ioutil.NopCloser(strings.NewReader(`{"code": 400, "error": "invalid rest client response"}`)),
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"anything", 0, -74331.0589})
assert.NotNil(t, err)
assert.Nil(t, response)
assert.EqualValues(t, http.StatusBadRequest, err.Code)
assert.EqualValues(t, "invalid rest client response", err.ErrorMessage)
}
func TestGetWeatherInvalidResponseBody(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusBadRequest,
Body: ioutil.NopCloser(strings.NewReader(`{"code": 400, "error": "Invalid response body"}`)),
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"wrong_anything", 44.3601, -71.0589})
assert.NotNil(t, err)
assert.Nil(t, response)
assert.EqualValues(t, http.StatusBadRequest, err.Code)
assert.EqualValues(t, "Invalid response body", err.ErrorMessage)
}
func TestGetWeatherInvalidRequest(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
invalidCloser, _ := os.Open("-asf3")
return &http.Response{
StatusCode: http.StatusBadRequest,
Body: invalidCloser,
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"wrong_anything", 44.3601, -71.0589})
assert.Nil(t, response)
assert.NotNil(t, err)
assert.EqualValues(t, http.StatusBadRequest, err.Code)
assert.EqualValues(t, "invalid argument", err.ErrorMessage)
}
//When the error response is invalid, here the code is supposed to be an integer, but a string was given.
//This can happen when the api owner changes some data types in the api
func TestGetWeatherInvalidErrorInterface(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusBadRequest,
Body: ioutil.NopCloser(strings.NewReader(`{"code": "string code"}`)),
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"anything", 44.3601, -71.0589})
assert.Nil(t, response)
assert.NotNil(t, err)
assert.EqualValues(t, http.StatusInternalServerError, err.Code)
assert.EqualValues(t, "invalid json response body", err.ErrorMessage)
}
//We are getting a postive response from the api, but, the datatype of the response returned does not match the struct datatype we have defined (does not match the struct type we want to unmarshal this response into).
func TestGetWeatherInvalidResponseInterface(t *testing.T) {
getRequestFunc = func(url string) (*http.Response, error) {
return &http.Response{
StatusCode: http.StatusOK,
Body: ioutil.NopCloser(strings.NewReader(`{"latitude": "string latitude", "longitude": -71.0589, "timezone": "America/New_York"}`)), //when we use string for latitude instead of float
}, nil
}
restclient.ClientStruct = &getClientMock{} //without this line, the real api is fired
response, err := WeatherProvider.GetWeather(weather_domain.WeatherRequest{"anything", 44.3601, -71.0589})
assert.Nil(t, response)
assert.NotNil(t, err)
assert.EqualValues(t, http.StatusInternalServerError, err.Code)
assert.EqualValues(t, "error unmarshaling weather fetch response", err.ErrorMessage)
}
|
// Bruteforce
package main
import "fmt"
import _ "math/big"
import "github.com/roessland/gopkg/mathutil"
func main() {
var min_value float64 = 2.0/5.0
var max_value float64 = 3.0/7.0
var D int64 = 1000000
// Closest value
var max_f float64 = 0.0
for d := int64(1); d <= D; d++ {
min_n := int64(float64(d) * min_value) - 1
max_n := int64(float64(d) * max_value) + 1
for n := min_n; n < max_n; n++ {
f := float64(n) / float64(d)
if min_value < f && f < max_value && f > max_f{
gcd := mathutil.GCD(n, d)
max_f = f
}
}
}
fmt.Printf("%v / %v = %v\n", n/gcd, d/gcd, float64(n)/float64(d))
fmt.Println("habeeb it")
}
|
/*
Copyright 2011 Google 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 main
import (
"flag"
"fmt"
"io/ioutil"
"os"
"sort"
"camli/blobref"
"camli/blobserver/localdisk" // used for the blob cache
"camli/cacher"
"camli/client"
"camli/fs"
"camli/third_party/github.com/hanwen/go-fuse/fuse"
)
func PrintMap(m map[string]float64) {
keys := make([]string, len(m))
for k, _ := range m {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
if m[k] > 0 {
fmt.Println(k, m[k])
}
}
}
func main() {
// Scans the arg list and sets up flags
debug := flag.Bool("debug", false, "print debugging messages.")
threaded := flag.Bool("threaded", true, "switch off threading; print debugging messages.")
flag.Parse()
errorf := func(msg string, args ...interface{}) {
fmt.Fprintf(os.Stderr, msg, args...)
os.Exit(2)
}
if flag.NArg() < 2 {
errorf("usage: cammount <blobref> <mountpoint>\n")
}
root := blobref.Parse(flag.Arg(0))
if root == nil {
errorf("Error parsing root blobref: %q\n", root)
}
client := client.NewOrFail() // automatic from flags
cacheDir, err := ioutil.TempDir("", "camlicache")
if err != nil {
errorf("Error creating temp cache directory: %v\n", err)
}
defer os.RemoveAll(cacheDir)
diskcache, err := localdisk.New(cacheDir)
if err != nil {
errorf("Error setting up local disk cache: %v", err)
}
fetcher := cacher.NewCachingFetcher(diskcache, client)
fs := fs.NewCamliFileSystem(fetcher, root)
timing := fuse.NewTimingPathFilesystem(fs)
conn := fuse.NewPathFileSystemConnector(timing)
rawTiming := fuse.NewTimingRawFilesystem(conn)
state := fuse.NewMountState(rawTiming)
state.Debug = *debug
mountPoint := flag.Arg(1)
err = state.Mount(mountPoint)
if err != nil {
fmt.Printf("MountFuse fail: %v\n", err)
os.Exit(1)
}
fmt.Printf("Mounted %s on %s (threaded=%v, debug=%v)\n", root.String(), mountPoint, *threaded, *debug)
state.Loop(*threaded)
fmt.Println("Finished", state.Stats())
counts := state.OperationCounts()
fmt.Println("Counts: ", counts)
latency := state.Latencies()
fmt.Println("MountState latency (ms):")
PrintMap(latency)
latency = timing.Latencies()
fmt.Println("Path ops (ms):", latency)
latency = rawTiming.Latencies()
fmt.Println("Raw FS (ms):", latency)
}
|
// Copyright (c) 2020 by meng. All rights reserved.
// Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file.
/**
* @Author: meng
* @Description:
* @File: idecorate
* @Version: 1.0.0
* @Date: 2020/4/9 15:46
*/
package interf
/************************************************************************/
/* 装饰结点
/* 装饰：
*********************************************************************** */
type IDecorator interface {
IBehaviour
SetChild(child IBehaviour)
GetChild() IBehaviour
}
|
package services
import (
"strings"
"github.com/ne7ermore/gRBAC/common"
"github.com/ne7ermore/gRBAC/plugin"
)
func Build(s plugin.Store) {
s.Build()
// init permissions
p := s.GetPermissionPools()
if err := initPerm(p); err != nil {
panic(err)
}
// init roles
r := s.GetRolePools()
if err := initRole(r); err != nil {
panic(err)
}
// init users
u := s.GetUserPools()
if err := initUser(u); err != nil {
panic(err)
}
}
func initPerm(pp plugin.PermissionPools) error {
ps, err := pp.Gather()
if err != nil {
return err
}
cps := make([]common.Permission, 0, len(ps))
for _, p := range ps {
cps = append(cps, common.NewFirstP(p.Getid(), p.GetDescrip()))
}
common.Get().NewPerms(cps)
return nil
}
func initRole(rp plugin.RolePools) error {
rs, err := rp.Gather()
if err != nil {
return err
}
auth := common.Get()
for _, r := range rs {
sr := common.NewStdRole(r.Getid())
auth.NewRole(sr)
if len(r.GetPermissions()) == 0 {
continue
}
permids := strings.Split(r.GetPermissions(), common.MongoRoleSep)
perms, err := auth.GetPerms(permids)
if err != nil {
return err
}
for _, p := range perms {
err = auth.Assign(sr, p)
if err != nil {
return err
}
}
}
return nil
}
func initUser(up plugin.UserPools) error {
us, err := up.Gather()
if err != nil {
return err
}
auth := common.Get()
for _, u := range us {
auth.NewUser(u.Getid())
if len(u.GetRoles()) == 0 {
continue
}
for _, rid := range strings.Split(u.GetRoles(), common.MongoRoleSep) {
err = auth.AddRole(u.Getid(), rid)
if err != nil {
return err
}
}
}
return nil
}
|
package mhfpacket
import (
"errors"
"github.com/Andoryuuta/Erupe/network"
"github.com/Andoryuuta/Erupe/network/clientctx"
"github.com/Andoryuuta/byteframe"
)
// TODO(Andoryuuta): Make up a name for this packet, not reserved anymore. Called "Is_update_guild_msg_board"
// MsgSysReserve203 represents the MSG_SYS_reserve203
type MsgSysReserve203 struct {
AckHandle uint32
Unk0 uint16 // Hardcoded 0x0000 in the binary
Unk1 uint16 // Hardcoded 0x0500 in the binary.
}
// Opcode returns the ID associated with this packet type.
func (m *MsgSysReserve203) Opcode() network.PacketID {
return network.MSG_SYS_reserve203
}
// Parse parses the packet from binary
func (m *MsgSysReserve203) Parse(bf *byteframe.ByteFrame, ctx *clientctx.ClientContext) error {
m.AckHandle = bf.ReadUint32()
m.Unk0 = bf.ReadUint16()
m.Unk1 = bf.ReadUint16()
return nil
}
// Build builds a binary packet from the current data.
func (m *MsgSysReserve203) Build(bf *byteframe.ByteFrame, ctx *clientctx.ClientContext) error {
return errors.New("Not implemented")
}
|
package version
import (
"fmt"
"runtime"
)
var (
ver string //nolint:gochecknoglobals
date string //nolint:gochecknoglobals
commit string //nolint:gochecknoglobals
)
// Info - version info.
type Info struct {
Version string
Date string
Commit string
}
// GetInfo - get version stamp information.
func GetInfo() Info {
return Info{
Version: ver,
Date: date,
Commit: commit,
}
}
// String() -- return version info string.
func (vi Info) String() string {
return fmt.Sprintf("%s #%s-%s-%s [%s]",
vi.Version,
vi.Commit,
runtime.GOOS,
runtime.GOARCH,
vi.Date,
)
}
|
package stack
import "testing"
func TestNewStack(t *testing.T) {
stack := NewStack()
stack.Push("a")
stack.Push("b")
stack.Push("c")
stack.Push("d")
stack.Push("e")
stack.Push("f")
t.Log(stack.Top())
t.Log(stack.Pop())
t.Log(stack.Pop())
t.Log(stack.Pop())
t.Log(stack.Pop())
t.Log(stack.Pop())
t.Log(stack.Pop())
t.Log(stack.Pop())
t.Log(stack.Pop())
t.Log(stack.Pop())
t.Log(stack.Pop())
}
|
package html
import (
"github.com/elliotchance/gedcom"
"github.com/elliotchance/gedcom/html/core"
"io"
)
// IndividualInList is a single row in the table of individuals on the list
// page.
type IndividualInList struct {
individual *gedcom.IndividualNode
document *gedcom.Document
visibility LivingVisibility
placesMap map[string]*place
}
func NewIndividualInList(document *gedcom.Document, individual *gedcom.IndividualNode, visibility LivingVisibility, placesMap map[string]*place) *IndividualInList {
return &IndividualInList{
individual: individual,
document: document,
visibility: visibility,
placesMap: placesMap,
}
}
func (c *IndividualInList) WriteHTMLTo(w io.Writer) (int64, error) {
birthDate, birthPlace := c.individual.Birth()
deathDate, deathPlace := c.individual.Death()
birthPlaceName := prettyPlaceName(gedcom.String(birthPlace))
deathPlaceName := prettyPlaceName(gedcom.String(deathPlace))
birthDateText := core.NewText(gedcom.String(birthDate))
deathDateText := core.NewText(gedcom.String(deathDate))
link := NewIndividualLink(c.document, c.individual, c.visibility, c.placesMap)
birthPlaceLink := NewPlaceLink(c.document, birthPlaceName, c.placesMap)
deathPlaceLink := NewPlaceLink(c.document, deathPlaceName, c.placesMap)
birthLines := core.NewLines(birthDateText, birthPlaceLink)
deathLines := core.NewLines(deathDateText, deathPlaceLink)
return core.NewTableRow(
core.NewTableCell(link).NoWrap(),
core.NewTableCell(birthLines),
core.NewTableCell(deathLines),
).WriteHTMLTo(w)
}
|
// Copyright 2016 Walter Schulze
//
// 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 mem_test
import (
"fmt"
"reflect"
"strings"
"testing"
reflectparser "github.com/katydid/katydid/parser/reflect"
"github.com/katydid/katydid/relapse/ast"
. "github.com/katydid/katydid/relapse/combinator"
"github.com/katydid/katydid/relapse/funcs"
"github.com/katydid/katydid/relapse/mem"
relapseparser "github.com/katydid/katydid/relapse/parser"
)
func NewInjectable() *injectableInt {
fmt.Printf("NewInjectable\n")
return &injectableInt{}
}
type injectableInt struct {
context *funcs.Context
}
func (this *injectableInt) Eval() (int64, error) {
v := this.context.Value.(int64)
fmt.Printf("eval = %d\n", v)
return v, nil
}
func (this *injectableInt) Compare(that funcs.Comparable) int {
if this.Hash() != that.Hash() {
if this.Hash() < that.Hash() {
return -1
}
return 1
}
if _, ok := that.(*injectableInt); ok {
return 0
}
return strings.Compare(this.String(), that.String())
}
func (this *injectableInt) String() string {
return "inject()"
}
func (this *injectableInt) Hash() uint64 {
return 17
}
func (this *injectableInt) SetContext(context *funcs.Context) {
this.context = context
fmt.Printf("context set\n")
}
func (this *injectableInt) HasVariable() bool {
return true
}
func init() {
funcs.Register("inject", NewInjectable)
parsedGrammar, err := relapseparser.ParseGrammar("Num:->eq($int, inject())")
if err != nil {
panic(err)
}
injectNumber = G(ast.NewRefLookup(parsedGrammar))
}
var injectNumber = G{}
type Number struct {
Num int64
}
func testInject(t *testing.T, m *mem.Mem) bool {
parser := reflectparser.NewReflectParser()
parser.Init(reflect.ValueOf(&Number{Num: 456}))
res, err := m.Validate(parser)
if err != nil {
t.Fatal(err)
}
return res
}
func TestInject(t *testing.T) {
grammar := injectNumber.Grammar()
fmt.Printf("parsed Grammar: %s\n", grammar)
m, err := mem.New(grammar)
if err != nil {
t.Fatal(err)
}
fmt.Printf("trying to set context...\n")
c := &funcs.Context{Value: int64(0)}
m.SetContext(c)
fmt.Printf("hopefully context was set\n")
c.Value = int64(456)
if !testInject(t, m) {
t.Fatalf("expected match")
}
c.Value = int64(123)
if testInject(t, m) {
t.Fatalf("expected non match")
}
}
|
package main
// https://leetcode-cn.com/problems/create-sorted-array-through-instructions/
// 树状数组
func createSortedArray(ins []int) int {
const mod = 1000000007
N := len(ins)
NN := 200000
tree := make([]int, NN+1)
add := func(i int) {
for i <= NN {
tree[i]++
i += i & -i
}
}
sum := func(i int) int {
ret := 0
for i > 0 {
ret += tree[i]
i -= i & -i
}
return ret
}
min := func(x, y int) int {
if x > y {
return y
}
return x
}
ans := 0
for i := 0; i < N; i++ {
ans += min(sum(ins[i]-1), sum(NN)-sum(ins[i])) % mod
add(ins[i])
}
return ans % mod
}
|
package utils
import (
"github.com/Shopify/sarama"
"github.com/howbazaar/loggo"
"strings"
"os"
"os/signal"
"encoding/json"
"go-temp-project/model"
)
var producer sarama.AsyncProducer
var signals chan os.Signal
var kafkaUp bool
func KafkaInit() {
config := sarama.NewConfig()
var err error
producer, err = sarama.NewAsyncProducer(strings.Split("localhost:9092", ","), config)
if err == nil {
logger := loggo.GetLogger("")
logger.Infof("===> KAFKA UP (%s) <===")
kafkaUp = true
}
// Trap SIGINT to trigger a graceful shutdown.
signals = make(chan os.Signal, 1)
signal.Notify(signals, os.Interrupt)
go func() {
<- signals
producer.AsyncClose() // Trigger a shutdown of the producer.
}()
}
func KafkaSend(topic string, value model.KafkaMonitoringLog) {
if kafkaUp {
go _KafkaSend(topic, value)
}
}
func _KafkaSend(topic string, value model.KafkaMonitoringLog) {
kafkaMessage, _ := json.Marshal(value)
message := &sarama.ProducerMessage{Topic: topic, Value: sarama.StringEncoder(string(kafkaMessage))}
producer.Input() <- message
}
|
package main
import (
"log"
"time"
"github.com/dustin/go-broadcast"
)
// Example of a simple broadcaster sending numbers to two workers.
func main() {
// create the broadcaster
broadcaster := broadcast.NewBroadcaster(100)
// start workers
go worker(1, broadcaster)
go worker(2, broadcaster)
// sending 5 messages to the broadcaster
for i := 0; i < 5; i++ {
log.Printf("Sending %+v to broadcaster", i)
broadcaster.Submit(i)
time.Sleep(time.Second)
}
// closing the broadcaster
err := broadcaster.Close()
if err != nil {
log.Printf("Closing broadcaster failed: %s", err.Error())
}
}
func worker(id int, broadcaster broadcast.Broadcaster) {
broadcastChan := make(chan interface{})
broadcaster.Register(broadcastChan)
defer broadcaster.Unregister(broadcastChan)
defer log.Printf("worker %d is done \n", id)
// dump out each message sent to the broadcaster.
for {
select {
case value := <-broadcastChan:
log.Printf("worker %d read %+v \n", id, value)
}
}
}
|
package main
import "testing"
func BenchmarkPredict(b *testing.B) {
bst, err := NewBooster()
if err != nil {
b.Fatal(err)
}
defer bst.Free()
err = bst.LoadModel("../model/dump.model")
if err != nil {
b.Fatal(err)
}
dm, err := NewDMatrix("../data/test_libsvm_oneline.txt")
if err != nil {
b.Fatal(err)
}
defer dm.Free()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, _ = bst.Predict(dm)
}
}
|
package main
import (
"fmt"
"reflect"
)
func makeFunction(f interface{}) interface{} {
rf := reflect.TypeOf(f)
if rf.Kind() != reflect.Func {
return nil
}
vf := reflect.ValueOf(f)
wrapperF := reflect.MakeFunc(rf, func(in []reflect.Value) []reflect.Value {
// start := time.Now()
out := vf.Call(in)
// end := time.Now()
// fmt.Printf("calling %s took %v\n", runtime.FuncForPC(vf.Pointer()).Name(), end.Sub(start))
return out
})
return wrapperF.Interface()
}
func Queue(f interface{}, params ...interface{}) {
a := makeFunction(f).(func())
a()
}
type Func func(a int, b string) int
func makeFunction2(f interface{}, params ...interface{}) interface{} {
t := reflect.TypeOf(f)
if t.Kind() != reflect.Func {
return nil
}
mul := reflect.MakeFunc(t, func(args []reflect.Value) []reflect.Value {
return []reflect.Value{reflect.ValueOf(args)}
})
fn, ok := mul.Interface().(Func)
if !ok {
return nil
}
fn(params[0].(int), params[1].(string))
return fn
}
func main() {
f := func(a int, b string) int {
fmt.Println("function f")
return 0
}
// Queue(f)
makeFunction2(f, 1, "1")
}
|
package example
func main() {
o, q, t, err := CreateOrder("product id", "customer id", "shipment id")
if err != nil {
panic(err)
}
}
// Return Transaction to show the transaction info in dashboard
func CreateOrder(productID, customerID, shipmentID string) (Order, Quote, Transaction, error) {
return Order{}, Quote{}, Transaction{}, nil
}
|
package BLC
import (
"bytes"
"crypto/ecdsa"
"crypto/rand"
"crypto/sha256"
"encoding/gob"
"encoding/hex"
"log"
)
//UTXO
type Transaction struct {
// 1. 交易 Hash
TxHash []byte
// 2. 输入
Vins []*TXInput
// 3. 输出
Vouts []*TXOutput
}
// 判断是否创世区块的交易
func (tx *Transaction) IsCoinbaseTransactions() bool {
return len(tx.Vins[0].TxHash) == 0 && tx.Vins[0].Vout == -1
}
// 1.Transaction 创建分两种情况
// 1.创世区块创建时的Transaction
func NewCoinBaseTransaction(address string) *Transaction {
// 代表消费信息
txInput := &TXInput{[]byte{}, -1, nil, []byte{}}
// 未消费
txOutput := NewTXOutput(10, address)
txCoinbase := &Transaction{[]byte{}, []*TXInput{txInput}, []*TXOutput{txOutput}}
//设置hash值
txCoinbase.HashTransaction()
return txCoinbase
}
/**
* 序列化一个区块
*/
func (tx *Transaction) HashTransaction() {
var result bytes.Buffer
encoder := gob.NewEncoder(&result)
err := encoder.Encode(tx)
if err != nil {
log.Panic(err)
}
hash := sha256.Sum256(result.Bytes())
tx.TxHash = hash[:]
}
func (tx *Transaction) Sign(privKey ecdsa.PrivateKey, prevTXS map[string]Transaction) {
if tx.IsCoinbaseTransactions() {
return
}
//没有找到对应的 transactions
for _, vin := range tx.Vins {
if prevTXS[hex.EncodeToString(vin.TxHash)].TxHash == nil {
log.Panic("ERROR : transaction is not correct")
}
}
//备份一分 tx
txCopy := tx.TrimmedCopy()
for inID, vin := range txCopy.Vins {
prevTx := prevTXS[hex.EncodeToString(vin.TxHash)]
txCopy.Vins[inID].Signature = nil
txCopy.Vins[inID].PublicKey = prevTx.Vouts[vin.Vout].Ripemd160Hash
txCopy.TxHash = txCopy.Hash()
txCopy.Vins[inID].PublicKey = nil
//签名代码
r, s, err := ecdsa.Sign(rand.Reader, &privKey, txCopy.TxHash)
if err != nil {
log.Panic(err)
}
signature := append(r.Bytes(), s.Bytes()...)
tx.Vins[inID].Signature = signature
}
}
func (tx *Transaction) TrimmedCopy() Transaction {
var inputs []*TXInput
var outputs []*TXOutput
for _, vin := range tx.Vins {
inputs = append(inputs, &TXInput{vin.TxHash, vin.Vout, nil, nil})
}
for _, vout := range tx.Vouts {
outputs = append(outputs, &TXOutput{vout.Value, vout.Ripemd160Hash})
}
txCopy := Transaction{tx.TxHash, inputs, outputs}
return txCopy
}
func (tx *Transaction) Hash() []byte {
txCopy := tx
txCopy.TxHash = []byte{}
hash := sha256.Sum256(txCopy.Serialize())
return hash[:]
}
func (tx *Transaction) Serialize() []byte {
var encoded bytes.Buffer
enc := gob.NewEncoder(&encoded)
err := enc.Encode(tx)
if err != nil {
log.Panic(err)
}
return encoded.Bytes()
}
// 2.转账时产生的Transaction
func NewSimpleTransaction(from, to string, amount int64, blockchain *Blockchain, txs []*Transaction) *Transaction {
// 1.有一个函数，返回from 这个人所有的未花费交易输出所对应的Transaction
//unUTXOs := blockchain.UnUTXOs(from)
//unSpentTx := UnSpentTransationsWithAdress(from)
wallets, _ := NewWallets()
wallet := wallets.Walets[from]
// 2.通过一个函数，返回
money, spendableUTXODic := blockchain.FindSpendableUTXOS(from, amount, txs)
var txInputs []*TXInput
var txOutputs []*TXOutput
for txHash, indexArray := range spendableUTXODic {
txHashBytes, _ := hex.DecodeString(txHash)
for _, index := range indexArray {
//未花费的交易输出
txInput := &TXInput{txHashBytes, index, nil, wallet.PublicKey}
txInputs = append(txInputs, txInput)
}
}
// 转账
txOutput := NewTXOutput(int64(amount), to)
txOutputs = append(txOutputs, txOutput)
//找零
txOutput = NewTXOutput(money-amount, from)
//txOutput = &TXOutput{money - amount, from}
txOutputs = append(txOutputs, txOutput)
tx := &Transaction{[]byte(""), txInputs, txOutputs}
//设置hash 值
tx.HashTransaction()
//进行签名
blockchain.SignTransaction(tx, wallet.PrivateKey)
return tx
}
/*
func NewUTXOTransaction(from, to string, amount int, bc *Blockchain) *Transaction {
var inputs []TXInput
var outputs []TXOutput
wallets, err := NewWallets()
if err != nil {
log.Panic(err)
}
wallet := wallets.
}
*/ |
package version
const Version = "0.1.3+git"
|
package krong
import (
"fmt"
)
type Agent struct {
Endpoint string
Command string
Secret string
}
func (a *Agent) String() string {
return fmt.Sprintf("Endpoint: %s, Command: %s, Secret: %s", a.Endpoint, a.Command, a.Secret)
}
|
package main
import "fmt"
// func functionname(parameters type) returntype {
// //body
// }
//Area function ....
func Area(w, l float64) float64 {
result := w * l
return result
}
//Perimeter function ...
func Perimeter(w float64, l float64) float64 {
result := 2 * (w + l)
return result
}
func geometryMetrics(w, l float64) (float64, float64) {
return Area(w, l), Perimeter(w, l)
}
func trianglePerimeter(a, b, c float64) (result, area float64) {
result = a + b + c
area = a * b * c //WRONG
return
}
// var res = Perimeter(22, 33)
// func emptyFunc() {}
func main() {
width, length := 23.5, 12.5
area := Area(width, length)
perimeter := Perimeter(width, length)
fmt.Println("Area:", area)
fmt.Println("Perimeter:", perimeter)
_, newPerimeter := geometryMetrics(12, 12)
//fmt.Println("New area is:", newArea)
fmt.Println("New perimeter is:", newPerimeter)
aTriangle, pTriangle := trianglePerimeter(10, 20, 30)
fmt.Println("Area triangle:", aTriangle)
fmt.Println("Perimeter triangle:", pTriangle)
//Lambda function
temp := func(a, b int) int {
return a*a + 2*a*b + b*b
}(10, 20)
lambdaFunction := func(a, b int) int {
return a*a + 2*a*b + b*b
}
fmt.Println("Result of lambda expression:", temp)
fmt.Printf("%T type of lambda function\n", lambdaFunction)
fmt.Printf("%T type for Area\n", Area)
lambdaFunction(20, 30)
}
|
package eviction
import (
"context"
"fmt"
"sort"
"strconv"
"strings"
"time"
autoscalingv1alpha1 "github.com/containers-ai/alameda/operator/api/v1alpha1"
utilsresource "github.com/containers-ai/alameda/operator/pkg/utils/resources"
"github.com/containers-ai/alameda/pkg/utils"
logUtil "github.com/containers-ai/alameda/pkg/utils/log"
datahub_client "github.com/containers-ai/api/alameda_api/v1alpha1/datahub"
datahub_common "github.com/containers-ai/api/alameda_api/v1alpha1/datahub/common"
datahub_events "github.com/containers-ai/api/alameda_api/v1alpha1/datahub/events"
datahub_recommendations "github.com/containers-ai/api/alameda_api/v1alpha1/datahub/recommendations"
datahub_resources "github.com/containers-ai/api/alameda_api/v1alpha1/datahub/resources"
"github.com/golang/protobuf/proto"
"github.com/golang/protobuf/ptypes/timestamp"
openshift_apps_v1 "github.com/openshift/api/apps/v1"
"github.com/pkg/errors"
"google.golang.org/genproto/googleapis/rpc/code"
apps_v1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
k8serrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/types"
"sigs.k8s.io/controller-runtime/pkg/client"
)
var (
scope = logUtil.RegisterScope("evictioner", "alamedascaler evictioner", 0)
)
// Evictioner deletes pods which need to apply recommendation
type Evictioner struct {
checkCycle int64
datahubClnt datahub_client.DatahubServiceClient
k8sClienit client.Client
evictCfg Config
purgeContainerCPUMemory bool
clusterID string
}
// NewEvictioner return Evictioner instance
func NewEvictioner(checkCycle int64,
datahubClnt datahub_client.DatahubServiceClient,
k8sClienit client.Client,
evictCfg Config,
purgeContainerCPUMemory bool,
clusterID string) *Evictioner {
return &Evictioner{
checkCycle: checkCycle,
datahubClnt: datahubClnt,
k8sClienit: k8sClienit,
evictCfg: evictCfg,
purgeContainerCPUMemory: purgeContainerCPUMemory,
clusterID: clusterID,
}
}
// Start checking pods need to apply recommendation
func (evictioner *Evictioner) Start() {
go evictioner.evictProcess()
}
func (evictioner *Evictioner) evictProcess() {
for {
if !evictioner.evictCfg.Enable {
scope.Warn("Evictioner is not enabled")
return
}
appliablePodRecList, err := evictioner.listAppliablePodRecommendation()
if err != nil {
scope.Errorf("List appliable PodRecommendation failed: %s", err.Error())
}
scope.Debugf("Applicable pod recommendation lists: %s", utils.InterfaceToString(appliablePodRecList))
evictioner.evictPods(appliablePodRecList)
time.Sleep(time.Duration(evictioner.checkCycle) * time.Second)
}
}
func (evictioner *Evictioner) evictPods(recommendations []*datahub_recommendations.PodRecommendation) {
events := make([]*datahub_events.Event, 0, len(recommendations))
for _, recommendation := range recommendations {
if recommendation.ObjectMeta == nil {
continue
}
pod := &corev1.Pod{}
err := evictioner.k8sClienit.Get(context.TODO(), types.NamespacedName{
Namespace: recommendation.ObjectMeta.GetNamespace(),
Name: recommendation.ObjectMeta.GetName(),
}, pod)
if err != nil {
if !k8serrors.IsNotFound(err) {
scope.Errorf("Get Pod(%s/%s) failed: %s", recommendation.ObjectMeta.GetNamespace(), recommendation.ObjectMeta.GetName(), err.Error())
}
continue
}
if evictioner.purgeContainerCPUMemory {
topController := recommendation.TopController
if topController == nil || topController.ObjectMeta == nil {
scope.Errorf("Purge pod (%s,%s) resources failed: get empty topController from PodRecommendation", pod.GetNamespace(), pod.GetName())
continue
}
topControllerNamespace := topController.ObjectMeta.Namespace
topControllerName := topController.ObjectMeta.Name
topControllerKind := topController.Kind
topControllerInstance, err := evictioner.getTopController(topControllerNamespace, topControllerName, topControllerKind)
if err != nil {
scope.Errorf("Purge pod (%s,%s) resources failed: get topController failed: %s", pod.GetNamespace(), pod.GetName(), err.Error())
continue
}
if needToPurge, err := evictioner.needToPurgeTopControllerContainerResources(topControllerInstance, topControllerKind); err != nil {
scope.Errorf("Purge pod (%s,%s) resources failed: %s", pod.GetNamespace(), pod.GetName(), err.Error())
} else if needToPurge {
if err = evictioner.purgeTopControllerContainerResources(topControllerInstance, topControllerKind); err != nil {
scope.Errorf("Purge pod (%s,%s) resources failed: %s", pod.GetNamespace(), pod.GetName(), err.Error())
continue
}
} else {
err = evictioner.k8sClienit.Delete(context.TODO(), pod)
if err != nil {
scope.Errorf("Evict pod (%s,%s) failed: %s", pod.GetNamespace(), pod.GetName(), err.Error())
} else {
e := newPodEvictEvent(evictioner.clusterID, &pod.ObjectMeta, pod.TypeMeta)
events = append(events, &e)
}
}
} else {
err = evictioner.k8sClienit.Delete(context.TODO(), pod)
if err != nil {
scope.Errorf("Evict pod (%s,%s) failed: %s", pod.GetNamespace(), pod.GetName(), err.Error())
} else {
e := newPodEvictEvent(evictioner.clusterID, &pod.ObjectMeta, pod.TypeMeta)
events = append(events, &e)
}
}
}
if err := evictioner.sendEvents(events); err != nil {
scope.Warnf("Send events to datahub failed: %s\n", err.Error())
}
}
func (evictioner *Evictioner) getTopController(namespace string, name string, kind datahub_resources.Kind) (interface{}, error) {
getResource := utilsresource.NewGetResource(evictioner.k8sClienit)
switch kind {
case datahub_resources.Kind_DEPLOYMENT:
return getResource.GetDeployment(namespace, name)
case datahub_resources.Kind_DEPLOYMENTCONFIG:
return getResource.GetDeploymentConfig(namespace, name)
case datahub_resources.Kind_STATEFULSET:
return getResource.GetStatefulSet(namespace, name)
default:
return nil, errors.Errorf("not supported controller type %s", datahub_resources.Kind_name[int32(kind)])
}
}
func (evictioner *Evictioner) needToPurgeTopControllerContainerResources(controller interface{}, kind datahub_resources.Kind) (bool, error) {
switch kind {
case datahub_resources.Kind_DEPLOYMENT:
deployment := controller.(*apps_v1.Deployment)
for _, container := range deployment.Spec.Template.Spec.Containers {
resourceLimits := container.Resources.Limits
if resourceLimits != nil {
_, cpuSpecExist := resourceLimits[corev1.ResourceCPU]
_, memorySpecExist := resourceLimits[corev1.ResourceMemory]
if cpuSpecExist || memorySpecExist {
return true, nil
}
}
resourceRequests := container.Resources.Requests
if resourceRequests != nil {
_, cpuSpecExist := resourceRequests[corev1.ResourceCPU]
_, memorySpecExist := resourceRequests[corev1.ResourceMemory]
if cpuSpecExist || memorySpecExist {
return true, nil
}
}
}
return false, nil
case datahub_resources.Kind_DEPLOYMENTCONFIG:
deploymentConfig := controller.(*openshift_apps_v1.DeploymentConfig)
for _, container := range deploymentConfig.Spec.Template.Spec.Containers {
resourceLimits := container.Resources.Limits
if resourceLimits != nil {
_, cpuSpecExist := resourceLimits[corev1.ResourceCPU]
_, memorySpecExist := resourceLimits[corev1.ResourceMemory]
if cpuSpecExist || memorySpecExist {
return true, nil
}
}
resourceRequests := container.Resources.Requests
if resourceRequests != nil {
_, cpuSpecExist := resourceRequests[corev1.ResourceCPU]
_, memorySpecExist := resourceRequests[corev1.ResourceMemory]
if cpuSpecExist || memorySpecExist {
return true, nil
}
}
}
return false, nil
case datahub_resources.Kind_STATEFULSET:
statefulSet := controller.(*apps_v1.StatefulSet)
for _, container := range statefulSet.Spec.Template.Spec.Containers {
resourceLimits := container.Resources.Limits
if resourceLimits != nil {
_, cpuSpecExist := resourceLimits[corev1.ResourceCPU]
_, memorySpecExist := resourceLimits[corev1.ResourceMemory]
if cpuSpecExist || memorySpecExist {
return true, nil
}
}
resourceRequests := container.Resources.Requests
if resourceRequests != nil {
_, cpuSpecExist := resourceRequests[corev1.ResourceCPU]
_, memorySpecExist := resourceRequests[corev1.ResourceMemory]
if cpuSpecExist || memorySpecExist {
return true, nil
}
}
}
return false, nil
default:
return false, errors.Errorf("not supported controller type %s", datahub_resources.Kind_name[int32(kind)])
}
}
func (evictioner *Evictioner) purgeTopControllerContainerResources(controller interface{}, kind datahub_resources.Kind) error {
switch kind {
case datahub_resources.Kind_DEPLOYMENT:
deployment := controller.(*apps_v1.Deployment)
deploymentCopy := deployment.DeepCopy()
for _, container := range deploymentCopy.Spec.Template.Spec.Containers {
resourceLimits := container.Resources.Limits
if resourceLimits != nil {
delete(resourceLimits, corev1.ResourceCPU)
delete(resourceLimits, corev1.ResourceMemory)
}
resourceRequests := container.Resources.Requests
if resourceRequests != nil {
delete(resourceRequests, corev1.ResourceCPU)
delete(resourceRequests, corev1.ResourceMemory)
}
}
ctx := context.TODO()
err := evictioner.k8sClienit.Update(ctx, deploymentCopy)
if err != nil {
return errors.Wrapf(err, "purge topController failed: %s", err.Error())
}
return nil
case datahub_resources.Kind_DEPLOYMENTCONFIG:
deploymentConfig := controller.(*openshift_apps_v1.DeploymentConfig)
deploymentConfigCopy := deploymentConfig.DeepCopy()
for _, container := range deploymentConfigCopy.Spec.Template.Spec.Containers {
resourceLimits := container.Resources.Limits
if resourceLimits != nil {
delete(resourceLimits, corev1.ResourceCPU)
delete(resourceLimits, corev1.ResourceMemory)
}
resourceRequests := container.Resources.Requests
if resourceRequests != nil {
delete(resourceRequests, corev1.ResourceCPU)
delete(resourceRequests, corev1.ResourceMemory)
}
}
ctx := context.TODO()
err := evictioner.k8sClienit.Update(ctx, deploymentConfigCopy)
if err != nil {
return errors.Wrapf(err, "purge topController failed: %s", err.Error())
}
return nil
case datahub_resources.Kind_STATEFULSET:
statefulSet := controller.(*apps_v1.StatefulSet)
statefulSetCopy := statefulSet.DeepCopy()
for _, container := range statefulSetCopy.Spec.Template.Spec.Containers {
resourceLimits := container.Resources.Limits
if resourceLimits != nil {
delete(resourceLimits, corev1.ResourceCPU)
delete(resourceLimits, corev1.ResourceMemory)
}
resourceRequests := container.Resources.Requests
if resourceRequests != nil {
delete(resourceRequests, corev1.ResourceCPU)
delete(resourceRequests, corev1.ResourceMemory)
}
}
ctx := context.TODO()
err := evictioner.k8sClienit.Update(ctx, statefulSetCopy)
if err != nil {
return errors.Wrapf(err, "purge topController failed: %s", err.Error())
}
return nil
default:
return errors.Errorf("not supported controller type %s", datahub_resources.Kind_name[int32(kind)])
}
}
func (evictioner *Evictioner) listAppliablePodRecommendation() ([]*datahub_recommendations.PodRecommendation, error) {
appliablePodRecList := []*datahub_recommendations.PodRecommendation{}
nowTime := time.Now()
nowTimestamp := time.Now().Unix()
recommendations, err := evictioner.listPodRecommendations(nowTimestamp)
if err != nil {
return nil, errors.Wrap(err, "list pod recommendations failed")
}
controllerRecommendationInfoMap := NewControllerRecommendationInfoMap(evictioner.k8sClienit, recommendations)
for _, controllerRecommendationInfo := range controllerRecommendationInfoMap {
podRecommendationInfos := controllerRecommendationInfo.podRecommendationInfos
sort.Slice(podRecommendationInfos, func(i, j int) bool {
return podRecommendationInfos[i].pod.ObjectMeta.CreationTimestamp.UnixNano() < podRecommendationInfos[j].pod.ObjectMeta.CreationTimestamp.UnixNano()
})
}
for _, controllerRecommendationInfo := range controllerRecommendationInfoMap {
// Create eviction restriction
maxUnavailable := controllerRecommendationInfo.getMaxUnavailable()
triggerThreshold, err := controllerRecommendationInfo.buildTriggerThreshold()
if err != nil {
scope.Errorf("Build triggerThreshold of controller (%s/%s, kind: %s) faild, skip evicting controller's pod: %s",
controllerRecommendationInfo.namespace, controllerRecommendationInfo.name, controllerRecommendationInfo.kind, err.Error())
continue
}
podRecommendations := make([]*datahub_recommendations.PodRecommendation, len(controllerRecommendationInfo.podRecommendationInfos))
for i := range controllerRecommendationInfo.podRecommendationInfos {
podRecommendations[i] = controllerRecommendationInfo.podRecommendationInfos[i].recommendation
}
evictionRestriction := NewEvictionRestriction(evictioner.k8sClienit, maxUnavailable, triggerThreshold, podRecommendations)
for _, podRecommendationInfo := range controllerRecommendationInfo.podRecommendationInfos {
pod := podRecommendationInfo.pod
podRecommendation := podRecommendationInfo.recommendation
if !controllerRecommendationInfo.isScalingToolTypeVPA() {
scope.Infof("Pod (%s/%s) cannot be evicted due to AlamedaScaler's scaling tool is type of %s",
pod.GetNamespace(), pod.GetName(), controllerRecommendationInfo.alamedaScaler.Spec.ScalingTool.Type)
continue
}
if ok, err := podRecommendationInfo.isApplicableAtTime(nowTime); err != nil {
scope.Infof("Pod (%s/%s) cannot be evicted due to PodRecommendation validate error, %s",
pod.GetNamespace(), pod.GetName(), err.Error())
continue
} else if !ok {
scope.Infof("Pod (%s/%s) cannot be evicted due to current time (%d) is not applicable on PodRecommendation's startTime (%d) and endTime(%d) interval",
pod.GetNamespace(), pod.GetName(), nowTime.Unix(), podRecommendation.GetStartTime().GetSeconds(), podRecommendation.GetEndTime().GetSeconds())
continue
}
if isEvictabel, err := evictionRestriction.IsEvictabel(pod); err != nil {
scope.Infof("Pod (%s/%s) cannot be evicted due to eviction restriction checking error: %s", pod.GetNamespace(), pod.GetName(), err.Error())
continue
} else if !isEvictabel {
scope.Infof("Pod (%s/%s) cannot be evicted.", pod.GetNamespace(), pod.GetName())
continue
} else {
scope.Infof("Pod (%s/%s) can be evicted.", pod.GetNamespace(), pod.GetName())
appliablePodRecList = append(appliablePodRecList, podRecommendation)
}
}
}
return appliablePodRecList, nil
}
func (evictioner *Evictioner) listPodRecommendations(nowTimestamp int64) ([]*datahub_recommendations.PodRecommendation, error) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
in := &datahub_recommendations.ListPodRecommendationsRequest{
ObjectMeta: []*datahub_resources.ObjectMeta{
{
ClusterName: evictioner.clusterID,
},
},
Kind: datahub_resources.Kind_KIND_UNDEFINED,
QueryCondition: &datahub_common.QueryCondition{
TimeRange: &datahub_common.TimeRange{
ApplyTime: ×tamp.Timestamp{
Seconds: nowTimestamp,
},
},
Order: datahub_common.QueryCondition_DESC,
Limit: 1,
},
}
scope.Debugf("Request of ListAvailablePodRecommendations is %s.", utils.InterfaceToString(in))
resp, err := evictioner.datahubClnt.ListAvailablePodRecommendations(ctx, in)
if err != nil {
return nil, err
} else if resp == nil || resp.Status == nil {
return nil, fmt.Errorf("receive nil status from datahub")
} else if resp.Status.Code != int32(code.Code_OK) {
return nil, fmt.Errorf("status code not 0: receive status code: %d, message: %s", resp.GetStatus().GetCode(), resp.GetStatus().GetMessage())
}
return resp.GetPodRecommendations(), nil
}
func (evictioner *Evictioner) sendEvents(events []*datahub_events.Event) error {
if len(events) == 0 {
return nil
}
request := datahub_events.CreateEventsRequest{
Events: events,
}
status, err := evictioner.datahubClnt.CreateEvents(context.TODO(), &request)
if err != nil {
return errors.Errorf("send events to Datahub failed: %s", err.Error())
} else if status == nil {
return errors.Errorf("send events to Datahub failed: receive nil status")
} else if status.Code != int32(code.Code_OK) {
return errors.Errorf("send events to Datahub failed: statusCode: %d, message: %s", status.Code, status.Message)
}
return nil
}
type podRecommendationInfo struct {
pod *corev1.Pod
recommendation *datahub_recommendations.PodRecommendation
}
func (p *podRecommendationInfo) isApplicableAtTime(t time.Time) (bool, error) {
startTime := p.recommendation.GetStartTime()
endTime := p.recommendation.GetEndTime()
if startTime == nil || endTime == nil {
return false, errors.Errorf("starTime and endTime cannot be nil")
}
if startTime.GetSeconds() >= t.Unix() || t.Unix() >= endTime.GetSeconds() {
return false, nil
}
return true, nil
}
func (p *podRecommendationInfo) podRunsLongerThan(d time.Duration) bool {
now := time.Now()
podCreationTime := p.pod.CreationTimestamp.Time
return podCreationTime.Add(d).Before(now)
}
type controllerRecommendationInfo struct {
namespace string
name string
kind string
alamedaScaler *autoscalingv1alpha1.AlamedaScaler
podRecommendationInfos []*podRecommendationInfo
}
func (c controllerRecommendationInfo) getMaxUnavailable() string {
var maxUnavailable string
scalingTool := c.alamedaScaler.Spec.ScalingTool
if scalingTool.ExecutionStrategy == nil {
maxUnavailable = autoscalingv1alpha1.DefaultMaxUnavailablePercentage
return maxUnavailable
}
maxUnavailable = scalingTool.ExecutionStrategy.MaxUnavailable
return maxUnavailable
}
func (c controllerRecommendationInfo) isScalingToolTypeVPA() bool {
return c.alamedaScaler.IsScalingToolTypeVPA()
}
func (c controllerRecommendationInfo) buildTriggerThreshold() (triggerThreshold, error) {
var triggerThreshold triggerThreshold
cpu := c.alamedaScaler.Spec.ScalingTool.ExecutionStrategy.TriggerThreshold.CPU
cpu = strings.TrimSuffix(cpu, "%")
cpuValue, err := strconv.ParseFloat(cpu, 64)
if err != nil {
return triggerThreshold, errors.Errorf("parse cpu trigger threshold failed: %s", err.Error())
}
triggerThreshold.CPU = cpuValue
memory := c.alamedaScaler.Spec.ScalingTool.ExecutionStrategy.TriggerThreshold.Memory
memory = strings.TrimSuffix(memory, "%")
memoryValue, err := strconv.ParseFloat(memory, 64)
if err != nil {
return triggerThreshold, errors.Errorf("parse memory trigger threshold failed: %s", err.Error())
}
triggerThreshold.Memory = memoryValue
return triggerThreshold, nil
}
// NewControllerRecommendationInfoMap returns
func NewControllerRecommendationInfoMap(client client.Client, podRecommendations []*datahub_recommendations.PodRecommendation) map[string]*controllerRecommendationInfo {
getResource := utilsresource.NewGetResource(client)
alamedaScalerMap := make(map[string]*autoscalingv1alpha1.AlamedaScaler)
controllerRecommendationInfoMap := make(map[string]*controllerRecommendationInfo)
for _, podRecommendation := range podRecommendations {
// Filter out invalid PodRecommendation
copyPodRecommendation := proto.Clone(podRecommendation)
podRecommendation = copyPodRecommendation.(*datahub_recommendations.PodRecommendation)
recommendationObjectMeta := podRecommendation.ObjectMeta
if recommendationObjectMeta == nil {
scope.Errorf("Skip PodRecommendation due to PodRecommendation has nil ObjectMeta")
continue
}
// Get AlamedaScaler owns this PodRecommendation and validate the AlamedaScaler is enabled execution.
alamedaRecommendation, err := getResource.GetAlamedaRecommendation(recommendationObjectMeta.Namespace, recommendationObjectMeta.Name)
if err != nil {
scope.Errorf("Skip PodRecommendation (%s/%s) due to get AlamedaRecommendation falied: %s", recommendationObjectMeta.Namespace, recommendationObjectMeta.Name, err.Error())
continue
}
alamedaScalerNamespace := ""
alamedaScalerName := ""
for _, or := range alamedaRecommendation.OwnerReferences {
if or.Kind == "AlamedaScaler" {
alamedaScalerNamespace = alamedaRecommendation.Namespace
alamedaScalerName = or.Name
break
}
}
alamedaScaler, exist := alamedaScalerMap[fmt.Sprintf("%s/%s", alamedaScalerNamespace, alamedaScalerName)]
if !exist {
alamedaScaler, err = getResource.GetAlamedaScaler(alamedaScalerNamespace, alamedaScalerName)
if err != nil {
scope.Errorf("Skip PodRecommendation (%s/%s) due to get AlamedaScaler falied: %s", recommendationObjectMeta.Namespace, recommendationObjectMeta.Name, err.Error())
continue
}
alamedaScalerMap[fmt.Sprintf("%s/%s", alamedaScalerNamespace, alamedaScalerName)] = alamedaScaler
}
if !alamedaScaler.IsEnableExecution() {
scope.Errorf("Skip PodRecommendation (%s/%s) because it's execution is not enabled.", recommendationObjectMeta.Namespace, recommendationObjectMeta.Name)
continue
}
// Get Pod instance of this PodRecommendation
podNamespace := recommendationObjectMeta.Namespace
podName := recommendationObjectMeta.Name
pod, err := getResource.GetPod(podNamespace, podName)
if err != nil {
scope.Errorf("Skip PodRecommendation due to get Pod (%s/%s) failed: %s", podNamespace, podName, err.Error())
continue
}
// Get topmost controller namespace, name and kind controlling this pod
controller := podRecommendation.TopController
if controller == nil {
scope.Errorf("Skip PodRecommendation (%s/%s) due to PodRecommendation has nil topmost controller", podNamespace, podName)
continue
} else if controller.ObjectMeta == nil {
scope.Errorf("Skip PodRecommendation (%s/%s) due to topmost controller has nil ObjectMeta", podNamespace, podName)
continue
}
// Append podRecommendationInfos into controllerRecommendationInfo
controllerID := fmt.Sprintf("%s.%s.%s", controller.Kind, controller.ObjectMeta.Namespace, controller.ObjectMeta.Name)
_, exist = controllerRecommendationInfoMap[controllerID]
if !exist {
controllerRecommendationInfoMap[controllerID] = &controllerRecommendationInfo{
namespace: controller.ObjectMeta.Namespace,
name: controller.ObjectMeta.Name,
kind: datahub_resources.Kind_name[int32(controller.Kind)],
alamedaScaler: alamedaScaler,
podRecommendationInfos: make([]*podRecommendationInfo, 0),
}
}
podRecommendationInfo := &podRecommendationInfo{
pod: pod,
recommendation: podRecommendation,
}
controllerRecommendationInfoMap[controllerID].podRecommendationInfos = append(
controllerRecommendationInfoMap[controllerID].podRecommendationInfos,
podRecommendationInfo,
)
}
return controllerRecommendationInfoMap
}
|
package scheduler
import (
"context"
"time"
"github.com/andywow/golang-lessons/lesson-calendar/internal/calendar"
"github.com/andywow/golang-lessons/lesson-calendar/internal/calendar/msgsystem"
"go.uber.org/zap"
"github.com/andywow/golang-lessons/lesson-calendar/internal/calendar/repository"
)
// options
type options struct {
logger *zap.Logger
storage *repository.EventRepository
msgSystem *msgsystem.MsgSystem
}
// Option server options
type Option interface {
apply(*options)
}
// logger option
type loggerOption struct {
Log *zap.Logger
}
// storage option
type repositoryOption struct {
EventStorage *repository.EventRepository
}
// storage option
type msgSystemOption struct {
MsgSystem *msgsystem.MsgSystem
}
// Scheduler scheduler for send events
type Scheduler struct {
logger *zap.SugaredLogger
eventStorage repository.EventRepository
messageSystem msgsystem.MsgSystem
}
func (s Scheduler) sendEvents(ctx context.Context, date time.Time) error {
events, err := s.eventStorage.GetEventsForNotification(ctx, date)
if err != nil {
s.logger.Error(err)
return err
}
s.logger.Infof("received %d events for send notifications", len(events))
for _, event := range events {
jsonMessage, err := calendar.ConvertToJSON(event)
if err != nil {
s.logger.Error(err)
continue
}
if err := s.messageSystem.SendMessage(ctx, jsonMessage); err != nil {
s.logger.Errorf("error, while sending notification about uuid: %s, err: %v",
event.Uuid, err)
} else {
s.logger.Infof("notification about event %s was sent to queue", event.Uuid)
}
}
return err
}
// Start scheduler
func (s Scheduler) Start(ctx context.Context, opts ...Option) {
options := options{
logger: zap.NewNop(),
}
for _, o := range opts {
o.apply(&options)
}
s.logger = options.logger.Sugar()
s.eventStorage = *options.storage
s.messageSystem = *options.msgSystem
nextTime := time.Now().Truncate(time.Minute).Add(time.Minute)
s.logger.Infof("first event scan will be at %s", nextTime.Format("2006-01-02 15:04:05"))
for {
time.Sleep(time.Until(nextTime))
select {
case <-ctx.Done():
return
default:
go func(eventTime time.Time) {
if err := s.sendEvents(ctx, eventTime); err != nil {
s.logger.Errorf("error, while sending events: %s", err)
}
}(nextTime)
}
nextTime = nextTime.Add(time.Minute)
}
}
// WithLogger apply logger
func WithLogger(log *zap.Logger) Option {
return loggerOption{Log: log}
}
// WithRepository apply storage
func WithRepository(repository *repository.EventRepository) Option {
return repositoryOption{EventStorage: repository}
}
// WithMsgSystem apply msg system
func WithMsgSystem(msgSystem *msgsystem.MsgSystem) Option {
return msgSystemOption{MsgSystem: msgSystem}
}
func (o loggerOption) apply(opts *options) {
opts.logger = o.Log
}
func (o repositoryOption) apply(opts *options) {
opts.storage = o.EventStorage
}
func (o msgSystemOption) apply(opts *options) {
opts.msgSystem = o.MsgSystem
}
|
package atlas
import (
"testing"
. "github.com/smartystreets/goconvey/convey"
)
type tObjStr struct {
X string
}
func TestTransformBuilder(t *testing.T) {
Convey("Building atlases using transforms:", t, func() {
Convey("string->struct->string happy path should build without error", func() {
_, err := Build(
BuildEntry(tObjStr{}).Transform().
TransformMarshal(MakeMarshalTransformFunc(
func(x tObjStr) (string, error) {
return x.X, nil
})).
TransformUnmarshal(MakeUnmarshalTransformFunc(
func(x string) (tObjStr, error) {
return tObjStr{x}, nil
})).
Complete(),
)
So(err, ShouldBeNil)
})
})
}
|
/*
* @lc app=leetcode.cn id=8 lang=golang
*
* [8] 字符串转换整数 (atoi)
*/
// @lc code=start
package main
import "fmt"
import "math"
// import "strings"
func myAtoi(s string) int {
if len(s) == 0 {
return 0
}
size := len(s)
i := 0
for i < size && s[i] == ' ' {
i++
}
if i == size {
return 0
}
s = s[i:]
s0 := s
if s[0] == '-' || s[0] == '+' {
s = s[1:]
}
n := 0
// s2 := []byte(s)
for _, ch := range []byte(s) {
ch -= '0'
if ch > 9 {
break
}
n = n*10 + int(ch)
if n > math.MaxInt32 {
if s0[0] == '-' {
return math.MinInt32
}
return math.MaxInt32
}
}
// fmt.Printf("n is %d\n", n)
if s0[0] == '-' {
n = -n
}
return n
// s = strings.TrimSpace(s)
// result := 0
// sign := 1
// for i, v := range s {
// if v >= '0' && v <= '9' {
// result = result*10 + int(v-'0')
// } else if v == '-' && i == 0 {
// sign = -1
// } else if v == '+' && i == 0 {
// sign = 1
// } else {
// break
// }
// // 数值最大检测
// fmt.Printf("result is %d\n", result)
// if result > math.MaxInt32 {
// if sign == -1 {
// return math.MinInt32
// }
// return math.MaxInt32
// }
// }
// return sign * result
}
// @lc code=end
func main(){
// fmt.Println(myAtoi(" -43"))
// fmt.Println(myAtoi("42"))
// fmt.Println(myAtoi("4193 with words"))
// fmt.Println(myAtoi("words and 987"))
// fmt.Println(myAtoi("-91283472332"))
fmt.Println("9223372036854775808")
fmt.Println(myAtoi("9223372036854775808"))
// fmt.Println(myAtoi("21474836460"))
// fmt.Println(myAtoi("0000000000012345678"))
} |
// Copyright 2016 Walter Schulze
//
// 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 auto compiles a parsed relapse grammar into a visual pushdown automaton and executes it.
//Compilation into a VPA may result in an exponential explosion, since fully converting a grammar to VPA is O(2^n^2).
//Rather use the mem package. It gives comparable speed and has no exponential behaviour.
//This package is just here to provide a benchmark against the mem package.
package auto
import (
"io"
"github.com/katydid/katydid/parser"
)
//Auto is the structure that represents the automaton.
type Auto struct {
calls []*callNode
returns []map[int]int
escapables []bool
start int
stateToNullable []int
accept []bool
}
//Validate executes an automaton with the given parser and returns whether the parser is valid given the automaton's original grammar.
func (auto *Auto) Validate(p parser.Interface) (bool, error) {
final, err := deriv(auto, auto.start, p)
if err != nil {
return false, err
}
return auto.accept[final], nil
}
func deriv(auto *Auto, current int, tree parser.Interface) (int, error) {
for {
if !auto.escapables[current] {
return current, nil
}
if err := tree.Next(); err != nil {
if err == io.EOF {
break
} else {
return 0, err
}
}
callTree := auto.calls[current]
childState, stackElm, err := callTree.eval(tree)
if err != nil {
return 0, err
}
if !tree.IsLeaf() {
tree.Down()
childState, err = deriv(auto, childState, tree)
if err != nil {
return 0, err
}
tree.Up()
}
nullIndex := auto.stateToNullable[childState]
current = auto.returns[stackElm][nullIndex]
}
return current, nil
}
|
package env
import (
"fmt"
"os"
"strings"
)
// GetStringSlice extracts slice of strings value with format "foo,bar,baz" from env.
// if not set, returns default value.
func GetStringSlice(key string, def []string) []string {
s, ok := os.LookupEnv(key)
if !ok {
return def
}
if len(s) == 0 {
return []string{}
}
return strings.Split(s, ",")
}
// MustGetStringSlice extracts slice of strings value with format "foo,bar,baz" from env.
// if not set, it panics.
func MustGetStringSlice(key string) []string {
s, ok := os.LookupEnv(key)
if !ok {
panic(fmt.Sprintf("environment variable '%s' has not been set", key))
}
if len(s) == 0 {
return []string{}
}
return strings.Split(s, ",")
}
|
package main
import "testing"
// +build integration
func TestFullFlow(t *testing.T) {
//TODO add test for entire flow using local dynamo and mocked sqs
} |
package usecase
import (
"fmt"
"strings"
"time"
entity "silverfish/silverfish/entity"
"github.com/PuerkitoBio/goquery"
"github.com/axgle/mahonia"
"github.com/sirupsen/logrus"
)
// FetcherBookbl export
type FetcherBookbl struct {
Fetcher
charset string
decoder mahonia.Decoder
}
// NewFetcherBookbl export
func NewFetcherBookbl(dns string) *FetcherBookbl {
fb := new(FetcherBookbl)
fb.NewFetcher(false, &dns)
fb.charset = "utf-8"
fb.decoder = mahonia.NewDecoder(fb.charset)
return fb
}
// GetChapterURL export
func (fb *FetcherBookbl) GetChapterURL(novel *entity.Novel, index int) *string {
url := fmt.Sprintf(`https://%s%s`, novel.DNS, novel.Chapters[index].URL)
return &url
}
// IsSplit export
func (fb *FetcherBookbl) IsSplit(doc *goquery.Document) bool {
return false
}
// Filter export
func (fb *FetcherBookbl) Filter(raw *string) *string {
return raw
}
// CrawlNovel export
func (fb *FetcherBookbl) CrawlNovel(url *string) (*entity.Novel, error) {
doc, docErr := fb.FetchDoc(url)
if docErr != nil {
return nil, docErr
}
id := fb.GenerateID(url)
info, infoErr := fb.FetchNovelInfo(id, doc)
if infoErr != nil {
return nil, fmt.Errorf("Something wrong while fetching info: %s", infoErr.Error())
}
chapters := fb.FetchChapterInfo(doc, info.Title, *url)
if len(chapters) == 0 {
logrus.Print("Chapters is empty. Strange...")
}
novel := &entity.Novel{
DNS: *fb.dns,
URL: *url,
Chapters: chapters,
}
novel.SetNovelInfo(info)
return novel, nil
}
// FetchNovelInfo export
func (fb *FetcherBookbl) FetchNovelInfo(novelID *string, doc *goquery.Document) (*entity.NovelInfo, error) {
title, ok0 := doc.Find("meta[property='og:title']").Attr("content")
author, ok1 := doc.Find("meta[property='og:novel:author']").Attr("content")
description := doc.Find("div.intro").Text()
description = strings.Replace(description, "簡介:", "", -1)
coverURL, ok2 := doc.Find("meta[property='og:image']").Attr("content")
if !ok0 || !ok1 || !ok2 || description == "" {
return nil, fmt.Errorf("Something missing, title: %s, author: %s, description: %s, coverURL: %s", title, author, description, coverURL)
}
return &entity.NovelInfo{
IsEnable: true,
NovelID: *novelID,
Title: fb.decoder.ConvertString(title),
Author: fb.decoder.ConvertString(author),
Description: fb.decoder.ConvertString(description),
CoverURL: coverURL,
LastCrawlTime: time.Now(),
}, nil
}
// FetchChapterInfo export
func (fb *FetcherBookbl) FetchChapterInfo(doc *goquery.Document, title, url string) []entity.NovelChapter {
chapters := []entity.NovelChapter{}
doc.Find("div.panel-booklist > ul.list-group > li > a").Each(func(i int, s *goquery.Selection) {
chapterTitle, ok0 := s.Attr("title")
chapterURL, ok1 := s.Attr("href")
if ok0 && ok1 {
chapters = append(chapters, entity.NovelChapter{
Title: fb.decoder.ConvertString(chapterTitle),
URL: chapterURL,
})
} else {
logrus.Printf("Chapter missing something, title: %s, url: %s", title, url)
}
})
return chapters
}
// UpdateNovelInfo export
func (fb *FetcherBookbl) UpdateNovelInfo(novel *entity.Novel) (*entity.Novel, error) {
doc, docErr := fb.FetchDoc(&novel.URL)
if docErr != nil {
return nil, docErr
}
info, infoErr := fb.FetchNovelInfo(&novel.NovelID, doc)
if infoErr != nil {
return nil, fmt.Errorf("Something wrong while fetching info: %s", infoErr.Error())
}
chapters := fb.FetchChapterInfo(doc, novel.Title, novel.URL)
if len(chapters) == 0 {
logrus.Print("Chapters is empty. Strange...")
}
info.LastCrawlTime = time.Now()
novel.SetNovelInfo(info)
novel.Chapters = chapters
return novel, nil
}
// FetchNovelChapter export
func (fb *FetcherBookbl) FetchNovelChapter(novel *entity.Novel, index int) (*string, error) {
url := fb.GetChapterURL(novel, index)
output := ""
doc, docErr := fb.FetchDoc(url)
if docErr != nil {
return nil, docErr
}
novelContent, _ := doc.Find("div.content").Html()
output += fb.decoder.ConvertString(novelContent)
return fb.Filter(&output), nil
}
|
package main
import (
"encoding/json"
"log"
"net/http"
"time"
)
const (
tree = "Sequoia"
)
type resp struct {
MyFavouriteTree string `json:"myFavouriteTree"`
}
func main() {
staticResponse := resp{tree}
http.HandleFunc(
"/tree",
func(w http.ResponseWriter, r *http.Request) {
log.Printf("\"%s\" request with header \"%s\" to \"%s\"", r.Method, r.Header, r.URL)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(staticResponse)
},
)
// The /healthz endpoint is added so that kubernetes can evalueate if the pod
// needs restarting
http.HandleFunc(
"/healthz",
func(w http.ResponseWriter, r *http.Request) {
log.Println("healthz ping")
w.WriteHeader(http.StatusOK)
w.Write([]byte("OK"))
},
)
srv := &http.Server{
ReadTimeout: 5 * time.Second,
WriteTimeout: 10 * time.Second,
Addr: ":8090",
}
log.Fatal(srv.ListenAndServe())
}
|
package main
import "fmt"
func strStr(haystack string, needle string) int {
l1 := len(haystack)
l2 := len(needle)
for i := 0; i+l2 <= l1; i++ {
if string(haystack[i:i+l2]) == needle {
return i
}
}
return -1
}
func main() {
s1 := "aaabbbcdefff"
s2 := "bbcd"
fmt.Println(strStr(s1, s2))
}
|
package cpu
import (
"log"
"github.com/cgimenes/gomenes-boy/hardware/cpu/registers"
"github.com/cgimenes/gomenes-boy/hardware/memory"
"github.com/cgimenes/gomenes-boy/hardware/types"
)
type Instruction struct {
cycles uint8
exec func()
}
type CPU struct {
mmu memory.MMU
registers registers.Registers
}
func (c *CPU) Init() {
c.initRegisters()
}
func (c *CPU) initRegisters() {
c.registers = registers.Registers{
A: types.ByteRegister{},
B: types.ByteRegister{},
D: types.ByteRegister{},
H: types.ByteRegister{},
F: types.ByteRegister{},
C: types.ByteRegister{},
E: types.ByteRegister{},
L: types.ByteRegister{},
SP: registers.SingleWordRegister{},
PC: registers.SingleWordRegister{},
}
c.registers.AF = registers.PairedWordRegister{
H: &c.registers.A,
L: &c.registers.F,
}
c.registers.BC = registers.PairedWordRegister{
H: &c.registers.B,
L: &c.registers.C,
}
c.registers.DE = registers.PairedWordRegister{
H: &c.registers.D,
L: &c.registers.E,
}
c.registers.HL = registers.PairedWordRegister{
H: &c.registers.H,
L: &c.registers.L,
}
c.registers.Flags = registers.Flags{R: &c.registers.F}
}
func (c *CPU) Decode(opcode types.Byte) Instruction {
switch opcode {
case 0x06:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.FetchNextByte())
}, cycles: 8}
case 0x0E:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.FetchNextByte())
}, cycles: 8}
case 0x16:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.FetchNextByte())
}, cycles: 8}
case 0x1E:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.FetchNextByte())
}, cycles: 8}
case 0x26:
return Instruction{exec: func() {
c.LDr8(c.registers.H, c.FetchNextByte())
}, cycles: 8}
case 0x2E:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.FetchNextByte())
}, cycles: 8}
case 0x7F:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.registers.A.Get())
}, cycles: 4}
case 0x78:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.registers.B.Get())
}, cycles: 4}
case 0x79:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.registers.C.Get())
}, cycles: 4}
case 0x7A:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.registers.D.Get())
}, cycles: 4}
case 0x7B:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.registers.E.Get())
}, cycles: 4}
case 0x7C:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.registers.H.Get())
}, cycles: 4}
case 0x7D:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.registers.L.Get())
}, cycles: 4}
case 0x7E:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0x40:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.registers.B.Get())
}, cycles: 4}
case 0x41:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.registers.C.Get())
}, cycles: 4}
case 0x42:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.registers.D.Get())
}, cycles: 4}
case 0x43:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.registers.E.Get())
}, cycles: 4}
case 0x44:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.registers.H.Get())
}, cycles: 4}
case 0x45:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.registers.L.Get())
}, cycles: 4}
case 0x46:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0x48:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.registers.B.Get())
}, cycles: 4}
case 0x49:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.registers.C.Get())
}, cycles: 4}
case 0x4A:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.registers.D.Get())
}, cycles: 4}
case 0x4B:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.registers.E.Get())
}, cycles: 4}
case 0x4C:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.registers.H.Get())
}, cycles: 4}
case 0x4D:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.registers.L.Get())
}, cycles: 4}
case 0x4E:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0x50:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.registers.B.Get())
}, cycles: 4}
case 0x51:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.registers.C.Get())
}, cycles: 4}
case 0x52:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.registers.D.Get())
}, cycles: 4}
case 0x53:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.registers.E.Get())
}, cycles: 4}
case 0x54:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.registers.H.Get())
}, cycles: 4}
case 0x55:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.registers.L.Get())
}, cycles: 4}
case 0x56:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0x58:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.registers.B.Get())
}, cycles: 4}
case 0x59:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.registers.C.Get())
}, cycles: 4}
case 0x5A:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.registers.D.Get())
}, cycles: 4}
case 0x5B:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.registers.E.Get())
}, cycles: 4}
case 0x5C:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.registers.H.Get())
}, cycles: 4}
case 0x5D:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.registers.L.Get())
}, cycles: 4}
case 0x5E:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0x60:
return Instruction{exec: func() {
c.LDr8(c.registers.H, c.registers.B.Get())
}, cycles: 4}
case 0x61:
return Instruction{exec: func() {
c.LDr8(c.registers.H, c.registers.C.Get())
}, cycles: 4}
case 0x62:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.registers.D.Get())
}, cycles: 4}
case 0x63:
return Instruction{exec: func() {
c.LDr8(c.registers.H, c.registers.E.Get())
}, cycles: 4}
case 0x64:
return Instruction{exec: func() {
c.LDr8(c.registers.H, c.registers.H.Get())
}, cycles: 4}
case 0x65:
return Instruction{exec: func() {
c.LDr8(c.registers.H, c.registers.L.Get())
}, cycles: 4}
case 0x66:
return Instruction{exec: func() {
c.LDr8(c.registers.H, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0x68:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.registers.B.Get())
}, cycles: 4}
case 0x69:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.registers.C.Get())
}, cycles: 4}
case 0x6A:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.registers.D.Get())
}, cycles: 4}
case 0x6B:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.registers.E.Get())
}, cycles: 4}
case 0x6C:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.registers.H.Get())
}, cycles: 4}
case 0x6D:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.registers.L.Get())
}, cycles: 4}
case 0x6E:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0x70:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.B.Get())
}, cycles: 8}
case 0x71:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.C.Get())
}, cycles: 8}
case 0x72:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.D.Get())
}, cycles: 8}
case 0x73:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.E.Get())
}, cycles: 8}
case 0x74:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.H.Get())
}, cycles: 8}
case 0x75:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.L.Get())
}, cycles: 8}
case 0x36:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.FetchNextByte())
}, cycles: 12}
case 0x0A:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.mmu.Get(c.registers.BC.Get()))
}, cycles: 8}
case 0x1A:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.mmu.Get(c.registers.DE.Get()))
}, cycles: 8}
case 0xFA:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.mmu.Get(c.FetchNextWord()))
}, cycles: 16}
case 0x3E:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.FetchNextByte())
}, cycles: 8}
case 0x47:
return Instruction{exec: func() {
c.LDr8(c.registers.B, c.registers.A.Get())
}, cycles: 4}
case 0x4F:
return Instruction{exec: func() {
c.LDr8(c.registers.C, c.registers.A.Get())
}, cycles: 4}
case 0x57:
return Instruction{exec: func() {
c.LDr8(c.registers.D, c.registers.A.Get())
}, cycles: 4}
case 0x5F:
return Instruction{exec: func() {
c.LDr8(c.registers.E, c.registers.A.Get())
}, cycles: 4}
case 0x67:
return Instruction{exec: func() {
c.LDr8(c.registers.H, c.registers.A.Get())
}, cycles: 4}
case 0x6F:
return Instruction{exec: func() {
c.LDr8(c.registers.L, c.registers.A.Get())
}, cycles: 4}
case 0x02:
return Instruction{exec: func() {
c.LDm8(c.registers.BC.Get(), c.registers.A.Get())
}, cycles: 8}
case 0x12:
return Instruction{exec: func() {
c.LDm8(c.registers.DE.Get(), c.registers.A.Get())
}, cycles: 8}
case 0x77:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.A.Get())
}, cycles: 8}
case 0xEA:
return Instruction{exec: func() {
c.LDm8(c.FetchNextWord(), c.registers.A.Get())
}, cycles: 16}
case 0xF2:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.mmu.Get(0xFF00 + types.Word(c.registers.C.Get())))
}, cycles: 8}
case 0xE2:
return Instruction{exec: func() {
c.LDm8(0xFF00 + types.Word(c.registers.C.Get()), c.registers.A.Get())
}, cycles: 8}
case 0x3A:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.mmu.Get(c.registers.HL.Get()))
c.DEC16(&c.registers.HL)
}, cycles: 8}
case 0x32:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.A.Get())
c.DEC16(&c.registers.HL)
}, cycles: 8}
case 0x2A:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.mmu.Get(c.registers.HL.Get()))
c.INC16(&c.registers.HL)
}, cycles: 8}
case 0x22:
return Instruction{exec: func() {
c.LDm8(c.registers.HL.Get(), c.registers.A.Get())
c.INC16(&c.registers.HL)
}, cycles: 8}
case 0xE0:
return Instruction{exec: func() {
c.LDm8(0xFF00 + types.Word(c.FetchNextByte()), c.registers.A.Get())
}, cycles: 12}
case 0xF0:
return Instruction{exec: func() {
c.LDr8(c.registers.A, c.mmu.Get(0xFF00 + types.Word(c.FetchNextByte())))
}, cycles: 12}
case 0x01:
return Instruction{exec: func() {
c.LDr16(&c.registers.BC, c.FetchNextWord())
}, cycles: 12}
case 0x11:
return Instruction{exec: func() {
c.LDr16(&c.registers.DE, c.FetchNextWord())
}, cycles: 12}
case 0x21:
return Instruction{exec: func() {
c.LDr16(&c.registers.HL, c.FetchNextWord())
}, cycles: 12}
case 0x31:
return Instruction{exec: func() {
c.LDr16(&c.registers.SP, c.FetchNextWord())
}, cycles: 12}
case 0xF9:
return Instruction{exec: func() {
c.LDr16(&c.registers.SP, c.registers.HL.Get())
}, cycles: 8}
case 0xF8:
return Instruction{exec: func() {
var n = c.FetchNextByte()
// @todo what is this?
if n > 127 {
c.LDr16(&c.registers.HL, c.registers.SP.Get() - types.Word(-n))
} else {
c.LDr16(&c.registers.HL, c.registers.SP.Get() + types.Word(n))
}
var check = c.registers.SP.Get() ^ types.Word(n) ^ ((c.registers.SP.Get() + types.Word(n)) & 0xffff)
// @todo is this the carry alg?
if (check & 0x100) == 0x100 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
// @todo is this the half carry alg?
if (check & 0x10) == 0x10 {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
c.registers.Flags.Reset(registers.Z)
c.registers.Flags.Reset(registers.N)
}, cycles: 12}
case 0x08:
return Instruction{exec: func() {
h, l := types.WordToBytes(c.registers.SP.Get())
addr := c.FetchNextWord()
c.mmu.Set(addr+1, h)
c.mmu.Set(addr, l)
}, cycles: 20}
case 0xF5:
return Instruction{exec: func() {
c.PushWord(c.registers.AF.Get())
}, cycles: 16}
case 0xC5:
return Instruction{exec: func() {
c.PushWord(c.registers.BC.Get())
}, cycles: 16}
case 0xD5:
return Instruction{exec: func() {
c.PushWord(c.registers.DE.Get())
}, cycles: 16}
case 0xE5:
return Instruction{exec: func() {
c.PushWord(c.registers.HL.Get())
}, cycles: 16}
case 0xF1:
return Instruction{exec: func() {
c.PopWord(&c.registers.AF)
}, cycles: 12}
case 0xC1:
return Instruction{exec: func() {
c.PopWord(&c.registers.BC)
}, cycles: 12}
case 0xD1:
return Instruction{exec: func() {
c.PopWord(&c.registers.DE)
}, cycles: 12}
case 0xE1:
return Instruction{exec: func() {
c.PopWord(&c.registers.HL)
}, cycles: 12}
// ALU start
case 0x87:
return Instruction{exec: func() {
c.ADD8(c.registers.A.Get())
}, cycles: 4}
case 0x80:
return Instruction{exec: func() {
c.ADD8(c.registers.B.Get())
}, cycles: 4}
case 0x81:
return Instruction{exec: func() {
c.ADD8(c.registers.C.Get())
}, cycles: 4}
case 0x82:
return Instruction{exec: func() {
c.ADD8(c.registers.D.Get())
}, cycles: 4}
case 0x83:
return Instruction{exec: func() {
c.ADD8(c.registers.E.Get())
}, cycles: 4}
case 0x84:
return Instruction{exec: func() {
c.ADD8(c.registers.H.Get())
}, cycles: 4}
case 0x85:
return Instruction{exec: func() {
c.ADD8(c.registers.L.Get())
}, cycles: 4}
case 0x86:
return Instruction{exec: func() {
c.ADD8(c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0xC6:
return Instruction{exec: func() {
c.ADD8(c.FetchNextByte())
}, cycles: 8}
case 0x8F:
return Instruction{exec: func() {
c.ADD8(c.registers.A.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x88:
return Instruction{exec: func() {
c.ADD8(c.registers.B.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x89:
return Instruction{exec: func() {
c.ADD8(c.registers.C.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x8A:
return Instruction{exec: func() {
c.ADD8(c.registers.D.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x8B:
return Instruction{exec: func() {
c.ADD8(c.registers.E.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x8C:
return Instruction{exec: func() {
c.ADD8(c.registers.H.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x8D:
return Instruction{exec: func() {
c.ADD8(c.registers.L.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x8E:
return Instruction{exec: func() {
c.ADD8(c.mmu.Get(c.registers.HL.Get()) + c.registers.Flags.Get(registers.C))
}, cycles: 8}
case 0xCE:
return Instruction{exec: func() {
c.ADD8(c.FetchNextByte() + c.registers.Flags.Get(registers.C))
}, cycles: 8}
case 0x97:
return Instruction{exec: func() {
c.SUB8(c.registers.A.Get())
}, cycles: 4}
case 0x90:
return Instruction{exec: func() {
c.SUB8(c.registers.B.Get())
}, cycles: 4}
case 0x91:
return Instruction{exec: func() {
c.SUB8(c.registers.C.Get())
}, cycles: 4}
case 0x92:
return Instruction{exec: func() {
c.SUB8(c.registers.D.Get())
}, cycles: 4}
case 0x93:
return Instruction{exec: func() {
c.SUB8(c.registers.E.Get())
}, cycles: 4}
case 0x94:
return Instruction{exec: func() {
c.SUB8(c.registers.H.Get())
}, cycles: 4}
case 0x95:
return Instruction{exec: func() {
c.SUB8(c.registers.L.Get())
}, cycles: 4}
case 0x96:
return Instruction{exec: func() {
c.SUB8(c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0xD6:
return Instruction{exec: func() {
c.SUB8(c.FetchNextByte())
}, cycles: 8}
case 0x9F:
return Instruction{exec: func() {
c.SUB8(c.registers.A.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x98:
return Instruction{exec: func() {
c.SUB8(c.registers.B.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x99:
return Instruction{exec: func() {
c.SUB8(c.registers.C.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x9A:
return Instruction{exec: func() {
c.SUB8(c.registers.D.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x9B:
return Instruction{exec: func() {
c.SUB8(c.registers.E.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x9C:
return Instruction{exec: func() {
c.SUB8(c.registers.H.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x9D:
return Instruction{exec: func() {
c.SUB8(c.registers.L.Get() + c.registers.Flags.Get(registers.C))
}, cycles: 4}
case 0x9E:
return Instruction{exec: func() {
c.SUB8(c.mmu.Get(c.registers.HL.Get()) + c.registers.Flags.Get(registers.C))
}, cycles: 8}
case 0xDE:
return Instruction{exec: func() {
c.SUB8(c.FetchNextByte() + c.registers.Flags.Get(registers.C))
}, cycles: 8}
case 0xA7:
return Instruction{exec: func() {
c.AND8(c.registers.A.Get())
}, cycles: 4}
case 0xA0:
return Instruction{exec: func() {
c.AND8(c.registers.B.Get())
}, cycles: 4}
case 0xA1:
return Instruction{exec: func() {
c.AND8(c.registers.C.Get())
}, cycles: 4}
case 0xA2:
return Instruction{exec: func() {
c.AND8(c.registers.D.Get())
}, cycles: 4}
case 0xA3:
return Instruction{exec: func() {
c.AND8(c.registers.E.Get())
}, cycles: 4}
case 0xA4:
return Instruction{exec: func() {
c.AND8(c.registers.H.Get())
}, cycles: 4}
case 0xA5:
return Instruction{exec: func() {
c.AND8(c.registers.L.Get())
}, cycles: 4}
case 0xA6:
return Instruction{exec: func() {
c.AND8(c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0xE6:
return Instruction{exec: func() {
c.AND8(c.FetchNextByte())
}, cycles: 8}
case 0xB7:
return Instruction{exec: func() {
c.OR8(c.registers.A.Get())
}, cycles: 4}
case 0xB0:
return Instruction{exec: func() {
c.OR8(c.registers.B.Get())
}, cycles: 4}
case 0xB1:
return Instruction{exec: func() {
c.OR8(c.registers.C.Get())
}, cycles: 4}
case 0xB2:
return Instruction{exec: func() {
c.OR8(c.registers.D.Get())
}, cycles: 4}
case 0xB3:
return Instruction{exec: func() {
c.OR8(c.registers.E.Get())
}, cycles: 4}
case 0xB4:
return Instruction{exec: func() {
c.OR8(c.registers.H.Get())
}, cycles: 4}
case 0xB5:
return Instruction{exec: func() {
c.OR8(c.registers.L.Get())
}, cycles: 4}
case 0xB6:
return Instruction{exec: func() {
c.OR8(c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0xF6:
return Instruction{exec: func() {
c.OR8(c.FetchNextByte())
}, cycles: 8}
case 0xAF:
return Instruction{exec: func() {
c.XOR8(c.registers.A.Get())
}, cycles: 4}
case 0xA8:
return Instruction{exec: func() {
c.XOR8(c.registers.B.Get())
}, cycles: 4}
case 0xA9:
return Instruction{exec: func() {
c.XOR8(c.registers.C.Get())
}, cycles: 4}
case 0xAA:
return Instruction{exec: func() {
c.XOR8(c.registers.D.Get())
}, cycles: 4}
case 0xAB:
return Instruction{exec: func() {
c.XOR8(c.registers.E.Get())
}, cycles: 4}
case 0xAC:
return Instruction{exec: func() {
c.XOR8(c.registers.H.Get())
}, cycles: 4}
case 0xAD:
return Instruction{exec: func() {
c.XOR8(c.registers.L.Get())
}, cycles: 4}
case 0xAE:
return Instruction{exec: func() {
c.XOR8(c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0xEE:
return Instruction{exec: func() {
c.XOR8(c.FetchNextByte())
}, cycles: 8}
case 0xBF:
return Instruction{exec: func() {
c.CP8(c.registers.A.Get())
}, cycles: 4}
case 0xB8:
return Instruction{exec: func() {
c.CP8(c.registers.B.Get())
}, cycles: 4}
case 0xB9:
return Instruction{exec: func() {
c.CP8(c.registers.C.Get())
}, cycles: 4}
case 0xBA:
return Instruction{exec: func() {
c.CP8(c.registers.D.Get())
}, cycles: 4}
case 0xBB:
return Instruction{exec: func() {
c.CP8(c.registers.E.Get())
}, cycles: 4}
case 0xBC:
return Instruction{exec: func() {
c.CP8(c.registers.H.Get())
}, cycles: 4}
case 0xBD:
return Instruction{exec: func() {
c.CP8(c.registers.L.Get())
}, cycles: 4}
case 0xBE:
return Instruction{exec: func() {
c.CP8(c.mmu.Get(c.registers.HL.Get()))
}, cycles: 8}
case 0xFE:
return Instruction{exec: func() {
c.CP8(c.FetchNextByte())
}, cycles: 8}
case 0x3C:
return Instruction{exec: func() {
c.INCr8(c.registers.A)
}, cycles: 4}
case 0x04:
return Instruction{exec: func() {
c.INCr8(c.registers.B)
}, cycles: 4}
case 0x0C:
return Instruction{exec: func() {
c.INCr8(c.registers.C)
}, cycles: 4}
case 0x14:
return Instruction{exec: func() {
c.INCr8(c.registers.D)
}, cycles: 4}
case 0x1C:
return Instruction{exec: func() {
c.INCr8(c.registers.E)
}, cycles: 4}
case 0x24:
return Instruction{exec: func() {
c.INCr8(c.registers.H)
}, cycles: 4}
case 0x2C:
return Instruction{exec: func() {
c.INCr8(c.registers.L)
}, cycles: 4}
case 0x34:
return Instruction{exec: func() {
c.INCm8(c.registers.HL.Get())
}, cycles: 12}
case 0x3D:
return Instruction{exec: func() {
c.DECr8(c.registers.A)
}, cycles: 4}
case 0x05:
return Instruction{exec: func() {
c.DECr8(c.registers.B)
}, cycles: 4}
case 0x0D:
return Instruction{exec: func() {
c.DECr8(c.registers.C)
}, cycles: 4}
case 0x15:
return Instruction{exec: func() {
c.DECr8(c.registers.D)
}, cycles: 4}
case 0x1D:
return Instruction{exec: func() {
c.DECr8(c.registers.E)
}, cycles: 4}
case 0x25:
return Instruction{exec: func() {
c.DECr8(c.registers.H)
}, cycles: 4}
case 0x2D:
return Instruction{exec: func() {
c.DECr8(c.registers.L)
}, cycles: 4}
case 0x35:
return Instruction{exec: func() {
c.DECm8(c.registers.HL.Get())
}, cycles: 12}
case 0x09:
return Instruction{exec: func() {
c.ADD16(c.registers.BC.Get())
}, cycles: 8}
case 0x19:
return Instruction{exec: func() {
c.ADD16(c.registers.DE.Get())
}, cycles: 8}
case 0x29:
return Instruction{exec: func() {
c.ADD16(c.registers.HL.Get())
}, cycles: 8}
case 0x39:
return Instruction{exec: func() {
c.ADD16(c.registers.SP.Get())
}, cycles: 8}
case 0xE8:
return Instruction{exec: func() {
var n = c.FetchNextByte()
// @todo what is this?
if n > 127 {
c.LDr16(&c.registers.SP, c.registers.SP.Get() - types.Word(-n))
} else {
c.LDr16(&c.registers.SP, c.registers.SP.Get() + types.Word(n))
}
var check = c.registers.SP.Get() ^ types.Word(n) ^ ((c.registers.SP.Get() + types.Word(n)) & 0xffff)
// @todo is this the carry alg?
if (check & 0x100) == 0x100 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
// @todo is this the half carry alg?
if (check & 0x10) == 0x10 {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
c.registers.Flags.Reset(registers.Z)
c.registers.Flags.Reset(registers.N)
}, cycles: 16}
case 0x03:
return Instruction{exec: func() {
c.INC16(&c.registers.BC)
}, cycles: 8}
case 0x13:
return Instruction{exec: func() {
c.INC16(&c.registers.DE)
}, cycles: 8}
case 0x23:
return Instruction{exec: func() {
c.INC16(&c.registers.HL)
}, cycles: 8}
case 0x33:
return Instruction{exec: func() {
c.INC16(&c.registers.SP)
}, cycles: 8}
case 0x0B:
return Instruction{exec: func() {
c.DEC16(&c.registers.BC)
}, cycles: 8}
case 0x1B:
return Instruction{exec: func() {
c.DEC16(&c.registers.DE)
}, cycles: 8}
case 0x2B:
return Instruction{exec: func() {
c.DEC16(&c.registers.HL)
}, cycles: 8}
case 0x3B:
return Instruction{exec: func() {
c.DEC16(&c.registers.SP)
}, cycles: 8}
// ALU end
case 0x27:
return Instruction{exec: c.DAA, cycles: 4}
case 0x2F:
return Instruction{exec: c.CPL, cycles: 4}
case 0x3F:
return Instruction{exec: c.CCF, cycles: 4}
case 0x37:
return Instruction{exec: c.SCF, cycles: 4}
case 0x00:
return Instruction{exec: c.NOP, cycles: 4}
case 0x76:
return Instruction{exec: c.HALT, cycles: 4}
case 0x10:
return Instruction{exec: c.STOP, cycles: 4}
case 0xF3:
return Instruction{exec: c.DI, cycles: 4}
case 0xFB:
return Instruction{exec: c.EI, cycles: 4}
case 0x07:
return Instruction{exec: func() {
c.RLCr8(c.registers.A)
}, cycles: 4}
case 0x17:
return Instruction{exec: func() {
c.RLr8(c.registers.A)
}, cycles: 4}
case 0x0F:
return Instruction{exec: func() {
c.RRCr8(c.registers.A)
}, cycles: 4}
case 0x1F:
return Instruction{exec: func() {
c.RRr8(c.registers.A)
}, cycles: 4}
case 0xC3:
return Instruction{exec: func() {
c.JP(c.FetchNextWord())
}, cycles: 12}
case 0xC2:
return Instruction{exec: func() {
c.JPc(registers.N, 0x0, c.FetchNextWord())
}, cycles: 12}
case 0xCA:
return Instruction{exec: func() {
c.JPc(registers.Z, 0x1, c.FetchNextWord())
}, cycles: 12}
case 0xD2:
return Instruction{exec: func() {
c.JPc(registers.C, 0x0, c.FetchNextWord())
}, cycles: 12}
case 0xDA:
return Instruction{exec: func() {
c.JPc(registers.C, 0x1, c.FetchNextWord())
}, cycles: 12}
case 0xE9:
return Instruction{exec: func() {
c.JP(c.registers.HL.Get())
}, cycles: 4}
case 0x18:
return Instruction{exec: func() {
c.JR(c.FetchNextByte())
}, cycles: 8}
case 0x20:
return Instruction{exec: func() {
c.JRc(registers.N, 0x0, c.FetchNextByte())
}, cycles: 8}
case 0x28:
return Instruction{exec: func() {
c.JRc(registers.Z, 0x1, c.FetchNextByte())
}, cycles: 8}
case 0x30:
return Instruction{exec: func() {
c.JRc(registers.C, 0x0, c.FetchNextByte())
}, cycles: 8}
case 0x38:
return Instruction{exec: func() {
c.JRc(registers.C, 0x1, c.FetchNextByte())
}, cycles: 8}
case 0xCD:
return Instruction{exec: func() {
c.CALL(c.FetchNextWord())
}, cycles: 12}
case 0xC4:
return Instruction{exec: func() {
c.CALLc(registers.N, 0x0, c.FetchNextWord())
}, cycles: 12}
case 0xCC:
return Instruction{exec: func() {
c.CALLc(registers.Z, 0x1, c.FetchNextWord())
}, cycles: 12}
case 0xD4:
return Instruction{exec: func() {
c.CALLc(registers.C, 0x0, c.FetchNextWord())
}, cycles: 12}
case 0xDC:
return Instruction{exec: func() {
c.CALLc(registers.C, 0x1, c.FetchNextWord())
}, cycles: 12}
case 0xC7:
return Instruction{exec: func() {
c.RST(0x0)
}, cycles: 16}
case 0xCF:
return Instruction{exec: func() {
c.RST(0x8)
}, cycles: 16}
case 0xD7:
return Instruction{exec: func() {
c.RST(0x10)
}, cycles: 16}
case 0xDF:
return Instruction{exec: func() {
c.RST(0x18)
}, cycles: 16}
case 0xE7:
return Instruction{exec: func() {
c.RST(0x20)
}, cycles: 16}
case 0xEF:
return Instruction{exec: func() {
c.RST(0x28)
}, cycles: 16}
case 0xF7:
return Instruction{exec: func() {
c.RST(0x30)
}, cycles: 16}
case 0xFF:
return Instruction{exec: func() {
c.RST(0x38)
}, cycles: 16}
case 0xC9:
return Instruction{exec: func() {
c.RET()
}, cycles: 8}
case 0xC0:
return Instruction{exec: func() {
c.RETc(registers.N, 0x0)
}, cycles: 8}
case 0xC8:
return Instruction{exec: func() {
c.RETc(registers.Z, 0x1)
}, cycles: 8}
case 0xD0:
return Instruction{exec: func() {
c.RETc(registers.C, 0x0)
}, cycles: 8}
case 0xD8:
return Instruction{exec: func() {
c.RETc(registers.C, 0x1)
}, cycles: 8}
case 0xD9:
return Instruction{exec: c.RETI, cycles: 8}
case 0xCB:
return Instruction{exec: func() {
opcode := c.FetchNextByte()
inst := c.DecodeCB(opcode)
inst.exec()
}, cycles: 4}
default:
log.Fatalf("OpCode 0x%02X not implemented", opcode)
return Instruction{}
}
}
func (c *CPU) DecodeCB(opcode types.Byte) Instruction {
switch opcode {
case 0x37:
return Instruction{exec: func() {
c.SWAPr8(c.registers.A)
}, cycles: 8}
case 0x30:
return Instruction{exec: func() {
c.SWAPr8(c.registers.B)
}, cycles: 8}
case 0x31:
return Instruction{exec: func() {
c.SWAPr8(c.registers.C)
}, cycles: 8}
case 0x32:
return Instruction{exec: func() {
c.SWAPr8(c.registers.D)
}, cycles: 8}
case 0x33:
return Instruction{exec: func() {
c.SWAPr8(c.registers.E)
}, cycles: 8}
case 0x34:
return Instruction{exec: func() {
c.SWAPr8(c.registers.H)
}, cycles: 8}
case 0x35:
return Instruction{exec: func() {
c.SWAPr8(c.registers.L)
}, cycles: 8}
case 0x36:
return Instruction{exec: func() {
c.SWAPm8(c.registers.HL.Get())
}, cycles: 16}
case 0x07:
return Instruction{exec: func() {
c.RLCr8(c.registers.A)
}, cycles: 8}
case 0x00:
return Instruction{exec: func() {
c.RLCr8(c.registers.B)
}, cycles: 8}
case 0x01:
return Instruction{exec: func() {
c.RLCr8(c.registers.C)
}, cycles: 8}
case 0x02:
return Instruction{exec: func() {
c.RLCr8(c.registers.D)
}, cycles: 8}
case 0x03:
return Instruction{exec: func() {
c.RLCr8(c.registers.E)
}, cycles: 8}
case 0x04:
return Instruction{exec: func() {
c.RLCr8(c.registers.H)
}, cycles: 8}
case 0x05:
return Instruction{exec: func() {
c.RLCr8(c.registers.L)
}, cycles: 8}
case 0x06:
return Instruction{exec: func() {
c.RLCm8(c.registers.HL.Get())
}, cycles: 16}
case 0x17:
return Instruction{exec: func() {
c.RLr8(c.registers.A)
}, cycles: 8}
case 0x10:
return Instruction{exec: func() {
c.RLr8(c.registers.B)
}, cycles: 8}
case 0x11:
return Instruction{exec: func() {
c.RLr8(c.registers.C)
}, cycles: 8}
case 0x12:
return Instruction{exec: func() {
c.RLr8(c.registers.D)
}, cycles: 8}
case 0x13:
return Instruction{exec: func() {
c.RLr8(c.registers.E)
}, cycles: 8}
case 0x14:
return Instruction{exec: func() {
c.RLr8(c.registers.H)
}, cycles: 8}
case 0x15:
return Instruction{exec: func() {
c.RLr8(c.registers.L)
}, cycles: 8}
case 0x16:
return Instruction{exec: func() {
c.RLm8(c.registers.HL.Get())
}, cycles: 16}
case 0x0F:
return Instruction{exec: func() {
c.RRCr8(c.registers.A)
}, cycles: 8}
case 0x08:
return Instruction{exec: func() {
c.RRCr8(c.registers.B)
}, cycles: 8}
case 0x09:
return Instruction{exec: func() {
c.RRCr8(c.registers.C)
}, cycles: 8}
case 0x0A:
return Instruction{exec: func() {
c.RRCr8(c.registers.D)
}, cycles: 8}
case 0x0B:
return Instruction{exec: func() {
c.RRCr8(c.registers.E)
}, cycles: 8}
case 0x0C:
return Instruction{exec: func() {
c.RRCr8(c.registers.H)
}, cycles: 8}
case 0x0D:
return Instruction{exec: func() {
c.RRCr8(c.registers.L)
}, cycles: 8}
case 0x0E:
return Instruction{exec: func() {
c.RRCm8(c.registers.HL.Get())
}, cycles: 16}
case 0x1F:
return Instruction{exec: func() {
c.RRr8(c.registers.A)
}, cycles: 8}
case 0x18:
return Instruction{exec: func() {
c.RRr8(c.registers.B)
}, cycles: 8}
case 0x19:
return Instruction{exec: func() {
c.RRr8(c.registers.C)
}, cycles: 8}
case 0x1A:
return Instruction{exec: func() {
c.RRr8(c.registers.D)
}, cycles: 8}
case 0x1B:
return Instruction{exec: func() {
c.RRr8(c.registers.E)
}, cycles: 8}
case 0x1C:
return Instruction{exec: func() {
c.RRr8(c.registers.H)
}, cycles: 8}
case 0x1D:
return Instruction{exec: func() {
c.RRr8(c.registers.L)
}, cycles: 8}
case 0x1E:
return Instruction{exec: func() {
c.RRm8(c.registers.HL.Get())
}, cycles: 16}
case 0x27:
return Instruction{exec: func() {
c.SLAr8(c.registers.A)
}, cycles: 8}
case 0x20:
return Instruction{exec: func() {
c.SLAr8(c.registers.B)
}, cycles: 8}
case 0x21:
return Instruction{exec: func() {
c.SLAr8(c.registers.C)
}, cycles: 8}
case 0x22:
return Instruction{exec: func() {
c.SLAr8(c.registers.D)
}, cycles: 8}
case 0x23:
return Instruction{exec: func() {
c.SLAr8(c.registers.E)
}, cycles: 8}
case 0x24:
return Instruction{exec: func() {
c.SLAr8(c.registers.H)
}, cycles: 8}
case 0x25:
return Instruction{exec: func() {
c.SLAr8(c.registers.L)
}, cycles: 8}
case 0x26:
return Instruction{exec: func() {
c.SLAm8(c.registers.HL.Get())
}, cycles: 16}
case 0x2F:
return Instruction{exec: func() {
c.SRAr8(c.registers.A)
}, cycles: 8}
case 0x28:
return Instruction{exec: func() {
c.SRAr8(c.registers.B)
}, cycles: 8}
case 0x29:
return Instruction{exec: func() {
c.SRAr8(c.registers.C)
}, cycles: 8}
case 0x2A:
return Instruction{exec: func() {
c.SRAr8(c.registers.D)
}, cycles: 8}
case 0x2B:
return Instruction{exec: func() {
c.SRAr8(c.registers.E)
}, cycles: 8}
case 0x2C:
return Instruction{exec: func() {
c.SRAr8(c.registers.H)
}, cycles: 8}
case 0x2D:
return Instruction{exec: func() {
c.SRAr8(c.registers.L)
}, cycles: 8}
case 0x2E:
return Instruction{exec: func() {
c.SRAm8(c.registers.HL.Get())
}, cycles: 16}
case 0x3F:
return Instruction{exec: func() {
c.SRLr8(c.registers.A)
}, cycles: 8}
case 0x38:
return Instruction{exec: func() {
c.SRLr8(c.registers.B)
}, cycles: 8}
case 0x39:
return Instruction{exec: func() {
c.SRLr8(c.registers.C)
}, cycles: 8}
case 0x3A:
return Instruction{exec: func() {
c.SRLr8(c.registers.D)
}, cycles: 8}
case 0x3B:
return Instruction{exec: func() {
c.SRLr8(c.registers.E)
}, cycles: 8}
case 0x3C:
return Instruction{exec: func() {
c.SRLr8(c.registers.H)
}, cycles: 8}
case 0x3D:
return Instruction{exec: func() {
c.SRLr8(c.registers.L)
}, cycles: 8}
case 0x3E:
return Instruction{exec: func() {
c.SRLm8(c.registers.HL.Get())
}, cycles: 16}
case 0x47:
return Instruction{exec: func() {
c.BIT(0, c.registers.A.Get())
}, cycles: 8}
case 0x40:
return Instruction{exec: func() {
c.BIT(0, c.registers.B.Get())
}, cycles: 8}
case 0x41:
return Instruction{exec: func() {
c.BIT(0, c.registers.C.Get())
}, cycles: 8}
case 0x42:
return Instruction{exec: func() {
c.BIT(0, c.registers.D.Get())
}, cycles: 8}
case 0x43:
return Instruction{exec: func() {
c.BIT(0, c.registers.E.Get())
}, cycles: 8}
case 0x44:
return Instruction{exec: func() {
c.BIT(0, c.registers.H.Get())
}, cycles: 8}
case 0x45:
return Instruction{exec: func() {
c.BIT(0, c.registers.L.Get())
}, cycles: 8}
case 0x46:
return Instruction{exec: func() {
c.BIT(0, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 16}
case 0x48:
return Instruction{exec: func() {
c.BIT(1, c.registers.A.Get())
}, cycles: 8}
case 0x49:
return Instruction{exec: func() {
c.BIT(1, c.registers.B.Get())
}, cycles: 8}
case 0x4A:
return Instruction{exec: func() {
c.BIT(1, c.registers.C.Get())
}, cycles: 8}
case 0x4B:
return Instruction{exec: func() {
c.BIT(1, c.registers.D.Get())
}, cycles: 8}
case 0x4C:
return Instruction{exec: func() {
c.BIT(1, c.registers.E.Get())
}, cycles: 8}
case 0x4D:
return Instruction{exec: func() {
c.BIT(1, c.registers.H.Get())
}, cycles: 8}
case 0x4E:
return Instruction{exec: func() {
c.BIT(1, c.registers.L.Get())
}, cycles: 8}
case 0x4F:
return Instruction{exec: func() {
c.BIT(1, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 16}
case 0x57:
return Instruction{exec: func() {
c.BIT(2, c.registers.A.Get())
}, cycles: 8}
case 0x50:
return Instruction{exec: func() {
c.BIT(2, c.registers.B.Get())
}, cycles: 8}
case 0x51:
return Instruction{exec: func() {
c.BIT(2, c.registers.C.Get())
}, cycles: 8}
case 0x52:
return Instruction{exec: func() {
c.BIT(2, c.registers.D.Get())
}, cycles: 8}
case 0x53:
return Instruction{exec: func() {
c.BIT(2, c.registers.E.Get())
}, cycles: 8}
case 0x54:
return Instruction{exec: func() {
c.BIT(2, c.registers.H.Get())
}, cycles: 8}
case 0x55:
return Instruction{exec: func() {
c.BIT(2, c.registers.L.Get())
}, cycles: 8}
case 0x56:
return Instruction{exec: func() {
c.BIT(2, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 16}
case 0x58:
return Instruction{exec: func() {
c.BIT(3, c.registers.A.Get())
}, cycles: 8}
case 0x59:
return Instruction{exec: func() {
c.BIT(3, c.registers.B.Get())
}, cycles: 8}
case 0x5A:
return Instruction{exec: func() {
c.BIT(3, c.registers.C.Get())
}, cycles: 8}
case 0x5B:
return Instruction{exec: func() {
c.BIT(3, c.registers.D.Get())
}, cycles: 8}
case 0x5C:
return Instruction{exec: func() {
c.BIT(3, c.registers.E.Get())
}, cycles: 8}
case 0x5D:
return Instruction{exec: func() {
c.BIT(3, c.registers.H.Get())
}, cycles: 8}
case 0x5E:
return Instruction{exec: func() {
c.BIT(3, c.registers.L.Get())
}, cycles: 8}
case 0x5F:
return Instruction{exec: func() {
c.BIT(3, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 16}
case 0x67:
return Instruction{exec: func() {
c.BIT(4, c.registers.A.Get())
}, cycles: 8}
case 0x60:
return Instruction{exec: func() {
c.BIT(4, c.registers.B.Get())
}, cycles: 8}
case 0x61:
return Instruction{exec: func() {
c.BIT(4, c.registers.C.Get())
}, cycles: 8}
case 0x62:
return Instruction{exec: func() {
c.BIT(4, c.registers.D.Get())
}, cycles: 8}
case 0x63:
return Instruction{exec: func() {
c.BIT(4, c.registers.E.Get())
}, cycles: 8}
case 0x64:
return Instruction{exec: func() {
c.BIT(4, c.registers.H.Get())
}, cycles: 8}
case 0x65:
return Instruction{exec: func() {
c.BIT(4, c.registers.L.Get())
}, cycles: 8}
case 0x66:
return Instruction{exec: func() {
c.BIT(4, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 16}
case 0x68:
return Instruction{exec: func() {
c.BIT(5, c.registers.A.Get())
}, cycles: 8}
case 0x69:
return Instruction{exec: func() {
c.BIT(5, c.registers.B.Get())
}, cycles: 8}
case 0x6A:
return Instruction{exec: func() {
c.BIT(5, c.registers.C.Get())
}, cycles: 8}
case 0x6B:
return Instruction{exec: func() {
c.BIT(5, c.registers.D.Get())
}, cycles: 8}
case 0x6C:
return Instruction{exec: func() {
c.BIT(5, c.registers.E.Get())
}, cycles: 8}
case 0x6D:
return Instruction{exec: func() {
c.BIT(5, c.registers.H.Get())
}, cycles: 8}
case 0x6E:
return Instruction{exec: func() {
c.BIT(5, c.registers.L.Get())
}, cycles: 8}
case 0x6F:
return Instruction{exec: func() {
c.BIT(5, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 16}
case 0x77:
return Instruction{exec: func() {
c.BIT(6, c.registers.A.Get())
}, cycles: 8}
case 0x70:
return Instruction{exec: func() {
c.BIT(6, c.registers.B.Get())
}, cycles: 8}
case 0x71:
return Instruction{exec: func() {
c.BIT(6, c.registers.C.Get())
}, cycles: 8}
case 0x72:
return Instruction{exec: func() {
c.BIT(6, c.registers.D.Get())
}, cycles: 8}
case 0x73:
return Instruction{exec: func() {
c.BIT(6, c.registers.E.Get())
}, cycles: 8}
case 0x74:
return Instruction{exec: func() {
c.BIT(6, c.registers.H.Get())
}, cycles: 8}
case 0x75:
return Instruction{exec: func() {
c.BIT(6, c.registers.L.Get())
}, cycles: 8}
case 0x76:
return Instruction{exec: func() {
c.BIT(6, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 16}
case 0x78:
return Instruction{exec: func() {
c.BIT(7, c.registers.A.Get())
}, cycles: 8}
case 0x79:
return Instruction{exec: func() {
c.BIT(7, c.registers.B.Get())
}, cycles: 8}
case 0x7A:
return Instruction{exec: func() {
c.BIT(7, c.registers.C.Get())
}, cycles: 8}
case 0x7B:
return Instruction{exec: func() {
c.BIT(7, c.registers.D.Get())
}, cycles: 8}
case 0x7C:
return Instruction{exec: func() {
c.BIT(7, c.registers.E.Get())
}, cycles: 8}
case 0x7D:
return Instruction{exec: func() {
c.BIT(7, c.registers.H.Get())
}, cycles: 8}
case 0x7E:
return Instruction{exec: func() {
c.BIT(7, c.registers.L.Get())
}, cycles: 8}
case 0x7F:
return Instruction{exec: func() {
c.BIT(7, c.mmu.Get(c.registers.HL.Get()))
}, cycles: 16}
case 0xC7:
return Instruction{exec: func() {
c.SETr8(0, c.registers.A)
}, cycles: 8}
case 0xC0:
return Instruction{exec: func() {
c.SETr8(0, c.registers.B)
}, cycles: 8}
case 0xC1:
return Instruction{exec: func() {
c.SETr8(0, c.registers.C)
}, cycles: 8}
case 0xC2:
return Instruction{exec: func() {
c.SETr8(0, c.registers.D)
}, cycles: 8}
case 0xC3:
return Instruction{exec: func() {
c.SETr8(0, c.registers.E)
}, cycles: 8}
case 0xC4:
return Instruction{exec: func() {
c.SETr8(0, c.registers.H)
}, cycles: 8}
case 0xC5:
return Instruction{exec: func() {
c.SETr8(0, c.registers.L)
}, cycles: 8}
case 0xC6:
return Instruction{exec: func() {
c.SETm8(0, c.registers.HL.Get())
}, cycles: 16}
case 0xC8:
return Instruction{exec: func() {
c.SETr8(1, c.registers.A)
}, cycles: 8}
case 0xC9:
return Instruction{exec: func() {
c.SETr8(1, c.registers.B)
}, cycles: 8}
case 0xCA:
return Instruction{exec: func() {
c.SETr8(1, c.registers.C)
}, cycles: 8}
case 0xCB:
return Instruction{exec: func() {
c.SETr8(1, c.registers.D)
}, cycles: 8}
case 0xCC:
return Instruction{exec: func() {
c.SETr8(1, c.registers.E)
}, cycles: 8}
case 0xCD:
return Instruction{exec: func() {
c.SETr8(1, c.registers.H)
}, cycles: 8}
case 0xCE:
return Instruction{exec: func() {
c.SETr8(1, c.registers.L)
}, cycles: 8}
case 0xCF:
return Instruction{exec: func() {
c.SETm8(1, c.registers.HL.Get())
}, cycles: 16}
case 0xD7:
return Instruction{exec: func() {
c.SETr8(2, c.registers.A)
}, cycles: 8}
case 0xD0:
return Instruction{exec: func() {
c.SETr8(2, c.registers.B)
}, cycles: 8}
case 0xD1:
return Instruction{exec: func() {
c.SETr8(2, c.registers.C)
}, cycles: 8}
case 0xD2:
return Instruction{exec: func() {
c.SETr8(2, c.registers.D)
}, cycles: 8}
case 0xD3:
return Instruction{exec: func() {
c.SETr8(2, c.registers.E)
}, cycles: 8}
case 0xD4:
return Instruction{exec: func() {
c.SETr8(2, c.registers.H)
}, cycles: 8}
case 0xD5:
return Instruction{exec: func() {
c.SETr8(2, c.registers.L)
}, cycles: 8}
case 0xD6:
return Instruction{exec: func() {
c.SETm8(2, c.registers.HL.Get())
}, cycles: 16}
case 0xD8:
return Instruction{exec: func() {
c.SETr8(3, c.registers.A)
}, cycles: 8}
case 0xD9:
return Instruction{exec: func() {
c.SETr8(3, c.registers.B)
}, cycles: 8}
case 0xDA:
return Instruction{exec: func() {
c.SETr8(3, c.registers.C)
}, cycles: 8}
case 0xDB:
return Instruction{exec: func() {
c.SETr8(3, c.registers.D)
}, cycles: 8}
case 0xDC:
return Instruction{exec: func() {
c.SETr8(3, c.registers.E)
}, cycles: 8}
case 0xDD:
return Instruction{exec: func() {
c.SETr8(3, c.registers.H)
}, cycles: 8}
case 0xDE:
return Instruction{exec: func() {
c.SETr8(3, c.registers.L)
}, cycles: 8}
case 0xDF:
return Instruction{exec: func() {
c.SETm8(3, c.registers.HL.Get())
}, cycles: 16}
case 0xE7:
return Instruction{exec: func() {
c.SETr8(4, c.registers.A)
}, cycles: 8}
case 0xE0:
return Instruction{exec: func() {
c.SETr8(4, c.registers.B)
}, cycles: 8}
case 0xE1:
return Instruction{exec: func() {
c.SETr8(4, c.registers.C)
}, cycles: 8}
case 0xE2:
return Instruction{exec: func() {
c.SETr8(4, c.registers.D)
}, cycles: 8}
case 0xE3:
return Instruction{exec: func() {
c.SETr8(4, c.registers.E)
}, cycles: 8}
case 0xE4:
return Instruction{exec: func() {
c.SETr8(4, c.registers.H)
}, cycles: 8}
case 0xE5:
return Instruction{exec: func() {
c.SETr8(4, c.registers.L)
}, cycles: 8}
case 0xE6:
return Instruction{exec: func() {
c.SETm8(4, c.registers.HL.Get())
}, cycles: 16}
case 0xE8:
return Instruction{exec: func() {
c.SETr8(5, c.registers.A)
}, cycles: 8}
case 0xE9:
return Instruction{exec: func() {
c.SETr8(5, c.registers.B)
}, cycles: 8}
case 0xEA:
return Instruction{exec: func() {
c.SETr8(5, c.registers.C)
}, cycles: 8}
case 0xEB:
return Instruction{exec: func() {
c.SETr8(5, c.registers.D)
}, cycles: 8}
case 0xEC:
return Instruction{exec: func() {
c.SETr8(5, c.registers.E)
}, cycles: 8}
case 0xED:
return Instruction{exec: func() {
c.SETr8(5, c.registers.H)
}, cycles: 8}
case 0xEE:
return Instruction{exec: func() {
c.SETr8(5, c.registers.L)
}, cycles: 8}
case 0xEF:
return Instruction{exec: func() {
c.SETm8(5, c.registers.HL.Get())
}, cycles: 16}
case 0xF7:
return Instruction{exec: func() {
c.SETr8(6, c.registers.A)
}, cycles: 8}
case 0xF0:
return Instruction{exec: func() {
c.SETr8(6, c.registers.B)
}, cycles: 8}
case 0xF1:
return Instruction{exec: func() {
c.SETr8(6, c.registers.C)
}, cycles: 8}
case 0xF2:
return Instruction{exec: func() {
c.SETr8(6, c.registers.D)
}, cycles: 8}
case 0xF3:
return Instruction{exec: func() {
c.SETr8(6, c.registers.E)
}, cycles: 8}
case 0xF4:
return Instruction{exec: func() {
c.SETr8(6, c.registers.H)
}, cycles: 8}
case 0xF5:
return Instruction{exec: func() {
c.SETr8(6, c.registers.L)
}, cycles: 8}
case 0xF6:
return Instruction{exec: func() {
c.SETm8(6, c.registers.HL.Get())
}, cycles: 16}
case 0xF8:
return Instruction{exec: func() {
c.SETr8(7, c.registers.A)
}, cycles: 8}
case 0xF9:
return Instruction{exec: func() {
c.SETr8(7, c.registers.B)
}, cycles: 8}
case 0xFA:
return Instruction{exec: func() {
c.SETr8(7, c.registers.C)
}, cycles: 8}
case 0xFB:
return Instruction{exec: func() {
c.SETr8(7, c.registers.D)
}, cycles: 8}
case 0xFC:
return Instruction{exec: func() {
c.SETr8(7, c.registers.E)
}, cycles: 8}
case 0xFD:
return Instruction{exec: func() {
c.SETr8(7, c.registers.H)
}, cycles: 8}
case 0xFE:
return Instruction{exec: func() {
c.SETr8(7, c.registers.L)
}, cycles: 8}
case 0xFF:
return Instruction{exec: func() {
c.SETm8(7, c.registers.HL.Get())
}, cycles: 16}
case 0x87:
return Instruction{exec: func() {
c.RESr8(0, c.registers.A)
}, cycles: 8}
case 0x80:
return Instruction{exec: func() {
c.RESr8(0, c.registers.B)
}, cycles: 8}
case 0x81:
return Instruction{exec: func() {
c.RESr8(0, c.registers.C)
}, cycles: 8}
case 0x82:
return Instruction{exec: func() {
c.RESr8(0, c.registers.D)
}, cycles: 8}
case 0x83:
return Instruction{exec: func() {
c.RESr8(0, c.registers.E)
}, cycles: 8}
case 0x84:
return Instruction{exec: func() {
c.RESr8(0, c.registers.H)
}, cycles: 8}
case 0x85:
return Instruction{exec: func() {
c.RESr8(0, c.registers.L)
}, cycles: 8}
case 0x86:
return Instruction{exec: func() {
c.RESm8(0, c.registers.HL.Get())
}, cycles: 16}
case 0x88:
return Instruction{exec: func() {
c.RESr8(1, c.registers.A)
}, cycles: 8}
case 0x89:
return Instruction{exec: func() {
c.RESr8(1, c.registers.B)
}, cycles: 8}
case 0x8A:
return Instruction{exec: func() {
c.RESr8(1, c.registers.C)
}, cycles: 8}
case 0x8B:
return Instruction{exec: func() {
c.RESr8(1, c.registers.D)
}, cycles: 8}
case 0x8C:
return Instruction{exec: func() {
c.RESr8(1, c.registers.E)
}, cycles: 8}
case 0x8D:
return Instruction{exec: func() {
c.RESr8(1, c.registers.H)
}, cycles: 8}
case 0x8E:
return Instruction{exec: func() {
c.RESr8(1, c.registers.L)
}, cycles: 8}
case 0x8F:
return Instruction{exec: func() {
c.RESm8(1, c.registers.HL.Get())
}, cycles: 16}
case 0x97:
return Instruction{exec: func() {
c.RESr8(2, c.registers.A)
}, cycles: 8}
case 0x90:
return Instruction{exec: func() {
c.RESr8(2, c.registers.B)
}, cycles: 8}
case 0x91:
return Instruction{exec: func() {
c.RESr8(2, c.registers.C)
}, cycles: 8}
case 0x92:
return Instruction{exec: func() {
c.RESr8(2, c.registers.D)
}, cycles: 8}
case 0x93:
return Instruction{exec: func() {
c.RESr8(2, c.registers.E)
}, cycles: 8}
case 0x94:
return Instruction{exec: func() {
c.RESr8(2, c.registers.H)
}, cycles: 8}
case 0x95:
return Instruction{exec: func() {
c.RESr8(2, c.registers.L)
}, cycles: 8}
case 0x96:
return Instruction{exec: func() {
c.RESm8(2, c.registers.HL.Get())
}, cycles: 16}
case 0x98:
return Instruction{exec: func() {
c.RESr8(3, c.registers.A)
}, cycles: 8}
case 0x99:
return Instruction{exec: func() {
c.RESr8(3, c.registers.B)
}, cycles: 8}
case 0x9A:
return Instruction{exec: func() {
c.RESr8(3, c.registers.C)
}, cycles: 8}
case 0x9B:
return Instruction{exec: func() {
c.RESr8(3, c.registers.D)
}, cycles: 8}
case 0x9C:
return Instruction{exec: func() {
c.RESr8(3, c.registers.E)
}, cycles: 8}
case 0x9D:
return Instruction{exec: func() {
c.RESr8(3, c.registers.H)
}, cycles: 8}
case 0x9E:
return Instruction{exec: func() {
c.RESr8(3, c.registers.L)
}, cycles: 8}
case 0x9F:
return Instruction{exec: func() {
c.RESm8(3, c.registers.HL.Get())
}, cycles: 16}
case 0xA7:
return Instruction{exec: func() {
c.RESr8(4, c.registers.A)
}, cycles: 8}
case 0xA0:
return Instruction{exec: func() {
c.RESr8(4, c.registers.B)
}, cycles: 8}
case 0xA1:
return Instruction{exec: func() {
c.RESr8(4, c.registers.C)
}, cycles: 8}
case 0xA2:
return Instruction{exec: func() {
c.RESr8(4, c.registers.D)
}, cycles: 8}
case 0xA3:
return Instruction{exec: func() {
c.RESr8(4, c.registers.E)
}, cycles: 8}
case 0xA4:
return Instruction{exec: func() {
c.RESr8(4, c.registers.H)
}, cycles: 8}
case 0xA5:
return Instruction{exec: func() {
c.RESr8(4, c.registers.L)
}, cycles: 8}
case 0xA6:
return Instruction{exec: func() {
c.RESm8(4, c.registers.HL.Get())
}, cycles: 16}
case 0xA8:
return Instruction{exec: func() {
c.RESr8(5, c.registers.A)
}, cycles: 8}
case 0xA9:
return Instruction{exec: func() {
c.RESr8(5, c.registers.B)
}, cycles: 8}
case 0xAA:
return Instruction{exec: func() {
c.RESr8(5, c.registers.C)
}, cycles: 8}
case 0xAB:
return Instruction{exec: func() {
c.RESr8(5, c.registers.D)
}, cycles: 8}
case 0xAC:
return Instruction{exec: func() {
c.RESr8(5, c.registers.E)
}, cycles: 8}
case 0xAD:
return Instruction{exec: func() {
c.RESr8(5, c.registers.H)
}, cycles: 8}
case 0xAE:
return Instruction{exec: func() {
c.RESr8(5, c.registers.L)
}, cycles: 8}
case 0xAF:
return Instruction{exec: func() {
c.RESm8(5, c.registers.HL.Get())
}, cycles: 16}
case 0xB7:
return Instruction{exec: func() {
c.RESr8(6, c.registers.A)
}, cycles: 8}
case 0xB0:
return Instruction{exec: func() {
c.RESr8(6, c.registers.B)
}, cycles: 8}
case 0xB1:
return Instruction{exec: func() {
c.RESr8(6, c.registers.C)
}, cycles: 8}
case 0xB2:
return Instruction{exec: func() {
c.RESr8(6, c.registers.D)
}, cycles: 8}
case 0xB3:
return Instruction{exec: func() {
c.RESr8(6, c.registers.E)
}, cycles: 8}
case 0xB4:
return Instruction{exec: func() {
c.RESr8(6, c.registers.H)
}, cycles: 8}
case 0xB5:
return Instruction{exec: func() {
c.RESr8(6, c.registers.L)
}, cycles: 8}
case 0xB6:
return Instruction{exec: func() {
c.RESm8(6, c.registers.HL.Get())
}, cycles: 16}
case 0xB8:
return Instruction{exec: func() {
c.RESr8(7, c.registers.A)
}, cycles: 8}
case 0xB9:
return Instruction{exec: func() {
c.RESr8(7, c.registers.B)
}, cycles: 8}
case 0xBA:
return Instruction{exec: func() {
c.RESr8(7, c.registers.C)
}, cycles: 8}
case 0xBB:
return Instruction{exec: func() {
c.RESr8(7, c.registers.D)
}, cycles: 8}
case 0xBC:
return Instruction{exec: func() {
c.RESr8(7, c.registers.E)
}, cycles: 8}
case 0xBD:
return Instruction{exec: func() {
c.RESr8(7, c.registers.H)
}, cycles: 8}
case 0xBE:
return Instruction{exec: func() {
c.RESr8(7, c.registers.L)
}, cycles: 8}
case 0xBF:
return Instruction{exec: func() {
c.RESm8(7, c.registers.HL.Get())
}, cycles: 16}
default:
log.Fatalf("OpCode 0xCB%02X not implemented", opcode)
return Instruction{}
}
}
// Load a byte into a register
func (c *CPU) LDr16(r registers.WordRegister, w types.Word) {
r.Set(w)
}
// Load a byte into a register
func (c *CPU) LDr8(r types.ByteRegister, b types.Byte) {
r.Set(b)
}
// Load a byte into a memory address
func (c *CPU) LDm8(address types.Word, b types.Byte) {
c.mmu.Set(address, b)
}
func (c *CPU) NOP() {
}
func (c *CPU) Run() {
for {
opcode := c.FetchNextByte()
inst := c.Decode(opcode)
inst.exec()
}
}
func (c *CPU) FetchNextByte() types.Byte {
b := c.mmu.Get(c.registers.PC.Get())
c.INC16(&c.registers.PC)
return b
}
func (c *CPU) FetchNextWord() types.Word {
l := c.FetchNextByte()
h := c.FetchNextByte()
return types.WordFromBytes(h, l)
}
func (c *CPU) PushWord(w types.Word) {
h, l := types.WordToBytes(w)
c.PushByte(h)
c.PushByte(l)
}
func (c *CPU) PushByte(b types.Byte) {
c.DEC16(&c.registers.SP)
c.mmu.Set(c.registers.SP.Get(), b)
}
func (c *CPU) DEC16(r registers.WordRegister) {
r.Set(r.Get() - 0x1)
}
func (c *CPU) DECr8(r types.ByteRegister) {
result := r.Get() - 0x1
c.registers.Flags.Set(registers.N)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
if (result^0x01^r.Get())&0x10 == 0x10 {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
r.Set(result)
}
func (c *CPU) DECm8(address types.Word) {
result := c.mmu.Get(address) - 0x1
c.registers.Flags.Set(registers.N)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
if (result^0x01^ c.mmu.Get(address))&0x10 == 0x10 {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
c.mmu.Set(address, result)
}
func (c *CPU) INC16(r registers.WordRegister) {
r.Set(r.Get() + 0x1)
}
func (c *CPU) INCr8(r types.ByteRegister) {
result := r.Get() + 0x1
c.registers.Flags.Reset(registers.N)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
if (result^0x01^r.Get())&0x10 == 0x10 {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
r.Set(result)
}
func (c *CPU) INCm8(address types.Word) {
result := c.mmu.Get(address) + 0x1
c.registers.Flags.Reset(registers.N)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
if (result^0x01^c.mmu.Get(address))&0x10 == 0x10 {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
c.mmu.Set(address, result)
}
func (c *CPU) PopWord(r registers.WordRegister) {
l := c.mmu.Get(c.registers.SP.Get())
c.INC16(&c.registers.SP)
h := c.mmu.Get(c.registers.SP.Get())
c.INC16(&c.registers.SP)
r.Set(types.WordFromBytes(h, l))
}
func (c *CPU) PopByte(r types.ByteRegister) {
r.Set(c.mmu.Get(c.registers.SP.Get()))
c.INC16(&c.registers.SP)
}
func (c *CPU) ADD8(b types.Byte) {
result := c.registers.A.Get() + b
c.registers.Flags.Reset(registers.N)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
if (result ^ b ^ c.registers.A.Get()) & 0x10 == 0x10 {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
if result < c.registers.A.Get() {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
c.registers.A.Set(result)
}
func (c *CPU) ADD16(b types.Word) {
result := c.registers.HL.Get() + b
c.registers.Flags.Reset(registers.N)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
if (result ^ b ^ c.registers.HL.Get()) & 0x1000 == 0x1000 {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
if result < c.registers.HL.Get() {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
c.registers.HL.Set(result)
}
func (c *CPU) SUB8(b types.Byte) {
result := c.registers.A.Get() - b
c.registers.Flags.Set(registers.N)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
if (int(c.registers.A.Get()) & 0xF) < (int(b) & 0xF) {
c.registers.Flags.Set(registers.H)
} else {
c.registers.Flags.Reset(registers.H)
}
if (int(c.registers.A.Get()) & 0xFF) < (int(b) & 0xFF) {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
c.registers.A.Set(result)
}
func (c *CPU) AND8(b types.Byte) {
result := c.registers.A.Get() & b
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.C)
c.registers.Flags.Set(registers.H)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.registers.A.Set(result)
}
func (c *CPU) OR8(b types.Byte) {
result := c.registers.A.Get() | b
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.C)
c.registers.Flags.Reset(registers.H)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.registers.A.Set(result)
}
func (c *CPU) XOR8(b types.Byte) {
result := c.registers.A.Get() ^ b
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.C)
c.registers.Flags.Reset(registers.H)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.registers.A.Set(result)
}
func (c *CPU) CP8(b types.Byte) {
result := c.registers.A.Get() - b
// @todo
c.registers.A.Set(result)
}
func (c *CPU) BIT(bit byte, b types.Byte) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Set(registers.H)
if types.GetBit(bit, b) == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
}
func (c *CPU) SETr8(bit byte, r types.ByteRegister) {
r.Set(types.SetBit(bit, r.Get()))
}
func (c *CPU) SETm8(bit byte, address types.Word) {
c.mmu.Set(address, types.SetBit(bit, c.mmu.Get(address)))
}
func (c *CPU) RESr8(bit byte, r types.ByteRegister) {
r.Set(types.ResetBit(bit, r.Get()))
}
func (c *CPU) RESm8(bit byte, address types.Word) {
c.mmu.Set(address, types.ResetBit(bit, c.mmu.Get(address)))
}
func (c *CPU) SWAPr8(r types.ByteRegister) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
c.registers.Flags.Reset(registers.C)
result := ((uint16(r.Get()) << 4) | (uint16(r.Get()) >> 4)) & 0xFF
r.Set(types.Byte(result))
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
}
func (c *CPU) SWAPm8(address types.Word) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
c.registers.Flags.Reset(registers.C)
result := ((uint16(c.mmu.Get(address)) << 4) | (uint16(c.mmu.Get(address)) >> 4)) & 0xFF
c.mmu.Set(address, types.Byte(result))
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
}
func (c *CPU) CCF() {
if c.registers.Flags.Get(registers.C) == 0x1 {
c.registers.Flags.Reset(registers.C)
} else {
c.registers.Flags.Set(registers.C)
}
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
}
func (c *CPU) SCF() {
c.registers.Flags.Set(registers.C)
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
}
func (c *CPU) DAA() {
// @todo
}
func (c *CPU) CPL() {
// @todo
}
func (c *CPU) HALT() {
// @todo
}
func (c *CPU) STOP() {
// @todo
c.HALT()
}
func (c *CPU) DI() {
// @todo
}
func (c *CPU) EI() {
// @todo
}
func (c *CPU) RLCr8(r types.ByteRegister) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
if r.Get() & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
}
result := (r.Get() << 1) | c.registers.Flags.Get(registers.C)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
r.Set(result)
}
func (c *CPU) RLr8(r types.ByteRegister) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := (r.Get() << 1) | c.registers.Flags.Get(registers.C)
if r.Get() & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
r.Set(result)
}
func (c *CPU) RRCr8(r types.ByteRegister) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
if r.Get() & 0x01 == 0x01 {
c.registers.Flags.Set(registers.C)
}
result := (r.Get() >> 1) | (c.registers.Flags.Get(registers.C) << 7)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
r.Set(result)
}
func (c *CPU) RRr8(r types.ByteRegister) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := (r.Get() >> 1) | (c.registers.Flags.Get(registers.C) << 7)
if r.Get() & 0x01 == 0x01 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
r.Set(result)
}
func (c *CPU) RLCm8(address types.Word) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
if c.mmu.Get(address) & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
}
result := (c.mmu.Get(address) << 1) | c.registers.Flags.Get(registers.C)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.mmu.Set(address, result)
}
func (c *CPU) RLm8(address types.Word) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := (c.mmu.Get(address) << 1) | c.registers.Flags.Get(registers.C)
if c.mmu.Get(address) & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.mmu.Set(address, result)
}
func (c *CPU) RRCm8(address types.Word) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
if c.mmu.Get(address) & 0x01 == 0x01 {
c.registers.Flags.Set(registers.C)
}
result := (c.mmu.Get(address) >> 1) | (c.registers.Flags.Get(registers.C) << 7)
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.mmu.Set(address, result)
}
func (c *CPU) RRm8(address types.Word) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := (c.mmu.Get(address) >> 1) | (c.registers.Flags.Get(registers.C) << 7)
if c.mmu.Get(address) & 0x01 == 0x01 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.mmu.Set(address, result)
}
func (c *CPU) SLAr8(r types.ByteRegister) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := r.Get() << 1
if r.Get() & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
r.Set(result)
}
func (c *CPU) SLAm8(address types.Word) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := c.mmu.Get(address) << 1
if c.mmu.Get(address) & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.mmu.Set(address, result)
}
func (c *CPU) SRAr8(r types.ByteRegister) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := (r.Get() >> 1) | (r.Get() & 0x80)
if r.Get() & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
r.Set(result)
}
func (c *CPU) SRAm8(address types.Word) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := (c.mmu.Get(address) >> 1) | (c.mmu.Get(address) & 0x80)
if c.mmu.Get(address) & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.mmu.Set(address, result)
}
func (c *CPU) SRLr8(r types.ByteRegister) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := r.Get() >> 1
if r.Get() & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
r.Set(result)
}
func (c *CPU) SRLm8(address types.Word) {
c.registers.Flags.Reset(registers.N)
c.registers.Flags.Reset(registers.H)
result := c.mmu.Get(address) >> 1
if c.mmu.Get(address) & 0x80 == 0x80 {
c.registers.Flags.Set(registers.C)
} else {
c.registers.Flags.Reset(registers.C)
}
if result == 0x0 {
c.registers.Flags.Set(registers.Z)
} else {
c.registers.Flags.Reset(registers.Z)
}
c.mmu.Set(address, result)
}
func (c *CPU) JP(address types.Word) {
c.registers.PC.Set(address)
}
func (c *CPU) JPc(flag int, flagValue types.Byte, address types.Word) {
if c.registers.Flags.Get(flag) == flagValue {
c.JP(address)
}
}
func (c *CPU) JR(b types.Byte) {
c.JP(c.registers.PC.Get() + types.Word(b))
}
func (c *CPU) JRc(flag int, flagValue types.Byte, b types.Byte) {
if c.registers.Flags.Get(flag) == flagValue {
c.JR(b)
}
}
func (c *CPU) CALL(address types.Word) {
c.PushWord(c.registers.PC.Get() + 0x3)
c.JP(address)
}
func (c *CPU) CALLc(flag int, flagValue types.Byte, address types.Word) {
if c.registers.Flags.Get(flag) == flagValue {
c.CALL(address)
}
}
func (c *CPU) RST(address types.Word) {
c.PushWord(c.registers.PC.Get() + 0x1)
c.JP(address)
}
func (c *CPU) RET() {
c.PopWord(&c.registers.PC)
}
func (c *CPU) RETc(flag int, flagValue types.Byte) {
if c.registers.Flags.Get(flag) == flagValue {
c.RET()
}
}
func (c *CPU) RETI() {
c.RET()
c.EI()
} |
package repository
import (
db "bareksa-test/database"
fx "bareksa-test/function"
md "bareksa-test/model"
st "bareksa-test/struck"
"context"
)
type TagsRepository struct {
DB db.Database
}
func InitiateTagsRepository(db db.Database) md.TagsRepository {
return &TagsRepository{
DB: db,
}
}
func (r *TagsRepository) Add(ctx context.Context, tag md.Tag, logs *[]st.Log) (response *md.Response, err error) {
// add news
sAdd, _, _ := fx.DoRawQuery(
r.DB.HerokuDB,
"insert into news_tag (news_id, tag_id, status, create_by) values (@NewsID, @TagID, @Status, @CreateBy) on conflict (news_id, tag_id) do update set status = @Status, update_date = now(), update_by = @UpdateBy;",
map[string]interface{}{"NewsID": tag.NewsID, "TagID": tag.ID, "Status": "A", "CreateBy": "Admin", "UpdateBy": "Admin"},
nil,
logs)
// err
if sAdd == 1 {
return &md.Response{
Status: "500",
Msg: "Terjadi Kesalahan",
}, nil
}
// // duplicate user
// if eCreate.Status == fx.ConvStrToInt(os.Getenv("ERR_DATA_DUPLICATE_CODE"), 553) {
// return ct.Register(ct.Response(os.Getenv("RESPONSE_ACCOUNT_DUPLICATED_CODE"), os.Getenv("RESPONSE_ACCOUNT_DUPLICATED")), md.User{}), nil
// }
return &md.Response{
Status: "200",
Msg: "Success",
}, nil
}
func (r *TagsRepository) Remove(ctx context.Context, tag md.Tag, logs *[]st.Log) (response *md.Response, err error) {
// update news
sUpdate, _, _ := fx.DoRawQuery(
r.DB.HerokuDB,
"update news_tag set status = @Status, update_date = now(), update_by = @UpdateBy where news_id = @NewsID and tag_id = @TagID;",
map[string]interface{}{"NewsID": tag.NewsID, "TagID": tag.ID, "Status": "I", "UpdateBy": "Admin"},
nil,
logs)
// err
if sUpdate == 1 {
return &md.Response{
Status: "500",
Msg: "Terjadi Kesalahan",
}, nil
}
return &md.Response{
Status: "200",
Msg: "Success",
}, nil
}
func (r *TagsRepository) List(ctx context.Context, tag md.Tag, logs *[]st.Log) (response *md.TagListResponse, err error) {
// var
var tags []md.Tag = []md.Tag{}
// get news
sGet, _, _ := fx.DoRawQuery(
r.DB.HerokuDB,
"select b.id, b.name, a.news_id, a.status, a.create_by, a.update_by, a.create_date, a.update_date from news_tag a inner join master_tag b on a.tag_id = b.id where news_id = @NewsID ",
map[string]interface{}{"NewsID": tag.NewsID},
&tags,
logs)
// err
if sGet == 1 {
return &md.TagListResponse{
Response: md.Response{
Status: "500",
Msg: "Terjadi Kesalahan",
},
Tags: tags,
}, nil
}
// empty
if len(tags) == 0 {
return &md.TagListResponse{
Response: md.Response{
Status: "404",
Msg: "Data kosong",
},
Tags: tags,
}, nil
}
return &md.TagListResponse{
Response: md.Response{
Status: "200",
Msg: "Success",
},
Tags: tags,
}, nil
}
|
package main
type land struct {
r, c int
}
func numIslands(grid [][]byte) int {
var lands []*land
mark := make([][]bool, len(grid))
for i := 0; i < len(grid); i++ {
mark[i] = make([]bool, len(grid[i]))
for j := 0; j < len(grid[i]); j++ {
if grid[i][j] == '1' {
lands = append(lands, &land{i, j})
}
}
}
var walk func(r, c int)
walk = func(r, c int) {
if r < 0 || r >= len(grid) ||
c < 0 || c >= len(grid[r]) ||
mark[r][c] || grid[r][c] != '1' {
return
}
mark[r][c] = true
walk(r-1, c) // up
walk(r+1, c) // down
walk(r, c-1) // left
walk(r, c+1) // right
}
res := 0
for pos := 0; pos < len(lands); pos++ {
l := lands[pos]
if mark[l.r][l.c] {
continue
}
walk(l.r, l.c)
res++
}
return res
}
|
package httptools
import (
"encoding/json"
"errors"
"fmt"
"io"
"mime"
"mime/multipart"
"net/http"
"os"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"text/template"
"time"
"github.com/elitah/fast-io"
"github.com/elitah/utils/bufferpool"
)
const (
flagOutput = iota
flagDebug
flagMax
flagOutputEnabled
flagOutputDisabled
flagDebugEnabled
flagDebugDisabled
)
var (
DebugBufferLength = 32
funcs = make(template.FuncMap)
pool = &sync.Pool{
New: func() interface{} {
return &httpHandler{
Request: nil,
}
},
}
)
type httpHandler struct {
*http.Request
body io.ReadCloser
flags [flagMax]uint32
statusCode int
location string
contentType string
start int64
rb *bufferpool.Buffer
wb *bufferpool.Buffer
jenc *json.Encoder
}
func (this *httpHandler) Release() {
if nil != this.body {
this.body.Close()
}
this.Request.Body.Close()
this.rb.Free()
this.wb.Free()
this.rb = nil
this.wb = nil
this.jenc = nil
pool.Put(this)
}
func (this *httpHandler) OutputEnabled(flag bool) {
if flag {
atomic.StoreUint32(&this.flags[flagOutput], flagOutputEnabled)
return
}
atomic.StoreUint32(&this.flags[flagOutput], flagOutputDisabled)
}
func (this *httpHandler) Debug(flag bool) {
if flag {
atomic.StoreUint32(&this.flags[flagDebug], flagDebugEnabled)
return
}
atomic.StoreUint32(&this.flags[flagDebug], flagDebugDisabled)
}
func (this *httpHandler) GetPath() string {
return this.URL.Path
}
func (this *httpHandler) GetJson(v interface{}) error {
if 0 < this.rb.Len() {
//
return json.Unmarshal(this.rb.Bytes(), v)
}
return nil
}
func (this *httpHandler) GetUpload(fn func(*multipart.Part) bool) error {
if reader, err := this.MultipartReader(); nil == err {
for {
if part, err := reader.NextPart(); nil == err {
if !fn(part) {
return nil
}
} else {
if errors.Is(err, io.EOF) {
return nil
} else {
return err
}
}
}
} else {
return err
}
}
func (this *httpHandler) SetContentType(ct string) {
this.contentType = ct
}
func (this *httpHandler) SendHttpCode(code int) {
this.statusCode = code
}
func (this *httpHandler) SendHttpRedirect(l string) {
// 重定向
this.location = l
}
func (this *httpHandler) NotFound() {
// 发送HTTP状态码：404 Not Found
this.SendHttpCode(http.StatusNotFound)
}
func (this *httpHandler) HttpOnlyIs(methods ...string) bool {
// 判断是否是指定方法
for _, method := range methods {
if method == this.Method {
return true
}
}
// 如果是HEAD方法，如果允许的方法是GET，那么返回200 OK
if "HEAD" == this.Method {
for _, method := range methods {
if "GET" == method {
this.SendHttpCode(http.StatusOK)
return false
}
}
}
// 发送HTTP状态码：405 Method Not Allowed
this.SendHttpCode(http.StatusMethodNotAllowed)
// 返回false
return false
}
func (this *httpHandler) SendJSAlert(args ...string) {
var title, msg, redirect string = "提示", "未填写消息内容", ""
if 1 <= len(args) && "" != args[0] {
title = args[0]
}
if 2 <= len(args) && "" != args[1] {
msg = args[1]
}
if 3 <= len(args) && "" != args[2] {
redirect = args[2]
}
if "" != redirect {
msg = fmt.Sprintf(`<script>alert('%s'); window.location.href = '%s';</script>`, msg, redirect)
} else {
msg = fmt.Sprintf(`<h3>%s</h3>`, msg)
}
// 清空缓冲
this.wb.Reset()
// 设置ContentType
this.contentType = "text/html"
fmt.Fprintf(this.wb, `<!DOCTYPE html>
<html lang="zh-cn">
<head>
<title>%s</title>
</head>
<body>
%s
</body>
</html>
`, title, msg)
}
func (this *httpHandler) SendHTML(args ...interface{}) {
// 设置ContentType
if "" == this.contentType {
this.contentType = "text/html"
}
// 参数
if 2 <= len(args) {
if format, ok := args[0].(string); ok {
// if format = `<img src="%s" style="width: 100%%" />`
if strings.Contains(format, "%") {
fmt.Fprintf(this.wb, format, args[1:]...)
return
}
}
}
//
fmt.Fprint(this.wb, args...)
}
func (this *httpHandler) SendHttpString(args ...interface{}) {
// 清空缓冲
this.wb.Reset()
// 设置ContentType
this.contentType = "text/plain"
// 写HTTP数据
if 2 <= len(args) {
if format, ok := args[0].(string); ok {
// if format = `<img src="%s" style="width: 100%%" />`
if strings.Contains(format, "%") {
fmt.Fprintf(this.wb, format, args[1:]...)
return
}
}
}
//
fmt.Fprint(this.wb, args...)
}
func (this *httpHandler) SendJsonString(s string) {
// 清空缓冲
this.wb.Reset()
// 设置ContentType
this.contentType = "application/json"
// 写Json数据
this.wb.WriteString(s)
}
func (this *httpHandler) SendJson(v interface{}) error {
if nil == this.jenc {
this.jenc = json.NewEncoder(this.wb)
}
if nil != this.jenc {
// 清空缓冲
this.wb.Reset()
// 设置ContentType
this.contentType = "application/json"
// 输出
return this.jenc.Encode(v)
}
// 输出json
if data, err := json.Marshal(v); nil == err {
if _, err = this.wb.Write(data); nil == err {
return nil
} else {
return err
}
} else {
return err
}
}
func (this *httpHandler) SendFile(path string) (bool, error) {
// 打开模板文件
if f, err := os.Open(path); nil == err {
// 退出是关闭文件
defer f.Close()
//
this.wb.Reset()
//
if _, err = fast_io.Copy(this.wb, f); nil == err {
this.contentType = mime.TypeByExtension(filepath.Ext(path))
return true, nil
} else {
return true, err
}
} else {
return false, err
}
}
func (this *httpHandler) Write(p []byte) (n int, err error) {
return this.wb.Write(p)
}
func (this *httpHandler) TemplateWrite(content []byte, data interface{}, ct string) error {
// 解析模板
if t, err := template.New(this.GetPath()).Funcs(funcs).Parse(string(content)); nil == err {
// 复位
this.wb.Reset()
// 执行模板
if err := t.Execute(this.wb, data); nil == err {
// 设置Content-Type
this.contentType = ct
// 返回
return nil
} else {
//
this.statusCode = http.StatusInternalServerError
// 模板错误，复位
this.wb.Reset()
// 返回错误
return err
}
} else {
// 返回错误
return err
}
}
func (this *httpHandler) TemplateFileWrite(path string, data interface{}) (bool, error) {
// 打开模板文件
if f, err := os.Open(path); nil == err {
// 退出是关闭文件
defer f.Close()
// 得到buffer
if b := bufferpool.Get(); nil != b {
// 退出是释放buffer
defer b.Free()
// 直接复制
b.ReadFrom(f)
// 解析
return true, this.TemplateWrite(b.Bytes(), data, mime.TypeByExtension(filepath.Ext(path)))
} else {
return true, fmt.Errorf("no buffer can be used")
}
} else {
return false, err
}
}
func (this *httpHandler) Output(w http.ResponseWriter) string {
var debug *bufferpool.Buffer
if flagOutputDisabled == atomic.LoadUint32(&this.flags[flagOutput]) {
return ""
}
if flagDebugEnabled == atomic.LoadUint32(&this.flags[flagDebug]) {
if b := bufferpool.Get(); nil != b {
//
defer b.Free()
//
b.Reset()
//
b.WriteString("================================================\n")
//
fmt.Fprintf(b, "Action: %s | %s(%s) | %s | %s\n", this.Method, this.Host, this.URL.Host, this.GetPath(), this.URL.RequestURI())
fmt.Fprintf(b, "Cost: %.3f ms\n", float64((time.Now().UnixNano()/1000)-this.start)/1000.0)
fmt.Fprintf(b, "Flags: %v\n", this.flags)
fmt.Fprintf(b, "StatusCode: %d\n", this.statusCode)
fmt.Fprintf(b, "Location: %s\n", this.location)
fmt.Fprintf(b, "ContentType: %s\n", this.contentType)
fmt.Fprintf(b, "User-Agent: %s\n", this.UserAgent())
fmt.Fprintf(b, "rb: %s\n", this.rb.String())
fmt.Fprintf(b, "wb: %s\n", this.wb.String())
//
b.WriteString("\n")
//
debug = b
}
}
defer func() {
// 发HTTP状态码
w.WriteHeader(this.statusCode)
// 写数据
if 0 < this.wb.Len() {
this.wb.WriteTo(w)
}
}()
if "" != this.location {
// 发HTTP状态码
this.statusCode = http.StatusFound
// 写location跳转路径
w.Header().Set("Location", this.location)
} else {
// 写Content-Type
if "" != this.contentType {
if "text/json" != this.contentType && strings.Contains(this.contentType, "/json") {
if strings.Contains(this.UserAgent(), "MSIE") {
this.contentType = "text/json"
}
}
//
switch this.contentType {
case "text/plain", "text/html", "text/css", "text/javascript", "application/x-javascript", "text/json", "application/json":
this.contentType = fmt.Sprintf("%s; charset=utf-8", this.contentType)
default:
}
//
w.Header().Set("Content-Type", this.contentType)
} else {
//
if 0 < this.wb.Len() {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
} else {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
}
}
// 写缓冲
if http.StatusBadRequest <= this.statusCode {
if s := http.StatusText(this.statusCode); "" != s {
// 缓冲复位
this.wb.Reset()
// 重写缓冲
this.wb.WriteString(s)
}
}
}
//
if nil != debug && 0 < debug.Len() {
return debug.String()
}
//
return ""
}
func NewHttpHandler(r *http.Request, flags ...bool) *httpHandler {
if nil != r {
if rb := bufferpool.Get(); nil != rb {
if wb := bufferpool.Get(); nil != wb {
if _r, ok := pool.Get().(*httpHandler); ok {
//
rb.Reset()
wb.Reset()
//
_r.Request = r
_r.body = nil
//
if 0 < len(flags) && flags[0] {
// 长度
if debugBufferLength := DebugBufferLength; 0 < debugBufferLength {
// 调试数据长度
if 1 > debugBufferLength {
debugBufferLength = 1
}
// 生成
if tr, err := rb.TeeReader(r.Body, int64(debugBufferLength*1024)); nil == err {
// 备份
_r.body = r.Body
// 替换
r.Body = tr
}
}
// 标记
atomic.StoreUint32(&_r.flags[flagDebug], flagDebugEnabled)
} else {
// 标记
atomic.StoreUint32(&_r.flags[flagDebug], flagDebugDisabled)
}
// 标记
atomic.StoreUint32(&_r.flags[flagOutput], flagOutputEnabled)
// 清空
_r.statusCode = http.StatusOK
_r.location = ""
_r.contentType = ""
_r.start = time.Now().UnixNano() / 1000
// 缓冲区
_r.rb = rb
_r.wb = wb
// json编码器
_r.jenc = nil
// 返回对象
return _r
}
// 释放
wb.Free()
}
// 释放
rb.Free()
}
}
return nil
}
func TemplateAddFunc(name string, fn interface{}) {
if "" != name && nil != fn {
funcs[name] = fn
}
}
|
package main
import (
"fmt"
)
type S1 struct{}
func (s *S1) M() string {
return "from S1.M"
}
type S2 struct {
*S1
}
func main() {
s := new(S2)
fmt.Println(s.M())
fmt.Println(s.S1.M())
}
|
package apis
import (
"math"
"net/url"
"strconv"
"github.com/ololko/simple-HTTP-server/pkg/events/models"
log "github.com/sirupsen/logrus"
)
func fillRequestStruck(u *url.URL) (models.RequestT, error) {
q := u.Query()
var to int64 = math.MaxInt32
var from int64 = math.MinInt32
var err error
if q.Get("from") != "" {
from, err = strconv.ParseInt(q.Get("from"), 10, 64)
if err != nil {
log.WithFields(log.Fields{
"method": "GET",
"bad_querry_argument": "from",
}).Error("Bad request")
return models.RequestT{}, err
}
}
if q.Get("to") != "" {
to, err = strconv.ParseInt(q.Get("to"), 10, 64)
if err != nil {
log.WithFields(log.Fields{
"method": "GET",
"bad_querry_argument": "to",
}).Error("Bad request")
return models.RequestT{}, err
}
}
request := models.RequestT{
From: from,
To: to,
Type: q.Get("type"),
}
return request, nil
}
|
// Inspired by go-bindata, but that seemed too heavyweight.
package main
import (
"flag"
"fmt"
"os"
"io"
"encoding/base64"
)
func main() {
flag.Parse()
target, err := os.OpenFile("data_" + flag.Arg(0) + ".go", os.O_WRONLY | os.O_TRUNC | os.O_CREATE, os.ModePerm)
if err != nil {
panic(err)
}
fmt.Fprintln(target, "package " + flag.Arg(1))
fmt.Fprintln(target, "// Generated code")
for x := 2; x < flag.NArg(); x++ {
name := flag.Arg(x)
file, err := os.Open("bindata/" + name + "." + flag.Arg(0))
if err != nil {
panic(err)
}
stat, err := file.Stat()
if err != nil {
panic(err)
}
data := make([]byte, stat.Size())
amount, err := io.ReadFull(file, data)
if err != nil || amount != len(data) {
panic(err)
}
file.Close()
fmt.Fprintln(target, "var " + name + "B64 = \"" + base64.StdEncoding.EncodeToString(data) + "\"")
}
target.Close()
}
|
/*
Copyright 2019 The Kubernetes 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 topologymanager
import (
"fmt"
"reflect"
"strings"
"testing"
"k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
"k8s.io/kubernetes/pkg/kubelet/lifecycle"
)
func NewTestBitMask(sockets ...int) bitmask.BitMask {
s, _ := bitmask.NewBitMask(sockets...)
return s
}
func TestNewManager(t *testing.T) {
tcases := []struct {
description string
policyName string
expectedPolicy string
expectedError error
}{
{
description: "Policy is set to best-effort",
policyName: "best-effort",
expectedPolicy: "best-effort",
},
{
description: "Policy is set to restricted",
policyName: "restricted",
expectedPolicy: "restricted",
},
{
description: "Policy is set to unknown",
policyName: "unknown",
expectedError: fmt.Errorf("unknown policy: \"unknown\""),
},
}
for _, tc := range tcases {
mngr, err := NewManager(nil, tc.policyName)
if tc.expectedError != nil {
if !strings.Contains(err.Error(), tc.expectedError.Error()) {
t.Errorf("Unexpected error message. Have: %s wants %s", err.Error(), tc.expectedError.Error())
}
} else {
rawMgr := mngr.(*manager)
if rawMgr.policy.Name() != tc.expectedPolicy {
t.Errorf("Unexpected policy name. Have: %q wants %q", rawMgr.policy.Name(), tc.expectedPolicy)
}
}
}
}
type mockHintProvider struct {
th map[string][]TopologyHint
//TODO: Add this field and add some tests to make sure things error out
//appropriately on allocation errors.
//allocateError error
}
func (m *mockHintProvider) GetTopologyHints(pod *v1.Pod, container *v1.Container) map[string][]TopologyHint {
return m.th
}
func (m *mockHintProvider) Allocate(pod *v1.Pod, container *v1.Container) error {
//return allocateError
return nil
}
func TestGetAffinity(t *testing.T) {
tcases := []struct {
name string
containerName string
podUID string
expected TopologyHint
}{
{
name: "case1",
containerName: "nginx",
podUID: "0aafa4c4-38e8-11e9-bcb1-a4bf01040474",
expected: TopologyHint{},
},
}
for _, tc := range tcases {
mngr := manager{}
actual := mngr.GetAffinity(tc.podUID, tc.containerName)
if !reflect.DeepEqual(actual, tc.expected) {
t.Errorf("Expected Affinity in result to be %v, got %v", tc.expected, actual)
}
}
}
func TestAccumulateProvidersHints(t *testing.T) {
tcases := []struct {
name string
hp []HintProvider
expected []map[string][]TopologyHint
}{
{
name: "TopologyHint not set",
hp: []HintProvider{},
expected: nil,
},
{
name: "HintProvider returns empty non-nil map[string][]TopologyHint",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{},
},
},
expected: []map[string][]TopologyHint{
{},
},
},
{
name: "HintProvider returns - nil map[string][]TopologyHint from provider",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": nil,
},
},
},
expected: []map[string][]TopologyHint{
{
"resource": nil,
},
},
},
{
name: "2 HintProviders with 1 resource returns hints",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource1": {TopologyHint{}},
},
},
&mockHintProvider{
map[string][]TopologyHint{
"resource2": {TopologyHint{}},
},
},
},
expected: []map[string][]TopologyHint{
{
"resource1": {TopologyHint{}},
},
{
"resource2": {TopologyHint{}},
},
},
},
{
name: "2 HintProviders 1 with 1 resource 1 with nil hints",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource1": {TopologyHint{}},
},
},
&mockHintProvider{nil},
},
expected: []map[string][]TopologyHint{
{
"resource1": {TopologyHint{}},
},
nil,
},
},
{
name: "2 HintProviders 1 with 1 resource 1 empty hints",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource1": {TopologyHint{}},
},
},
&mockHintProvider{
map[string][]TopologyHint{},
},
},
expected: []map[string][]TopologyHint{
{
"resource1": {TopologyHint{}},
},
{},
},
},
{
name: "HintProvider with 2 resources returns hints",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource1": {TopologyHint{}},
"resource2": {TopologyHint{}},
},
},
},
expected: []map[string][]TopologyHint{
{
"resource1": {TopologyHint{}},
"resource2": {TopologyHint{}},
},
},
},
}
for _, tc := range tcases {
mngr := manager{
hintProviders: tc.hp,
}
actual := mngr.accumulateProvidersHints(&v1.Pod{}, &v1.Container{})
if !reflect.DeepEqual(actual, tc.expected) {
t.Errorf("Test Case %s: Expected NUMANodeAffinity in result to be %v, got %v", tc.name, tc.expected, actual)
}
}
}
type mockPolicy struct {
nonePolicy
ph []map[string][]TopologyHint
}
func (p *mockPolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, bool) {
p.ph = providersHints
return TopologyHint{}, true
}
func TestCalculateAffinity(t *testing.T) {
tcases := []struct {
name string
hp []HintProvider
expected []map[string][]TopologyHint
}{
{
name: "No hint providers",
hp: []HintProvider{},
expected: ([]map[string][]TopologyHint)(nil),
},
{
name: "HintProvider returns empty non-nil map[string][]TopologyHint",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{},
},
},
expected: []map[string][]TopologyHint{
{},
},
},
{
name: "HintProvider returns -nil map[string][]TopologyHint from provider",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": nil,
},
},
},
expected: []map[string][]TopologyHint{
{
"resource": nil,
},
},
},
{
name: "Assorted HintProviders",
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource-1/A": {
{NUMANodeAffinity: NewTestBitMask(0), Preferred: true},
{NUMANodeAffinity: NewTestBitMask(0, 1), Preferred: false},
},
"resource-1/B": {
{NUMANodeAffinity: NewTestBitMask(1), Preferred: true},
{NUMANodeAffinity: NewTestBitMask(1, 2), Preferred: false},
},
},
},
&mockHintProvider{
map[string][]TopologyHint{
"resource-2/A": {
{NUMANodeAffinity: NewTestBitMask(2), Preferred: true},
{NUMANodeAffinity: NewTestBitMask(3, 4), Preferred: false},
},
"resource-2/B": {
{NUMANodeAffinity: NewTestBitMask(2), Preferred: true},
{NUMANodeAffinity: NewTestBitMask(3, 4), Preferred: false},
},
},
},
&mockHintProvider{
map[string][]TopologyHint{
"resource-3": nil,
},
},
},
expected: []map[string][]TopologyHint{
{
"resource-1/A": {
{NUMANodeAffinity: NewTestBitMask(0), Preferred: true},
{NUMANodeAffinity: NewTestBitMask(0, 1), Preferred: false},
},
"resource-1/B": {
{NUMANodeAffinity: NewTestBitMask(1), Preferred: true},
{NUMANodeAffinity: NewTestBitMask(1, 2), Preferred: false},
},
},
{
"resource-2/A": {
{NUMANodeAffinity: NewTestBitMask(2), Preferred: true},
{NUMANodeAffinity: NewTestBitMask(3, 4), Preferred: false},
},
"resource-2/B": {
{NUMANodeAffinity: NewTestBitMask(2), Preferred: true},
{NUMANodeAffinity: NewTestBitMask(3, 4), Preferred: false},
},
},
{
"resource-3": nil,
},
},
},
}
for _, tc := range tcases {
mngr := manager{}
mngr.policy = &mockPolicy{}
mngr.hintProviders = tc.hp
mngr.calculateAffinity(&v1.Pod{}, &v1.Container{})
actual := mngr.policy.(*mockPolicy).ph
if !reflect.DeepEqual(tc.expected, actual) {
t.Errorf("Test Case: %s", tc.name)
t.Errorf("Expected result to be %v, got %v", tc.expected, actual)
}
}
}
func TestAddContainer(t *testing.T) {
testCases := []struct {
name string
containerID string
podUID types.UID
}{
{
name: "Case1",
containerID: "nginx",
podUID: "0aafa4c4-38e8-11e9-bcb1-a4bf01040474",
},
{
name: "Case2",
containerID: "Busy_Box",
podUID: "b3ee37fc-39a5-11e9-bcb1-a4bf01040474",
},
}
mngr := manager{}
mngr.podMap = make(map[string]string)
for _, tc := range testCases {
pod := v1.Pod{}
pod.UID = tc.podUID
err := mngr.AddContainer(&pod, tc.containerID)
if err != nil {
t.Errorf("Expected error to be nil but got: %v", err)
}
if val, ok := mngr.podMap[tc.containerID]; ok {
if reflect.DeepEqual(val, pod.UID) {
t.Errorf("Error occurred")
}
} else {
t.Errorf("Error occurred, Pod not added to podMap")
}
}
}
func TestRemoveContainer(t *testing.T) {
testCases := []struct {
name string
containerID string
podUID types.UID
}{
{
name: "Case1",
containerID: "nginx",
podUID: "0aafa4c4-38e8-11e9-bcb1-a4bf01040474",
},
{
name: "Case2",
containerID: "Busy_Box",
podUID: "b3ee37fc-39a5-11e9-bcb1-a4bf01040474",
},
}
var len1, len2 int
mngr := manager{}
mngr.podMap = make(map[string]string)
for _, tc := range testCases {
mngr.podMap[tc.containerID] = string(tc.podUID)
len1 = len(mngr.podMap)
err := mngr.RemoveContainer(tc.containerID)
len2 = len(mngr.podMap)
if err != nil {
t.Errorf("Expected error to be nil but got: %v", err)
}
if len1-len2 != 1 {
t.Errorf("Remove Pod resulted in error")
}
}
}
func TestAddHintProvider(t *testing.T) {
var len1 int
tcases := []struct {
name string
hp []HintProvider
}{
{
name: "Add HintProvider",
hp: []HintProvider{
&mockHintProvider{},
},
},
}
mngr := manager{}
for _, tc := range tcases {
mngr.hintProviders = []HintProvider{}
len1 = len(mngr.hintProviders)
mngr.AddHintProvider(tc.hp[0])
}
len2 := len(mngr.hintProviders)
if len2-len1 != 1 {
t.Errorf("error")
}
}
func TestAdmit(t *testing.T) {
numaNodes := []int{0, 1}
tcases := []struct {
name string
result lifecycle.PodAdmitResult
qosClass v1.PodQOSClass
policy Policy
hp []HintProvider
expected bool
}{
{
name: "QOSClass set as BestEffort. None Policy. No Hints.",
qosClass: v1.PodQOSBestEffort,
policy: NewNonePolicy(),
hp: []HintProvider{},
expected: true,
},
{
name: "QOSClass set as Guaranteed. None Policy. No Hints.",
qosClass: v1.PodQOSGuaranteed,
policy: NewNonePolicy(),
hp: []HintProvider{},
expected: true,
},
{
name: "QOSClass set as BestEffort. single-numa-node Policy. No Hints.",
qosClass: v1.PodQOSBestEffort,
policy: NewRestrictedPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{},
},
expected: true,
},
{
name: "QOSClass set as BestEffort. Restricted Policy. No Hints.",
qosClass: v1.PodQOSBestEffort,
policy: NewRestrictedPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{},
},
expected: true,
},
{
name: "QOSClass set as Guaranteed. BestEffort Policy. Preferred Affinity.",
qosClass: v1.PodQOSGuaranteed,
policy: NewBestEffortPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: true,
},
{
name: "QOSClass set as Guaranteed. BestEffort Policy. More than one Preferred Affinity.",
qosClass: v1.PodQOSGuaranteed,
policy: NewBestEffortPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(1),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: true,
},
{
name: "QOSClass set as Burstable. BestEffort Policy. More than one Preferred Affinity.",
qosClass: v1.PodQOSBurstable,
policy: NewBestEffortPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(1),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: true,
},
{
name: "QOSClass set as Guaranteed. BestEffort Policy. No Preferred Affinity.",
qosClass: v1.PodQOSGuaranteed,
policy: NewBestEffortPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: true,
},
{
name: "QOSClass set as Guaranteed. Restricted Policy. Preferred Affinity.",
qosClass: v1.PodQOSGuaranteed,
policy: NewRestrictedPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: true,
},
{
name: "QOSClass set as Burstable. Restricted Policy. Preferred Affinity.",
qosClass: v1.PodQOSBurstable,
policy: NewRestrictedPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: true,
},
{
name: "QOSClass set as Guaranteed. Restricted Policy. More than one Preferred affinity.",
qosClass: v1.PodQOSGuaranteed,
policy: NewRestrictedPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(1),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: true,
},
{
name: "QOSClass set as Burstable. Restricted Policy. More than one Preferred affinity.",
qosClass: v1.PodQOSBurstable,
policy: NewRestrictedPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(1),
Preferred: true,
},
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: true,
},
{
name: "QOSClass set as Guaranteed. Restricted Policy. No Preferred affinity.",
qosClass: v1.PodQOSGuaranteed,
policy: NewRestrictedPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: false,
},
{
name: "QOSClass set as Burstable. Restricted Policy. No Preferred affinity.",
qosClass: v1.PodQOSBurstable,
policy: NewRestrictedPolicy(numaNodes),
hp: []HintProvider{
&mockHintProvider{
map[string][]TopologyHint{
"resource": {
{
NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false,
},
},
},
},
},
expected: false,
},
}
for _, tc := range tcases {
man := manager{
policy: tc.policy,
podTopologyHints: make(map[string]map[string]TopologyHint),
hintProviders: tc.hp,
}
pod := &v1.Pod{
Spec: v1.PodSpec{
Containers: []v1.Container{
{
Resources: v1.ResourceRequirements{},
},
},
},
Status: v1.PodStatus{
QOSClass: tc.qosClass,
},
}
podAttr := lifecycle.PodAdmitAttributes{
Pod: pod,
}
actual := man.Admit(&podAttr)
if actual.Admit != tc.expected {
t.Errorf("Error occurred, expected Admit in result to be %v got %v", tc.expected, actual.Admit)
}
}
}
|
package generator
import (
"bufio"
"fmt"
"io"
"math/rand"
"os"
"strconv"
"strings"
)
type City struct {
Name string
CountryCode string
Country string
Latitude float32
Longitude float32
Ip string
}
func ReadCitiesFromFile(fileName string) ([]City, error) {
var cities []City
file, err := os.Open(fileName)
if err != nil {
return nil, err
}
defer file.Close()
reader := bufio.NewReader(file)
for {
line, _, err := reader.ReadLine()
if err == io.EOF {
return cities, nil
} else if err != nil {
return nil, err
}
info := strings.Split(string(line), "\t")
lat, parseErr := strconv.ParseFloat(info[3], 32)
if parseErr != nil {
return nil, fmt.Errorf("parse error at %v", info[0])
}
lng, parseErr := strconv.ParseFloat(info[4], 32)
if parseErr != nil {
return nil, fmt.Errorf("parse error at %v", info[0])
}
ip := strings.Join([]string{
strconv.Itoa(rand.Intn(256)),
strconv.Itoa(rand.Intn(256)),
strconv.Itoa(rand.Intn(256)),
strconv.Itoa(rand.Intn(256)),
}, ".")
city := City{
Name: info[1],
CountryCode: info[1],
Country: info[2],
Latitude: float32(lat),
Longitude: float32(lng),
Ip: ip,
}
cities = append(cities, city)
}
}
|
package server
import (
"fmt"
"github.com/garyburd/redigo/redis"
"github.com/golang/glog"
"time"
)
type RedisConn struct {
host string
port int32
hp string
connTimeOut int32
sockTimeOut int32
database string
passwd string
ctx redis.Conn // is a interface
}
func (rc *RedisConn) HostPort() string {
return rc.hp
}
func NewRedisConn(h string,
pt int32,
ct int32,
st int32,
db string,
pd string) *RedisConn {
rc := &RedisConn{
host: h,
port: pt,
connTimeOut: ct,
sockTimeOut: st,
database: db,
passwd: pd,
}
rc.hp = h + fmt.Sprintf(":%d", pt)
rc.ctx = nil
return rc
}
func (rc *RedisConn) DisConnect() {
if rc.ctx != nil {
rc.ctx.Close()
rc.ctx = nil
}
}
func (rc *RedisConn) DoConnect() error {
var err error = nil
rc.DisConnect()
rc.ctx, err = redis.DialTimeout("tcp",
rc.hp,
time.Duration(rc.connTimeOut)*time.Millisecond,
time.Duration(rc.sockTimeOut)*time.Millisecond,
time.Duration(rc.sockTimeOut)*time.Millisecond)
if rc.ctx == nil || err != nil {
glog.Warningf("connect [%s] error %v", rc.hp, err)
return err
}
_, err = rc.ctx.Do("AUTH", rc.passwd)
if err != nil {
glog.Warningf("auth [%s] error %v", rc.hp, err)
rc.ctx.Close()
rc.ctx = nil
return err
}
_, err = rc.ctx.Do("SELECT", rc.database)
if err != nil {
glog.Warningf("select [%s][%s] error %v", rc.hp, rc.database, err)
rc.ctx.Close()
rc.ctx = nil
return err
}
return nil
}
func (rc *RedisConn) Do(cmd string, args ...interface{}) (interface{}, error) {
if rc.ctx == nil {
err := rc.DoConnect()
if err != nil {
return nil, err
}
}
return rc.ctx.Do(cmd, args...)
}
func (rc *RedisConn) SafeDo(cmd string, args ...interface{}) (interface{}, error) {
reply, err := rc.Do(cmd, args...)
if err == nil {
return reply, err
}
err = rc.DoConnect()
if err != nil {
return nil, err
}
return rc.Do(cmd, args...)
}
|
package main
import (
"golang.org/x/tour/pic"
)
func Pic(dx, dy int) [][]uint8 {
dySlice := make([][]uint8, dy)
for outerIndex := range dySlice {
dySlice[outerIndex] = make([]uint8, dx)
for innerIndex := range dySlice[outerIndex] {
dySlice[outerIndex][innerIndex] = uint8((innerIndex ^ outerIndex) * (innerIndex & outerIndex))
}
}
return dySlice
}
func main() {
pic.Show(Pic)
}
|
package service
import (
"server-monitor-admin/global"
"server-monitor-admin/model"
"server-monitor-admin/model/request"
"server-monitor-admin/utils"
)
func ListServerGroup(page *request.QueryServerGroup) {
var projects []model.SysServerGroup
db := global.DB.Limit(page.Limit).Offset(page.GetOffset()).Order("create_time desc")
if page.UserId != utils.SUPER_ADMIN_USER_ID {
db = db.Where("create_user_id=?", page.UserId)
}
if len(page.ProjectName) != 0 {
db = db.Where("project_name like ?", "%"+page.ProjectName+"%")
}
db.Where("del_flag=0").Find(&projects).Count(&page.Total)
page.List = projects
}
|
package oss
import (
"bytes"
"encoding/base64"
"errors"
"fmt"
"io"
"mime/multipart"
"net/textproto"
"os"
"path"
"strings"
)
// PostOption is the option type for configuration multipart.Writer
type PostOption func(*multipart.Writer) error
// PostObject posts an object to OSS in MIME multipart format
func (a *API) PostObject(bucket, object, filename, policy string, options ...PostOption) (res Header, _ error) {
buf := new(bytes.Buffer)
w := multipart.NewWriter(buf)
policy = base64.StdEncoding.EncodeToString([]byte(policy))
options = append(options, []PostOption{
postObjectName(object),
postAccessKeyID(a.accessKeyID),
postPolicy(policy),
postSignature(hmacSHA1([]byte(policy), []byte(a.accessKeySecret))),
postFile(filename),
}...)
for _, option := range options {
if err := option(w); err != nil {
return nil, err
}
}
w.Close()
return res, a.Do("POST", bucket, "", &res, []Option{ContentType(w.FormDataContentType()), HTTPBody(buf)}...)
}
func setMultipartBoundary(boundary string) PostOption {
return func(w *multipart.Writer) error {
return w.SetBoundary(boundary)
}
}
func postFile(filename string) PostOption {
return func(w *multipart.Writer) error {
file, err := os.Open(filename)
if err != nil {
return err
}
defer file.Close()
h := make(textproto.MIMEHeader)
h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="file"; filename="%s"`, escapeQuotes(path.Base(filename))))
writer, _ := w.CreatePart(h)
return safeCopy(writer, file)
}
}
func safeCopy(w io.Writer, r io.Reader) error {
if w == nil || r == nil {
return errors.New("fail to copy")
}
_, err := io.Copy(w, r)
return err
}
var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"")
func escapeQuotes(s string) string {
return quoteEscaper.Replace(s)
}
// postPolicy is a PostOption to set policy
func postPolicy(value string) PostOption {
return setMultipartField("policy", value)
}
// PostCacheControl is a PostOption to set Cache-Control
func PostCacheControl(value string) PostOption {
return setMultipartField("Cache-Control", value)
}
// PostContentType is a PostOption to set Content-Type
func PostContentType(value string) PostOption {
return setMultipartField("Content-Type", value)
}
// PostContentDisposition is a PostOption to set Content-Disposition
func PostContentDisposition(value string) PostOption {
return setMultipartField("Content-Disposition", value)
}
// PostContentEncoding is a PostOption to set Content-Encoding
func PostContentEncoding(value string) PostOption {
return setMultipartField("Content-Encoding", value)
}
// PostExpires is a PostOption to set Expires
func PostExpires(value string) PostOption {
return setMultipartField("Expires", value)
}
// PostSuccessActionRedirect is a PostOption to set success_action_redirect
func PostSuccessActionRedirect(value string) PostOption {
return setMultipartField("success_action_redirect", value)
}
// PostSuccessActionStatus is a PostOption to set success_action_status
func PostSuccessActionStatus(value string) PostOption {
return setMultipartField("success_action_status", value)
}
// PostMeta is a PostOption to set X-Oss-Meta-* headers
func PostMeta(key, value string) PostOption {
return setMultipartField("x-oss-meta-"+key, value)
}
// PostServerSideEncryption is a PostOption to set x-oss-server-side-encryption
func PostServerSideEncryption(value string) PostOption {
return setMultipartField("x-oss-server-side-encryption", value)
}
// PostObjectACL is a PostOption to set x-oss-object-acl
func PostObjectACL(value ACLType) PostOption {
return setMultipartField("x-oss-object-acl", string(value))
}
func postSignature(value string) PostOption {
return setMultipartField("Signature", value)
}
func postObjectName(value string) PostOption {
return setMultipartField("key", value)
}
func postAccessKeyID(value string) PostOption {
return setMultipartField("OSSAccessKeyId", value)
}
func setMultipartField(key, value string) PostOption {
return func(w *multipart.Writer) error {
return w.WriteField(key, value)
}
}
|
package main
import (
"fmt"
"github.com/dah8ra/ch7/eval713"
)
func main() {
expr, _ := eval713.Parse("1+2*3-4/8")
fmt.Println(expr)
env := eval713.Env{"x": 1, "y": 2}
expr.String(env)
}
|
// Copyright 2021 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// 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 server
import (
"context"
"path/filepath"
"github.com/pingcap/badger"
"github.com/pingcap/badger/options"
"github.com/pingcap/errors"
"github.com/pingcap/tidb/store/mockstore/unistore/config"
"github.com/pingcap/tidb/store/mockstore/unistore/lockstore"
"github.com/pingcap/tidb/store/mockstore/unistore/pd"
"github.com/pingcap/tidb/store/mockstore/unistore/tikv"
"github.com/pingcap/tidb/store/mockstore/unistore/tikv/mvcc"
)
const (
subPathRaft = "raft"
subPathKV = "kv"
)
// NewMock returns a new *tikv.Server, a new *tikv.MockRegionManager and a new *tikv.MockPD.
func NewMock(conf *config.Config, clusterID uint64) (*tikv.Server, *tikv.MockRegionManager, *tikv.MockPD, error) {
physical, logical := tikv.GetTS()
ts := uint64(physical)<<18 + uint64(logical)
safePoint := &tikv.SafePoint{}
db, err := createDB(subPathKV, safePoint, &conf.Engine)
if err != nil {
return nil, nil, nil, err
}
bundle := &mvcc.DBBundle{
DB: db,
LockStore: lockstore.NewMemStore(8 << 20),
StateTS: ts,
}
rm, err := tikv.NewMockRegionManager(bundle, clusterID, tikv.RegionOptions{
StoreAddr: conf.Server.StoreAddr,
PDAddr: conf.Server.PDAddr,
RegionSize: conf.Server.RegionSize,
})
if err != nil {
return nil, nil, nil, err
}
pdClient := tikv.NewMockPD(rm)
svr, err := setupStandAlongInnerServer(bundle, safePoint, rm, pdClient, conf)
if err != nil {
return nil, nil, nil, err
}
return svr, rm, pdClient, nil
}
// New returns a new *tikv.Server.
func New(conf *config.Config, pdClient pd.Client) (*tikv.Server, error) {
physical, logical, err := pdClient.GetTS(context.Background())
if err != nil {
return nil, err
}
ts := uint64(physical)<<18 + uint64(logical)
safePoint := &tikv.SafePoint{}
db, err := createDB(subPathKV, safePoint, &conf.Engine)
if err != nil {
return nil, err
}
bundle := &mvcc.DBBundle{
DB: db,
LockStore: lockstore.NewMemStore(8 << 20),
StateTS: ts,
}
if conf.Server.Raft {
return nil, errors.New("not support raftstore")
}
rm := tikv.NewStandAloneRegionManager(bundle, getRegionOptions(conf), pdClient)
return setupStandAlongInnerServer(bundle, safePoint, rm, pdClient, conf)
}
func getRegionOptions(conf *config.Config) tikv.RegionOptions {
return tikv.RegionOptions{
StoreAddr: conf.Server.StoreAddr,
PDAddr: conf.Server.PDAddr,
RegionSize: conf.Server.RegionSize,
}
}
func setupStandAlongInnerServer(bundle *mvcc.DBBundle, safePoint *tikv.SafePoint, rm tikv.RegionManager, pdClient pd.Client, conf *config.Config) (*tikv.Server, error) {
innerServer := tikv.NewStandAlongInnerServer(bundle)
innerServer.Setup(pdClient)
store := tikv.NewMVCCStore(conf, bundle, conf.Engine.DBPath, safePoint, tikv.NewDBWriter(bundle), pdClient)
store.DeadlockDetectSvr.ChangeRole(tikv.Leader)
if err := innerServer.Start(pdClient); err != nil {
return nil, err
}
store.StartDeadlockDetection(false)
return tikv.NewServer(rm, store, innerServer), nil
}
func createDB(subPath string, safePoint *tikv.SafePoint, conf *config.Engine) (*badger.DB, error) {
opts := badger.DefaultOptions
opts.NumCompactors = conf.NumCompactors
opts.ValueThreshold = conf.ValueThreshold
if subPath == subPathRaft {
// Do not need to write blob for raft engine because it will be deleted soon.
return nil, errors.New("not support " + subPathRaft)
}
opts.ManagedTxns = true
opts.ValueLogWriteOptions.WriteBufferSize = 4 * 1024 * 1024
opts.Dir = filepath.Join(conf.DBPath, subPath)
opts.ValueDir = opts.Dir
opts.ValueLogFileSize = conf.VlogFileSize
opts.ValueLogMaxNumFiles = 3
opts.MaxMemTableSize = conf.MaxMemTableSize
opts.TableBuilderOptions.MaxTableSize = conf.MaxTableSize
opts.NumMemtables = conf.NumMemTables
opts.NumLevelZeroTables = conf.NumL0Tables
opts.NumLevelZeroTablesStall = conf.NumL0TablesStall
opts.LevelOneSize = conf.L1Size
opts.SyncWrites = conf.SyncWrite
compressionPerLevel := make([]options.CompressionType, len(conf.Compression))
for i := range opts.TableBuilderOptions.CompressionPerLevel {
compressionPerLevel[i] = config.ParseCompression(conf.Compression[i])
}
opts.TableBuilderOptions.CompressionPerLevel = compressionPerLevel
opts.MaxBlockCacheSize = conf.BlockCacheSize
opts.MaxIndexCacheSize = conf.IndexCacheSize
opts.TableBuilderOptions.SuRFStartLevel = conf.SurfStartLevel
if safePoint != nil {
opts.CompactionFilterFactory = safePoint.CreateCompactionFilter
}
opts.CompactL0WhenClose = conf.CompactL0WhenClose
opts.VolatileMode = conf.VolatileMode
return badger.Open(opts)
}
|
package discord
import (
"fmt"
"math"
"math/rand"
"github.com/bwmarrin/discordgo"
)
func (b *Bot) specials(s *discordgo.Session, m *discordgo.MessageCreate) {
if m.Author.ID == s.State.User.ID || m.Author.Bot {
return
}
if b.startsWith(m, "rob") {
b.checkuser(m)
if !(len(m.Mentions) > 0) {
s.ChannelMessageSend(m.ChannelID, "You need to mention the person you are going to rob!")
return
}
b.checkuserwithid(m, m.Mentions[0].ID)
user1, suc := b.getuser(m, m.Author.ID)
if !suc {
return
}
ups, exists := user1.Properties["rob"]
if !exists {
s.ChannelMessageSend(m.ChannelID, "You need property `rob` to Rob people!")
return
}
user2, suc := b.getuser(m, m.Mentions[0].ID)
if !suc {
return
}
var num int
_, err := fmt.Sscanf(m.Content, "rob %d", &num)
if b.handle(err, m) {
return
}
num = b.abs(num)
if user2.Wallet < num {
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("User <@%s> doesn't even have %d coins!", m.Mentions[0].ID, num))
return
}
if user1.Wallet < num {
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("If you are going to rob someone of %d coins, you need to have that many coins in case you get caught.", num))
return
}
if (num / 10) > 0 {
num -= rand.Intn(num / 10) // loss
}
// backfiring
backNum := ups - 2
randChance := int(math.Pow(float64(ups), 1.5))
if randChance != 0 {
backNum += rand.Intn(randChance)
}
if backNum < 0 {
user1.Wallet -= num
user2.Wallet += num
b.updateuser(m, user1)
b.updateuser(m, user2)
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("Oh no! You got caught and had to give %d coins to the person you were stealing from! Try upgrading property `rob` to reduce the chances of backfiring!", num))
return
}
user1.Wallet += num
user2.Wallet -= num
b.updateuser(m, user1)
b.updateuser(m, user2)
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("Everything went perfectly and you just stole %d coins!", num))
return
}
}
|
package api
import (
"io/ioutil"
"net/http"
"net/http/httptest"
"os"
"testing"
"time"
"github.com/jinzhu/gorm"
)
func TestCheckSchedules(t *testing.T) {
// create dummy db
f, _ := ioutil.TempFile("", "")
db, err := gorm.Open("sqlite3", f.Name())
defer os.Remove(f.Name())
defer db.Close()
if err != nil {
t.Fatal("Error initializing test sqlite db")
}
t.Run("client success", func(t *testing.T) {
// create web endpoint
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`OK`))
}))
// Close the server when test finishes
defer server.Close()
httpClient := HTTPClient{
client: server.Client(),
url: server.URL,
}
// initialize routes
routes := NewRoutes(db, []byte{}, &httpClient)
routes.MigrateDB()
oneMinuteAgo := time.Now().Add(-1 * time.Minute)
oneMinuteInFuture := time.Now().Add(time.Minute)
routes.db.Create(&Schedule{
Time: oneMinuteAgo,
Status: "PENDING",
Source: "jimbobjoe",
})
routes.db.Create(&Schedule{
Time: oneMinuteInFuture,
Status: "PENDING",
Source: "jimbobjoe",
})
routes.CheckSchedules()
sentSchedule := Schedule{}
routes.db.Where("status = ?", "SENT").First(&sentSchedule)
if sentSchedule.ID == 0 {
t.Error("Did not set schedule status to sent")
}
pendingSchedule := Schedule{}
routes.db.Where("status = ?", "PENDING").First(&pendingSchedule)
if pendingSchedule.ID == 0 {
t.Error("Incorrectly affected pending schedule")
}
})
t.Run("client errors", func(t *testing.T) {
// create fake web server
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(401)
}))
// Close the server when test finishes
defer server.Close()
httpClient := HTTPClient{
client: server.Client(),
url: server.URL,
}
// initialize routes
routes := NewRoutes(db, []byte{}, &httpClient)
routes.MigrateDB()
oneMinuteAgo := time.Now().Add(-1 * time.Minute)
routes.db.Create(&Schedule{
Time: oneMinuteAgo,
Status: "PENDING",
Source: "jimbobjoe",
})
routes.CheckSchedules()
pendingSchedule := Schedule{}
routes.db.Where("status = ?", "ERROR").First(&pendingSchedule)
if pendingSchedule.ID == 0 {
t.Error("Did not mark the schedule as error")
}
})
}
func TestExecuteSchedule(t *testing.T) {
executed := false
// create fake web endpoint
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
executed = true
w.Write([]byte("ok"))
}))
defer server.Close()
httpClient := HTTPClient{
client: server.Client(),
url: server.URL,
}
httpClient.executeSchedule()
if !executed {
t.Error("HTTP Endpoint not executed")
}
}
|
package util
// Abs returns the absolute value of x.
func Abs(x int) int {
if x < 0 {
return -x
}
return x
}
func TowardZero(num int) int {
if num == 0 {
return 0
} else {
if num < 0 {
return num + 1
} else {
return num - 1
}
}
}
func Max(a int, b int) int {
if a > b {
return a
} else {
return b
}
}
|
package main
import (
"fmt"
"math/rand"
"net/http"
"time"
"github.com/ajvb/kala/client"
"github.com/ajvb/kala/job"
)
// Manager is the basic unit to represent consumer to maintain their own worker
type Manager struct {
ID string
Name string
Workers []Worker
}
// Worker represents the base simulation unit with efficiency
type Worker struct {
Manager Manager
Efficienct int
Name string
CurrentJobID string
}
func main() {
// TODO: get the schedudler server url from environment variable
c := client.New("http://127.0.0.1:8000")
// TODO: maintain a list of resources
// TODO: create a list of workers each with different efficiency
http.HandleFunc("/job", jobHandler(c))
http.HandleFunc("/hello", helloHandler)
http.ListenAndServe(":8080", nil)
}
func jobHandler(c *client.KalaClient) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// TODO: parse the callback URL
url := "127.0.0.1:8080/hello"
name := "test_job"
createJob(c, url, name)
})
}
func helloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Println("Hello job simulation server")
r.Println("Hello job simulation server")
}
func createJob(c *client.KalaClient, url, name string) {
// construct the current time string
delay := rand.Int31n(60)
t := time.Now().
Add(time.Duration(delay) * time.Second).
Format("2006-01-02T15:04:05-07:00")
schedule := fmt.Sprintf("R2/%s/PT1S", t)
body := &job.Job{
Schedule: schedule,
Name: name,
Command: "curl " + url,
}
id, err := c.CreateJob(body)
if err != nil {
panic(err)
}
fmt.Println(id)
}
|
package main
import (
"bitbucket.org/kyrra/sandbox/auth"
"flag"
"fmt"
)
func main() {
listen := flag.String("listen", ":8080", "Hostname and address to listen on")
source := flag.String("datasource", "users.json", "Filename to load JSON user data from")
flag.Parse()
err := auth.Serve(*listen, *source)
if err != nil {
fmt.Println("error starting auth server: ", err)
}
}
|
//go:generate go run gen/uikit.go
//go:generate go fmt
package uikit
|
package list
import "errors"
var (
outRangeError = errors.New("out of range")
)
type LinkList struct {
headNode *Node
len int
}
func (l *LinkList) IsEmpty() bool {
return l.len == 0
}
func (l *LinkList) Length() int {
return l.len
}
func (l *LinkList) GetHeadNode() *Node {
return l.headNode
}
// 从头部增加
func (l *LinkList) Add(data interface{}) {
node := &Node{Data:data}
node.Next = l.headNode
l.headNode = node
l.len += 1
}
// 从尾部增加
func (l *LinkList) Append(data interface{}) {
node := &Node{Data:data}
if l.IsEmpty() {
l.headNode = node
} else {
cur := l.headNode
for cur.Next != nil {
cur = cur.Next
}
cur.Next = node
}
l.len += 1
}
func (l *LinkList) Insert(index int, data interface{}) {
if index <= 0{
l.Add(data)
} else if index >= l.Length() {
l.Append(data)
} else {
node := &Node{Data:data}
cur := l.headNode
for i := 0; i < index - 1; i ++ {
cur = cur.Next
}
node.Next = cur.Next
cur.Next = node
l.len += 1
}
}
func (l *LinkList)Find(data interface{}) *Node {
cur := l.headNode
for cur != nil {
if cur.Data == data {
return cur
}
cur = cur.Next
}
return nil
}
func (l *LinkList)GetNodeAtIndex(index int) (node *Node, error error) {
if index < 0 || index >= l.Length() {
return nil, outRangeError
} else {
cur := l.headNode
for i := 0; i < index; i ++ {
cur = cur.Next
}
return cur, nil
}
}
func (l *LinkList)Remove(data interface{}) {
if l.IsEmpty() {
return
}
if l.headNode.Data == data {
l.headNode = l.headNode.Next
l.len -= 1
}
for cur := l.headNode; cur.Next != nil; cur = cur.Next {
if cur.Next.Data == data {
cur.Next = cur.Next.Next
l.len -= 1
return
}
}
}
func (l *LinkList) RemoveAtIndex(index int) (node *Node, error error) {
if index < 0 || index >= l.Length() {
return nil, outRangeError
} else if index == 0 {
node = l.headNode
l.headNode = l.headNode.Next
} else {
cur := l.headNode
for i := 1; i < index; i ++ {
cur = cur.Next
}
node = cur.Next
cur.Next = cur.Next.Next
}
l.len -= 1
return
}
func (l *LinkList) Contain(data interface{}) bool {
return l.Find(data) != nil
}
|
// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
// Code generated from the elasticsearch-specification DO NOT EDIT.
// https://github.com/elastic/elasticsearch-specification/tree/33e8a1c9cad22a5946ac735c4fba31af2da2cec2
package types
import (
"bytes"
"encoding/json"
"errors"
"io"
"strconv"
)
// NodeOperatingSystemInfo type.
//
// https://github.com/elastic/elasticsearch-specification/blob/33e8a1c9cad22a5946ac735c4fba31af2da2cec2/specification/nodes/info/types.ts#L367-L384
type NodeOperatingSystemInfo struct {
// AllocatedProcessors The number of processors actually used to calculate thread pool size. This
// number can be set with the node.processors setting of a node and defaults to
// the number of processors reported by the OS.
AllocatedProcessors *int `json:"allocated_processors,omitempty"`
// Arch Name of the JVM architecture (ex: amd64, x86)
Arch string `json:"arch"`
// AvailableProcessors Number of processors available to the Java virtual machine
AvailableProcessors int `json:"available_processors"`
Cpu *NodeInfoOSCPU `json:"cpu,omitempty"`
Mem *NodeInfoMemory `json:"mem,omitempty"`
// Name Name of the operating system (ex: Linux, Windows, Mac OS X)
Name string `json:"name"`
PrettyName string `json:"pretty_name"`
// RefreshIntervalInMillis Refresh interval for the OS statistics
RefreshIntervalInMillis int64 `json:"refresh_interval_in_millis"`
Swap *NodeInfoMemory `json:"swap,omitempty"`
// Version Version of the operating system
Version string `json:"version"`
}
func (s *NodeOperatingSystemInfo) UnmarshalJSON(data []byte) error {
dec := json.NewDecoder(bytes.NewReader(data))
for {
t, err := dec.Token()
if err != nil {
if errors.Is(err, io.EOF) {
break
}
return err
}
switch t {
case "allocated_processors":
var tmp interface{}
dec.Decode(&tmp)
switch v := tmp.(type) {
case string:
value, err := strconv.Atoi(v)
if err != nil {
return err
}
s.AllocatedProcessors = &value
case float64:
f := int(v)
s.AllocatedProcessors = &f
}
case "arch":
var tmp json.RawMessage
if err := dec.Decode(&tmp); err != nil {
return err
}
o := string(tmp[:])
o, err = strconv.Unquote(o)
if err != nil {
o = string(tmp[:])
}
s.Arch = o
case "available_processors":
var tmp interface{}
dec.Decode(&tmp)
switch v := tmp.(type) {
case string:
value, err := strconv.Atoi(v)
if err != nil {
return err
}
s.AvailableProcessors = value
case float64:
f := int(v)
s.AvailableProcessors = f
}
case "cpu":
if err := dec.Decode(&s.Cpu); err != nil {
return err
}
case "mem":
if err := dec.Decode(&s.Mem); err != nil {
return err
}
case "name":
if err := dec.Decode(&s.Name); err != nil {
return err
}
case "pretty_name":
if err := dec.Decode(&s.PrettyName); err != nil {
return err
}
case "refresh_interval_in_millis":
if err := dec.Decode(&s.RefreshIntervalInMillis); err != nil {
return err
}
case "swap":
if err := dec.Decode(&s.Swap); err != nil {
return err
}
case "version":
if err := dec.Decode(&s.Version); err != nil {
return err
}
}
}
return nil
}
// NewNodeOperatingSystemInfo returns a NodeOperatingSystemInfo.
func NewNodeOperatingSystemInfo() *NodeOperatingSystemInfo {
r := &NodeOperatingSystemInfo{}
return r
}
|
// Licensed to SolID under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. SolID licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package jwsreq
import (
"context"
"encoding/json"
"fmt"
"google.golang.org/protobuf/encoding/protojson"
corev1 "zntr.io/solid/api/gen/go/oidc/core/v1"
"zntr.io/solid/pkg/sdk/jwt"
)
// -----------------------------------------------------------------------------
// JWTAuthorizationEncoder returns an authorization request encoder instance.
func JWTAuthorizationEncoder(signer jwt.Signer) AuthorizationEncoder {
return &jwtEncoder{
signer: signer,
}
}
type jwtEncoder struct {
signer jwt.Signer
}
func (enc *jwtEncoder) Encode(ctx context.Context, ar *corev1.AuthorizationRequest) (string, error) {
// Check arguments
if ar == nil {
return "", fmt.Errorf("unable to encode nil request")
}
// Encode ar as json
jsonString, err := protojson.MarshalOptions{
UseProtoNames: true,
EmitUnpopulated: false,
}.Marshal(ar)
if err != nil {
return "", fmt.Errorf("unable to prepare request: %w", err)
}
// Decode using json
var claims map[string]interface{}
if err = json.Unmarshal(jsonString, &claims); err != nil {
return "", fmt.Errorf("unable to serialize request payload: %w", err)
}
// Sign request
req, err := enc.signer.Sign(claims)
if err != nil {
return "", fmt.Errorf("unable to sign request: %w", err)
}
// No error
return req, nil
}
|
package common
import (
"fmt"
)
// APIError define API error when response status is 4xx or 5xx
type APIError struct {
Code int64 `json:"code"`
Message string `json:"msg"`
}
// Error return error code and message
func (e APIError) Error() string {
return fmt.Sprintf("<APIError> code=%d, msg=%s", e.Code, e.Message)
}
// IsAPIError check if e is an API error
func IsAPIError(e error) bool {
_, ok := e.(*APIError)
return ok
}
|
package main
import (
"fmt"
"os"
)
func init() {
os.Args = append(os.Args, "-local", "u=admin", "--help")
}
func main() {
cmd := len(os.Args[0])
argCount := len(os.Args[1:])
fmt.Printf("Program Name: %s\n", cmd)
fmt.Printf("Total Arguments: %d\n", argCount)
for i, a := range os.Args[1:] {
fmt.Printf("Argument %d is %s\n", i+1, a)
}
}
|
package main
import (
"encoding/json"
"fmt"
)
/*
@Time : 2020/6/26 3:17 下午
@Author : audiRS7
@File : 2使用map转json
@Software: GoLand
*/
//2、使用map[string]interface{}描述于谦并转json
func main() {
dataMap := make(map[string]interface{})
dataMap["name"] = "于谦"
dataMap["age"] = 50
dataMap["gender"] = "male"
dataMap["hobby"] = []string{"抽烟", "喝酒", "烫头"}
bytes, err := json.Marshal(dataMap)
if err != nil {
fmt.Println("解析失败")
return
}
fmt.Println(string(bytes))
}
|
package types
// UnemploymentClaims holds the data for unemployment claims based on OAED.
type UnemploymentClaims struct {
Unemployed int `json:"unemployed" fake:"{number:5000,10000}"`
Benefits int `json:"benefits" fake:"{number:1000,5000}"`
AsOfDate string `json:"asofdate" fake:"{year}-{month}-{day}" format:"2006-01-02"`
}
// ElectorsByAge holds the data for electors by age.
type ElectorsByAge struct {
Year int `json:"year" fake:"{year}"`
AgeGroup string `json:"age_group" fake:"{randomstring:[18-23,24-29,30-35,36-41]}"`
Count int `json:"count" fake:"{number:10000,100000}"`
ElectionType string `json:"election_type" fake:"{randomstring:[βουλευτικές,τοπικής αυτοδιοίκηςη]}"`
ElectoralDistrict string `json:"electoral_district" fake:"{randomstring:[ΑΙΤΩΛ/ΝΙΑΣ,ΑΙΤΩΛ/ΝΙΑΣ,ΑΡΚΑΔΙΑΣ,ΑΡΤΗΣ]}"`
}
// ElectorsByRegionAndGender holds the data for electors by region and gender.
type ElectorsByRegionAndGender struct {
Year int `json:"year" fake:"{year}"`
VotersMale int `json:"voters_male" fake:"{number:10000,100000}"`
VotersFemale int `json:"voters_female" fake:"{number:10000,100000}"`
ElectionType string `json:"election_type" fake:"{randomstring:[βουλευτικές,τοπικής αυτοδιοίκηςη]}"`
ElectoralDistrict string `json:"electoral_district" fake:"{randomstring:[ΑΙΤΩΛ/ΝΙΑΣ,ΑΡΚΑΔΙΑΣ,ΑΡΤΗΣ]}"`
Municipality string `json:"municipality" fake:"{randomstring:[,ΔΕΛΤΑ,ΟΡΕΣΤΙΔΟΣ,ΠΑΤΡΕΩΝ]}"`
}
|
/*
Copyright 2018 The Kubernetes 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 kunstruct
import (
"testing"
)
func TestGetFieldValue(t *testing.T) {
factory := NewKunstructuredFactoryImpl()
kunstructured := factory.FromMap(map[string]interface{}{
"Kind": "Service",
"metadata": map[string]interface{}{
"labels": map[string]string{
"app": "application-name",
},
"name": "service-name",
},
"spec": map[string]interface{}{
"ports": map[string]interface{}{
"port": "80",
},
},
"this": map[string]interface{}{
"is": map[string]interface{}{
"aNumber": 1000,
"aNilValue": nil,
"anEmptyMap": map[string]interface{}{},
"unrecognizable": testing.InternalExample{
Name: "fooBar",
},
},
},
})
tests := []struct {
name string
pathToField string
expectedValue string
errorExpected bool
errorMsg string
}{
{
name: "oneField",
pathToField: "Kind",
expectedValue: "Service",
errorExpected: false,
},
{
name: "twoFields",
pathToField: "metadata.name",
expectedValue: "service-name",
errorExpected: false,
},
{
name: "threeFields",
pathToField: "spec.ports.port",
expectedValue: "80",
errorExpected: false,
},
{
name: "empty",
pathToField: "",
errorExpected: true,
errorMsg: "no field named ''",
},
{
name: "emptyDotEmpty",
pathToField: ".",
errorExpected: true,
errorMsg: "no field named '.'",
},
{
name: "twoFieldsOneMissing",
pathToField: "metadata.banana",
errorExpected: true,
errorMsg: "no field named 'metadata.banana'",
},
{
name: "deeperMissingField",
pathToField: "this.is.aDeep.field.that.does.not.exist",
errorExpected: true,
errorMsg: "no field named 'this.is.aDeep.field.that.does.not.exist'",
},
{
name: "emptyMap",
pathToField: "this.is.anEmptyMap",
errorExpected: true,
errorMsg: ".this.is.anEmptyMap accessor error: map[] is of the type map[string]interface {}, expected string",
},
{
name: "numberAsValue",
pathToField: "this.is.aNumber",
errorExpected: true,
errorMsg: ".this.is.aNumber accessor error: 1000 is of the type int, expected string",
},
{
name: "nilAsValue",
pathToField: "this.is.aNilValue",
errorExpected: true,
errorMsg: ".this.is.aNilValue accessor error: <nil> is of the type <nil>, expected string",
},
{
name: "unrecognizable",
pathToField: "this.is.unrecognizable.Name",
errorExpected: true,
errorMsg: ".this.is.unrecognizable.Name accessor error: {fooBar <nil> false} is of the type testing.InternalExample, expected map[string]interface{}",
},
}
for _, test := range tests {
s, err := kunstructured.GetFieldValue(test.pathToField)
if test.errorExpected {
if err == nil {
t.Fatalf("%q; path %q - should return error, but no error returned",
test.name, test.pathToField)
}
if test.errorMsg != err.Error() {
t.Fatalf("%q; path %q - expected error: \"%s\", got error: \"%v\"",
test.name, test.pathToField, test.errorMsg, err.Error())
}
continue
}
if err != nil {
t.Fatalf("%q; path %q - unexpected error %v",
test.name, test.pathToField, err)
}
if test.expectedValue != s {
t.Fatalf("%q; Got: %s expected: %s",
test.name, s, test.expectedValue)
}
}
}
|
package repository_test
import (
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/assert"
"github.com/indrasaputra/aptx/internal/repository"
mock_repository "github.com/indrasaputra/aptx/test/mock/repository"
)
type HealthCheckerExecutor struct {
checker *repository.HealthChecker
deps []*mock_repository.MockHealthCheckerRepository
}
func TestNewHealthChecker(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
t.Run("successfully create an instance of HealthChecker", func(t *testing.T) {
exec := createHealthCheckerExecutor(ctrl)
assert.NotNil(t, exec.checker)
})
}
func TestHealthChecker_IsAlive(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
t.Run("there is broken dependency", func(t *testing.T) {
exec := createHealthCheckerExecutor(ctrl)
exec.deps[0].EXPECT().IsAlive(testContext).Return(true)
exec.deps[1].EXPECT().IsAlive(testContext).Return(false)
res := exec.checker.IsAlive(testContext)
assert.False(t, res)
})
t.Run("all dependencies are good", func(t *testing.T) {
exec := createHealthCheckerExecutor(ctrl)
exec.deps[0].EXPECT().IsAlive(testContext).Return(true)
exec.deps[1].EXPECT().IsAlive(testContext).Return(true)
res := exec.checker.IsAlive(testContext)
assert.True(t, res)
})
}
func createHealthCheckerExecutor(ctrl *gomock.Controller) *HealthCheckerExecutor {
d1 := mock_repository.NewMockHealthCheckerRepository(ctrl)
d2 := mock_repository.NewMockHealthCheckerRepository(ctrl)
c := repository.NewHealthChecker(d1, d2)
return &HealthCheckerExecutor{
checker: c,
deps: []*mock_repository.MockHealthCheckerRepository{d1, d2},
}
}
|
/*
* Copyright @ 2020 - present Blackvisor Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package storage
import (
"encoding/base64"
"encoding/json"
"errors"
"log"
"reflect"
"time"
)
type GenericStorage struct {
Credentials map[string]string
StorageType string
}
func (gs *GenericStorage) Init() error {
storage, err := CreateStorage(gs.Credentials, gs.StorageType, true)
if err != nil {
return err
}
defer storage.Destroy()
return storage.Init()
}
func (gs *GenericStorage) GetKeys(table string, pattern string) ([]string, error) {
err := CheckTableName(table)
if err != nil {
return nil, err
}
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return nil, err
}
defer storage.Destroy()
return storage.GetKeys(table, pattern)
}
func (gs *GenericStorage) SetKey(table string, key string, value string, expiration time.Duration) error {
err := CheckTableName(table)
if err != nil {
return err
}
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return err
}
defer storage.Destroy()
return storage.SetKey(table, key, value, expiration)
}
func (gs *GenericStorage) GetFullKey(key string) (string, error) {
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return "", err
}
defer storage.Destroy()
return storage.GetFullKey(key)
}
func (gs *GenericStorage) GetKey(table string, key string) (string, error) {
err := CheckTableName(table)
if err != nil {
return "", err
}
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return "", err
}
defer storage.Destroy()
return storage.GetKey(table, key)
}
func (gs *GenericStorage) DelKey(table string, key string) (int64, error) {
err := CheckTableName(table)
if err != nil {
return 0, err
}
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return 0, err
}
defer storage.Destroy()
return storage.DelKey(table, key)
}
func (gs *GenericStorage) AddToMap(table string, key string, objectKey string, object interface{}) error {
err := CheckTableName(table)
if err != nil {
return err
}
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return err
}
defer storage.Destroy()
json, err := json.Marshal(object)
if err != nil {
log.Println("Can not json encode")
return err
}
// Encode
encodedString := base64.StdEncoding.EncodeToString(json)
return storage.AddToMap(table, key, objectKey, encodedString)
}
func (gs *GenericStorage) DelFromMap(table string, key string, objectKey string) error {
err := CheckTableName(table)
if err != nil {
return err
}
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return err
}
defer storage.Destroy()
return storage.DelFromMap(table, key, objectKey)
}
func (gs *GenericStorage) GetFromMap(table string, key string, objectKey string, reference interface{}) error {
err := CheckTableName(table)
if err != nil {
return err
}
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return err
}
defer storage.Destroy()
value, err := storage.GetFromMap(table, key, objectKey)
if err != nil {
return err
}
bytes, err := base64.StdEncoding.DecodeString(value)
if err != nil {
return err
}
err = json.Unmarshal(bytes, &reference)
if err != nil {
return err
}
return nil
}
func (gs *GenericStorage) GetMap(table string, key string, reference interface{}) error {
err := CheckTableName(table)
if err != nil {
return err
}
storage, err := CreateStorage(gs.Credentials, gs.StorageType, false)
if err != nil {
return err
}
defer storage.Destroy()
data, err := storage.GetMap(table, key)
if err != nil {
return err
}
if reference == nil {
return errors.New("reference is null")
}
paramType := reflect.TypeOf(reference)
if paramType.Kind() != reflect.Ptr ||
(paramType.Elem().Kind() != reflect.Map || paramType.Elem().Key().Kind() != reflect.String) ||
paramType.Elem().Elem().Kind() != reflect.Ptr {
return errors.New("fill slice: parameter is not in format *map[string]*interface{}")
}
containerType := paramType.Elem()
messageType := containerType.Elem()
elementType := messageType.Elem()
paramValue := reflect.ValueOf(reference)
containerValue := paramValue.Elem()
if containerValue.IsNil() {
containerValue.Set(reflect.MakeMapWithSize(reflect.MapOf(containerType.Key(), messageType), len(data)))
}
for key, element := range data {
messageValue := reflect.New(elementType)
bytes, err := base64.StdEncoding.DecodeString(element)
if err != nil {
return err
}
err = json.Unmarshal(bytes, messageValue.Interface())
if err != nil {
return err
}
keyValue := reflect.ValueOf(key)
containerValue.SetMapIndex(keyValue, messageValue)
}
return nil
}
|
package euler
import "testing"
func TestQuestion2(t *testing.T) {
v := Question2()
if v != 4613732 {
t.Error(" Expected 4613732, got ", v)
}
}
|
package main
import (
"fmt"
"go_solidity/erc20"
"go_solidity/solidity"
"github.com/ethereum/go-ethereum/common"
)
var (
key string = `{"address":"e1975b35b3db24671cef3d7527797ab09ada0f95","crypto":{"cipher":"aes-128-ctr","ciphertext":"7c7c2b398cb7426238772cd3242bb6109339cca2c43616a5be9001f13cebc29c","cipherparams":{"iv":"8b2e982b21fc25a7cdc514e31f0b7e3c"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"60869b454865c84324322e29b33784561db1038c2bf31b9a857701567b88936f"},"mac":"1d4674b52815c9e14ebdbdba14a696050491d87dd342cd0e79d047e181220237"},"id":"b85ff6f8-fee8-4fba-a3d2-a832b15488d0","version":3}`
rpc string = "http://eosqukuai01.chinacloudapp.cn:8545"
contractAddress common.Address = common.HexToAddress("0xb8137ffe602b038388abac4eebc94a4331cc57df")
)
func main() {
session, err := solidity.NewContractSession(rpc, contractAddress, key, "11235813")
if err != nil {
fmt.Printf("solidity.NewContractSession : %s\n", err.Error())
return
}
// vote.Test(session, contractAddress)
//erc20
contract, err := erc20.NewErc20(address, session.Client)
if err != nil {
fmt.Printf("vote.Test :%s\n", err.Error())
return
}
//func (_Erc20 *Erc20Session) Grant(_to common.Address, _value *big.Int, _duration *big.Int, _periods *big.Int) (*types.Transaction, error) {
tx, err := contract.Grant()
if err != nil {
fmt.Printf("Deposit: %v", err)
return
}
ctx := context.Background()
fmt.Printf("[%s]Deposit tx.Size=%f WaitMined begin...\n", NowString(), float64(tx.Size()))
_, err = bind.WaitMined(ctx, session.Client, tx)
if err != nil {
fmt.Printf("Deposit :%v\n", err)
return
}
session.Opts.Value = big.NewInt(0)
fmt.Printf("[%s]Deposit WaitMined end...\n", NowString())
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.