Golang Panic示例

说明

golang panic示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: log

示例#1
文件: main.go 项目: proudlygeek/goscii

func upload(res http.ResponseWriter, req *http.Request) {
	defer logException(res, req)

	if req.Method == "POST" {
		file, _, err := req.FormFile("pic")

		if err != nil {
			log.Panic(err)
		}
		defer file.Close()

		wr := &manager.MongoWriter{}
		image, err := asciiEncoder.DecodeImage(file)
		if err != nil {
			log.Panic(err)
		}

		err = asciiEncoder.Asciify(image, wr)
		if err != nil {
			log.Panic(err)
		}

		uri := mongoArtManager.Save(wr)
		http.Redirect(res, req, "/art/"+uri, 302)
	}
}

示例#2
文件: secp256.go 项目: JmAbuDabi/skycoin

//generate signature in repeatable way
func SignDeterministic(msg []byte, seckey []byte, nonce_seed []byte) []byte {
	nonce := SumSHA256(nonce_seed) //deterministicly generate nonce

	var sig []byte = make([]byte, 65)
	var recid C.int

	var msg_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&msg[0]))
	var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0]))
	var nonce_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&nonce[0]))
	var sig_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&sig[0]))

	if C.secp256k1_ecdsa_seckey_verify(seckey_ptr) != C.int(1) {
		log.Panic("Invalid secret key")
	}

	ret := C.secp256k1_ecdsa_sign_compact(
		msg_ptr, C.int(len(msg)),
		sig_ptr,
		seckey_ptr,
		nonce_ptr,
		&recid)

	sig[64] = byte(int(recid))

	if int(recid) > 4 {
		log.Panic()
	}

	if ret != 1 {
		return SignDeterministic(msg, seckey, nonce_seed) //nonce invalid,retry
	}

	return sig
}

示例#3
文件: visor.go 项目: keepwalking1234/skycoin

func (self *Visor) CreateGenesisBlockInit() (SignedBlock, error) {
	self.GenesisPreconditions()

	if len(self.Blockchain.Blocks) != 0 || len(self.blockSigs.Sigs) != 0 {
		log.Panic("Blockchain already has genesis")
	}
	if self.Config.BlockchainPubkey != cipher.PubKeyFromSecKey(self.Config.BlockchainSeckey) {
		log.Panicf("Cannot create genesis block. Invalid secret key for pubkey")
	}

	gb := self.Blockchain.CreateGenesisBlock(self.Config.GenesisAddress,
		self.Config.GenesisTimestamp, self.Config.GenesisCoinVolume)
	sb := self.SignBlock(gb)
	if err := self.verifySignedBlock(&sb); err != nil {
		log.Panic("Signed a fresh genesis block, but its invalid: %v", err)
	}
	self.blockSigs.record(&sb)

	log.Printf("New Genesis:")
	log.Printf("genesis_time= %v", sb.Block.Head.Time)
	log.Printf("genesis_address= %v", self.Config.GenesisAddress.String())
	log.Printf("genesis_signature= %v", sb.Sig.Hex())

	return sb, nil
}

示例#4
文件: pool_win.go 项目: hackintoshrao/minio

func (p *Pool) print(first bool) bool {
	var out string
	if !first {
		coords, err := getCursorPos()
		if err != nil {
			log.Panic(err)
		}
		coords.Y -= int16(len(p.bars))
		coords.X = 0

		err = setCursorPos(coords)
		if err != nil {
			log.Panic(err)
		}
	}
	isFinished := true
	for _, bar := range p.bars {
		if !bar.isFinish {
			isFinished = false
		}
		bar.Update()
		out += fmt.Sprintf("\r%s\n", bar.String())
	}
	fmt.Print(out)
	return isFinished
}

示例#5
文件: jenkins-authentication-proxy.go 项目: Recras/jenkins-authentication-proxy

func main() {
	jenkins_address := os.Getenv("JENKINS_URL")
	listen_address := os.Getenv("LISTEN_ADDRESS")

	if listen_address == "" {
		listen_address = "[::]:8080"
	}
	if jenkins_address == "" {
		log.Fatalln("Use environment variables JENKINS_URL and LISTEN_ADDRESS (default \"[::]:8080\")")
	}

	remote, err := url.Parse(jenkins_address)
	if err != nil {
		log.Panic(err)
	}

	proxy := httputil.NewSingleHostReverseProxy(remote)
	http.HandleFunc("/", handler(proxy))

	log.Println("jenkins-authentication-proxy", version, "starting")
	log.Println("Authentication endpoint:", planio_url)
	err = http.ListenAndServe(listen_address, nil)
	if err != nil {
		log.Panic(err)
	}
}

示例#6
文件: serialization.go 项目: RagnarDanneskjold/skycoin

// Loads a blockchain but subdues errors into the logger, or panics.
// If no blockchain is found, it creates a new empty one
func loadBlockchain(filename string, genAddr coin.Address) *coin.Blockchain {
	bc := &coin.Blockchain{}
	created := false
	if filename != "" {
		var err error
		bc, err = LoadBlockchain(filename)
		if err == nil {
			if len(bc.Blocks) == 0 {
				log.Panic("Loaded empty blockchain")
			}
			loadedGenAddr := bc.Blocks[0].Body.Transactions[0].Out[0].Address
			if loadedGenAddr != genAddr {
				log.Panic("Configured genesis address does not match the " +
					"address in the blockchain")
			}
			created = true
		} else {
			if os.IsNotExist(err) {
				logger.Info("No blockchain file, will create a new blockchain")
			} else {
				log.Panicf("Failed to load blockchain file \"%s\": %v",
					filename, err)
			}
		}
	}
	if !created {
		bc = coin.NewBlockchain()
	}
	return bc
}

示例#7
文件: list-all-vms.go 项目: stamp/go-xenserver-client

func main() {
	//log.SetLevel(log.DebugLevel)

	// Create a new client
	client := client.NewXenAPIClient("127.0.0.1", "username", "password")

	// Login, this will create a session that is used by all other methods
	err := client.Login()
	if err != nil {
		log.Panic(err)
	}

	// Fetch a list of all VMs, unfortunaly this will return templates and the domain controller as well
	vms, err := client.GetVMs()
	if err != nil {
		log.Panic(err)
	}

	// Loop thru all VMs
	for _, vm := range vms {
		// Fetch information about this vm. This method will also return a list with all available records
		vm.GetRecord()

		// Ignore all that is not a VM (templates and domain controller)
		if !vm.IsVM {
			continue
		}

		// Print out information about the VM
		fmt.Printf("%s (%s) - %s\n", vm.Name, vm.PowerState, vm.Description)
	}

}

示例#8
文件: main.go 项目: ovr/go-url-checker

func initDataBase() *sql.DB {
	db, err := sql.Open("sqlite3", "./sites.db")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	sqlStmt := `
	DELETE FROM sites;
	DROP TABLE sites;
	`
	db.Exec(sqlStmt)
	if err != nil {
		log.Panic("%q: %s\n", err, sqlStmt)
		os.Exit(1)
	}

	sqlStmt = `
	CREATE TABLE sites (domain TEXT NOT NULL PRIMARY KEY, code INTEGER);
	`
	_, err = db.Exec(sqlStmt)
	if err != nil {
		log.Panic("%q: %s\n", err, sqlStmt)
		os.Exit(1)
	}

	return db
}

示例#9
文件: graf.go 项目: pwaller/mema

func make_window(w, h int, title string) func() {
	// Required to make sure that the OpenGL go-routine doesn't get switched
	// to another thread (=> kerblammo)
	runtime.LockOSThread()

	if err := glfw.Init(); err != nil {
		log.Panic("glfw Error:", err)
	}

	err := glfw.OpenWindow(w, h, 0, 0, 0, 0, 0, 0, glfw.Windowed)
	if err != nil {
		log.Panic("Error:", err)
	}

	if gl.Init() != 0 {
		log.Panic("gl error")
	}

	if *vsync {
		glfw.SetSwapInterval(1)
	} else {
		glfw.SetSwapInterval(0)
	}

	glfw.SetWindowTitle(title)
	glfw.SetWindowSizeCallback(Reshape)

	Init()

	return func() {
		glfw.Terminate()
		glfw.CloseWindow()
		log.Print("Cleanup")
	}
}

示例#10
文件: secp256k1.go 项目: keepwalking1234/skycoin

//recovers the public key from the signature
//recovery of pubkey means correct signature
func RecoverPubkey(msg []byte, sig []byte) []byte {
	if len(sig) != 65 {
		log.Panic()
	}

	var recid int = int(sig[64])

	pubkey, ret := secp.RecoverPublicKey(
		sig[0:64],
		msg,
		recid)

	if ret != 1 {
		log.Printf("RecoverPubkey: code %s", ret)
		return nil
	}
	//var pubkey2 []byte = pubkey1.Bytes() //compressed

	if pubkey == nil {
		log.Panic("ERROR: impossible, pubkey nil and ret ==1")
	}
	if len(pubkey) != 33 {
		log.Panic("pubkey length wrong")
	}

	return pubkey
	//nonce1.SetBytes(nonce_seed)

}

示例#11
文件: secp256k1.go 项目: keepwalking1234/skycoin

//raise a pubkey to the power of a seckey
func ECDH(pub []byte, sec []byte) []byte {
	if len(sec) != 32 {
		log.Panic()
	}

	if len(pub) != 33 {
		log.Panic()
	}

	if VerifySeckey(sec) != 1 {
		log.Printf("Invalid Seckey")
	}

	if ret := VerifyPubkey(pub); ret != 1 {
		log.Printf("Invalid Pubkey, %d", ret)
		return nil
	}

	pubkey_out := secp.Multiply(pub, sec)
	if pubkey_out == nil {
		return nil
	}
	if len(pubkey_out) != 33 {
		log.Panic("ERROR: impossible, invalid pubkey length")
	}
	return pubkey_out
}

示例#12
文件: registry.go 项目: andradeandrey/skynet

func RemoveFromRegistry(r *RpcService) {

	newServices := make([]*RpcService, 0)

	for _, v := range NOS.Services {
		if v != nil {
			if !v.Equal(r) {
				newServices = append(newServices, v)
			}

		}
	}
	NOS.Services = newServices
	b, err := json.Marshal(NOS)
	if err != nil {
		log.Panic(err.String())
	}
	rev, err := DC.Rev()
	if err != nil {
		log.Panic(err.String())
	}
	_, err = DC.Set("/servers/config/networkservers.conf", rev, b)
	if err != nil {
		log.Panic(err.String())
	}
}

示例#13
文件: registry.go 项目: andradeandrey/skynet

func RemoveService(i int) {

	newServices := make([]*RpcService, 0)

	for k, v := range NOS.Services {
		if k != i {
			if v != nil {
				newServices = append(newServices, v)
			}
		}
	}
	NOS.Services = newServices
	b, err := json.Marshal(NOS)
	if err != nil {
		log.Panic(err.String())
	}
	rev, err := DC.Rev()
	if err != nil {
		log.Panic(err.String())
	}
	_, err = DC.Set("/servers/config/networkservers.conf", rev, b)
	if err != nil {
		log.Panic(err.String())
	}

}

示例#14
文件: read.go 项目: bcho/read

func main() {
	robot := robot.NewRobot()
	if err := robot.Start(); err != nil {
		log.Panic(err)
	}

	bot, err := tgbotapi.NewBotAPI(os.Getenv("BOT_TOKEN"))
	if err != nil {
		log.Panic(err)
	}

	bot.Debug = true

	u := tgbotapi.NewUpdate(0)
	u.Timeout = 60

	updates, err := bot.GetUpdatesChan(u)
	if err != nil {
		log.Panic(err)
	}

	for update := range updates {
		log.Printf("[%s] %s", update.Message.From.UserName, update.Message.Text)

		bot.Send(robot.Response(update.Message))
	}
}

示例#15
文件: configuration.go 项目: maxzerbini/ovo

func GetServerIP() string {
	ifaces, err := net.Interfaces()
	if err != nil {
		log.Panic("Can't acess the network interfaces.")
	}
	var ip net.IP
	for _, i := range ifaces {
		addrs, err := i.Addrs()
		if err != nil {
			log.Panic("Can't read the IP.")
		}
		for _, addr := range addrs {
			switch v := addr.(type) {
			case *net.IPNet:
				//log.Printf("Evaluating IPNet: %v\r\n", v.IP)
				if (v.IP.To4() != nil) && !v.IP.IsLinkLocalUnicast() && !v.IP.IsLoopback() && !v.IP.IsMulticast() {
					ip = v.IP
				}
			case *net.IPAddr:
				//log.Printf("Evaluating IPAddr: %v\r\n", v.IP)
				if (v.IP.To4() != nil) && !v.IP.IsLinkLocalUnicast() && !v.IP.IsLoopback() && !v.IP.IsMulticast() {
					ip = v.IP
				}
			}
		}
	}
	// process IP address
	return ip.String()
}

示例#16
文件: proxyServer.go 项目: mehulsbhatt/goRepo

func (*myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// output request
	request, err := httputil.DumpRequest(r, false)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(request))

	// create client to get site
	tr := &http.Transport{}
	//client := http.Client{}
	r.RequestURI = "" // pay attention : it is very important
	//response, err := client.Do(r)
	response, err := tr.RoundTrip(r)
	if err != nil {
		log.Panic(err, "not get response")
	}
	defer response.Body.Close()
	data, err := ioutil.ReadAll(response.Body)
	if err != nil {
		log.Panic(err, "not get Body")
	}
	fmt.Println("Get Body")

	// save Header
	for i, j := range response.Header {
		for _, k := range j {
			w.Header().Add(i, k)
		}
	}
	w.WriteHeader(response.StatusCode)
	w.Write(data)
}

示例#17
文件: auth.go 项目: EMSL-MSC/pacifica-uploader-2.0

func authHandle(w http.ResponseWriter, req *http.Request) {
	c := strings.Count(req.URL.Path, "/")
	l := len(req.URL.Path)
	if c == 2 || (c == 3 && req.URL.Path[l-1:l] == "/" && req.URL.Path[l-2:l-1] != "/") {
		ss := strings.Split(req.URL.Path, "/")
		user := ss[2]
		if user == "" {
			w.WriteHeader(http.StatusBadRequest)
		} else {
			switch platform.PlatformGet() {
			case platform.Windows:
				if strings.Index(user, ":") != -1 {
					w.WriteHeader(http.StatusBadRequest)
				} else {
					path, _ := authStore.GetFile(strings.ToLower(user))
					w.Write([]byte(path + "\n"))
				}
			case platform.Linux:
				path, _ := authStore.GetFile(user)
				w.Write([]byte(path + "\n"))
			case platform.Darwin:
				log.Panic("Darwin not yet supported")
			default:
				log.Panic("%v+ not yet supported", runtime.GOOS)
			}
		}
	} else {
		w.WriteHeader(http.StatusBadRequest)
	}
}

示例#18
文件: storage.go 项目: chenyongsuda/CodePackage

//保存离线消息
func (storage *Storage) SaveMessage(msg *IMMessage) {
	_, ok := storage.files[msg.receiver]
	if !ok {
		path := storage.GetOfflinePath(msg.receiver)
		fmt.Println("path:", path)
		file, err := os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
		if err != nil {
			log.Panic("open file")
		}
		file_size, err := file.Seek(0, os.SEEK_END)
		if err != nil {
			log.Panic("seek file")
		}
		if file_size < HEADER_SIZE && file_size > 0 {
			log.Println("file header is't complete")
			err = file.Truncate(0)
			if err != nil {
				log.Panic("truncate file")
			}
			file_size = 0
		}
		if file_size == 0 {
			storage.WriteHeader(file)
		}
		storage.files[msg.receiver] = file
	}
	storage.WriteMessage(storage.files[msg.receiver], msg)
}

示例#19
文件: Connector_test.go 项目: Griesbacher/nagflux

func (mockLive *MockLivestatus) StartMockLivestatus() {
	var listener net.Listener
	var err error
	switch mockLive.ConnectionType {
	case "tcp":
		listener, err = net.Listen("tcp", mockLive.LivestatusAddress)
	case "file":
		listener, err = net.Listen("unix", mockLive.LivestatusAddress)
	default:
		log.Panic("ConnectionType undefined")
		return
	}

	if err != nil {
		log.Panic(err)
	}

	isRunning := true
	for isRunning {
		conn, err := listener.Accept()
		if err != nil {
			//log.Println(err)
			continue
		}
		go mockLive.handle(conn)

		mutex.Lock()
		isRunning = mockLive.isRunning
		mutex.Unlock()
	}
}

示例#20
文件: blockchain_file.go 项目: RagnarDanneskjold/skycoin

//decode block to bytes
func Dec_block(b []byte) (SignedBlock, error) {
	if len(b) < 16 {
		log.Panic()
	}

	var dln uint64 = le_Uint64(b[0:8])
	var seq uint64 = le_Uint64(b[8:16])
	var chk uint64 = le_Uint64(b[16:24])

	if dln != uint64(len(b)) {
		log.Panic("Dec_block, length check failed")
	}

	b = b[24:] //cleave off header

	if chk != FnvsHash(b) {
		log.Panic("Dec_block, checksum failed")
	}

	var sb SignedBlock
	err := encoder.DeserializeRaw(b, &sb)
	if err != nil {
		log.Panic("Dec_block, deserialization failed")
	}

	if seq != sb.Block.Head.BkSeq {
		log.Panic("Dec_block, seq mismatch")
	}

	return sb, nil
}

示例#21
文件: penstock.go 项目: athoune/go-penstock

func main() {
	client, err := NewClient("localhost", 4807)
	if err != nil {
		//error
	}
	// some login?
	header := &Header{
		Path: []byte("some/path"),
	}
	log.Println(header)
	err = client.Write(NewBytesMessage(header, []byte("hello")))
	if err != nil {
		log.Panic(err)
	}
	err = client.Write(NewBytesMessage(header, []byte("world!")))
	if err != nil {
		log.Panic(err)
	}
	var msg CompleteMessage
	for {
		msg = <-client.response
		b := bytes.NewBuffer(msg.Body)
		log.Println("Response:", msg.Header, b.String())
	}
}

示例#22
文件: encoder.go 项目: Chao-Jia/skycoin

// Fast path for atomic types.
func DeserializeAtomic(in []byte, data interface{}) {
	n := intDestSize(data)
	if len(in) < n {
		log.Panic("Not enough data to deserialize")
	}
	if n != 0 {
		var b [8]byte
		copy(b[0:n], in[0:n])
		bs := b[:n]

		switch v := data.(type) {
		case *int8:
			*v = int8(b[0])
		case *uint8:
			*v = b[0]
		case *int16:
			*v = int16(le_Uint16(bs))
		case *uint16:
			*v = le_Uint16(bs)
		case *int32:
			*v = int32(le_Uint32(bs))
		case *uint32:
			*v = le_Uint32(bs)
		case *int64:
			*v = int64(le_Uint64(bs))
		case *uint64:
			*v = le_Uint64(bs)
		default:
			//FIX: this does not get triggered on invalid type in
			// pass in struct on unit test
			log.Panic("type not atomic")
		}
	}
}

示例#23
文件: ec.go 项目: Chao-Jia/skycoin

//returns nil on failure
//crash rather than fail
func GeneratePublicKey(k []byte) []byte {

	//log.Panic()
	if len(k) != 32 {
		log.Panic()
	}
	var r XYZ
	var n Number
	var pk XY

	//must not be zero
	//must not be negative
	//must be less than order of curve
	n.SetBytes(k)
	if n.Sign() <= 0 || n.Cmp(&TheCurve.Order.Int) >= 0 {
		log.Panic("only call for valid seckey, check that seckey is valid first")
		return nil
	}
	ECmultGen(&r, &n)
	pk.SetXYZ(&r)
	if pk.IsValid() == false {
		log.Panic() //should not occur
	}
	_pubkey_test(pk)
	return pk.Bytes()
}

示例#24
文件: main.go 项目: kellegous/bungler

func main() {
	flagTypes := flag.String("types", "jar,src", "")
	flagDst := flag.String("dst", ".", "")
	flagRec := flag.Bool("recursive", true, "")
	flag.Parse()

	types, err := parseTypes(*flagTypes)
	if err != nil {
		log.Panic(err)
	}

	if _, err := os.Stat(*flagDst); err != nil {
		if err := os.MkdirAll(*flagDst, os.ModePerm); err != nil {
			log.Panic(err)
		}
	}

	var dep repo.Dep
	for _, arg := range flag.Args() {
		if err := dep.Parse(arg); err != nil {
			log.Panic(err)
		}

		if err := dep.Download(*flagDst, *flagRec, types); err != nil {
			log.Panic(err)
		}
	}
}

示例#25
文件: secp256.go 项目: JmAbuDabi/skycoin

//generates deterministic keypair with weak SHA256 hash of seed
//internal use only
//be extremely careful with golang slice semantics
func generateDeterministicKeyPair(seed []byte) ([]byte, []byte) {
	if seed == nil {
		log.Panic()
	}

	pubkey_len := C.int(33)
	const seckey_len = 32

	var pubkey []byte = make([]byte, pubkey_len)
	var seckey []byte = make([]byte, seckey_len)

	var pubkey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
	var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0]))

new_seckey:
	seed = SumSHA256(seed[0:32])
	copy(seckey[0:32], seed[0:32])
	if C.secp256k1_ecdsa_seckey_verify(seckey_ptr) != 1 {
		goto new_seckey //rehash seckey until it succeeds, almost never happens
	}

	ret := C.secp256k1_ecdsa_pubkey_create(
		pubkey_ptr, &pubkey_len,
		seckey_ptr, 1)

	if ret != 1 {
		log.Panic("secp256k1-g0, generateDeterministicKeyPair, pubkey generation failing for valid seckey")
	}

	return pubkey, seckey
}

示例#26
文件: reinhardt.go 项目: Manuras/reinhardt

func main() {

	// Load config

	// Create logger

	// Setup database
	dbString := fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable", DB_USER, DB_PASSWORD, DB_NAME)
	db, err := sql.Open("postgres", dbString)

	if err != nil {
		log.Panic(err)
	}

	err = db.Ping()

	if err != nil {
		log.Panic(err)
	}

	defer db.Close()

	// Setup all repositories
	var repos = Repositories{&repo.UserRepository{db}}

	user := new(repo.User)
	user.Username = "test"

	repos.user.Save(user)
}

示例#27
文件: secp256.go 项目: JmAbuDabi/skycoin

//raise a pubkey to the power of a seckey
func ECDH(pub []byte, sec []byte) []byte {
	if len(sec) != 32 {
		log.Panic()
	}

	if len(pub) != 33 {
		log.Panic()
	}

	if VerifyPubkey(pub) != 1 {
		log.Printf("Invalid Pubkey")
		return nil
	}

	if VerifySeckey(sec) != 1 {
		log.Printf("Invalid Seckey")
	}

	var pub2 []byte = make([]byte, 33)
	copy(pub2[0:33], pub[0:33])

	var pub_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pub2[0]))
	var sec_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&sec[0]))

	ret := C.secp256k1_ecdsa_pubkey_tweak_mul(
		pub_ptr, C.int(len(pub2)),
		sec_ptr,
	)

	if ret != 1 {
		return nil
	}

	return pub2
}

示例#28
文件: util.go 项目: tdeckers/utcar

func Encrypt3DESECB(input []byte, key []byte) []byte {
	if len(key) != 24 {
		log.Panic("Key must be 24 bytes")
	}
	block, err := des.NewTripleDESCipher(key)
	if err != nil {
		log.Panic(err)
	}
	bs := block.BlockSize()
	//log.Printf("Block size: %d", bs)
	if len(input)%bs != 0 {
		log.Panic("Input should be a multiple of blocksize")
	}
	//log.Printf("Input length: %d", len(input))
	m := len(input) / bs
	//log.Printf("Going for %d cycles", m)
	data := []byte{}
	buf := make([]byte, bs)
	for i := 0; i < m; i++ {
		//log.Printf("%d: byte: %s", i, hex.EncodeToString(input[0:bs]))
		block.Encrypt(buf, input)
		input = input[bs:]
		data = append(data, buf...)
	}
	return data
}

示例#29
文件: api.go 项目: Celluliodio/flannel

// RegisterTestRequest registers the HTTP request req for testing, such that
// any API calls are sent to the provided URL. It returns a closure to delete
// the registration.
// It should only be used by aetest package.
func RegisterTestRequest(req *http.Request, apiURL *url.URL, decorate func(netcontext.Context) netcontext.Context) func() {
	c := &context{
		req:    req,
		apiURL: apiURL,
	}
	ctxs.Lock()
	defer ctxs.Unlock()
	if _, ok := ctxs.m[req]; ok {
		log.Panic("req already associated with context")
	}
	if _, ok := ctxs.dec[req]; ok {
		log.Panic("req already associated with context")
	}
	if ctxs.dec == nil {
		ctxs.dec = make(map[*http.Request]func(netcontext.Context) netcontext.Context)
	}
	ctxs.m[req] = c
	ctxs.dec[req] = decorate

	return func() {
		ctxs.Lock()
		delete(ctxs.m, req)
		delete(ctxs.dec, req)
		ctxs.Unlock()
	}
}

示例#30
文件: main.go 项目: blabber/cmg

func main() {
	flag.Parse()

	tmpl = template.New("root").Funcs(template.FuncMap{"wrapDescription": wrapDescription})
	_, err := tmpl.ParseGlob(path.Join(*templates, "*.tmpl"))
	if err != nil {
		log.Panic(err)
	}

	l := lib.NewRateLimiter(time.Second/10, 100)
	defer l.Stop()

	ln, err := net.Listen("tcp", net.JoinHostPort(*ip, *port))
	if err != nil {
		log.Panic(err)
	}
	for {
		<-l.Throttle
		conn, err := ln.Accept()
		if err != nil {
			log.Print(err)
		}
		go handleConnection(conn)
	}
}

展开阅读全文