Exemple #1
0
// decodes an nntp message and writes it to a section of the file.
func decodeMsg(c *nntp.Conn, f *file, groups []string, MsgID string) {
	defer f.Done()
	g, err := findGroup(c, groups)
	if err != nil {
		putBroken(c)
		glog.Errorf("switching to group %s: %s", g, err)
		return
	}
	rc, err := c.GetMessage(MsgID)
	if err != nil {
		glog.Errorf("getting message %s from group %s: %s", MsgID, g, err)
		if _, ok := err.(*textproto.Error); ok {
			putConn(c)
		} else {
			putBroken(c)
		}
		return
	}
	putConn(c)

	yread, err := yenc.NewPart(bytes.NewReader(rc))
	if err != nil {
		glog.Errorln(err)
		return
	}
	wr := f.WriterAt(yread.Begin)
	_, err = io.Copy(wr, yread)
	if err != nil {
		glog.Errorln(err)
	}
}
Exemple #2
0
func (i *instance) connectionHandler(c *net.UnixConn) {
	defer c.Close()
	for {
		req, err := readRequest(c)
		if err == io.EOF {
			return // Client closed the connection.
		}
		if err != nil {
			glog.Errorln("Failed to read a message from socket:", err)
		}
		f, t := funcMap[req.Type]
		if t != true {
			sendError(c, fmt.Errorf("unknown request type"))
			continue
		}
		resp, err := f(i, req)
		if err != nil {
			sendError(c, err)
			continue
		}
		err = writeResponse(c, resp)
		if err != nil {
			glog.Errorln("Failed to write a message to socket:", err)
			return
		}
	}
}
Exemple #3
0
func createNewLevelDB(path string, _ graph.Options) error {
	opts := &opt.Options{}
	db, err := leveldb.OpenFile(path, opts)
	if err != nil {
		glog.Errorf("Error: could not create database: %v", err)
		return err
	}
	defer db.Close()
	qs := &QuadStore{}
	qs.db = db
	qs.writeopts = &opt.WriteOptions{
		Sync: true,
	}
	qs.readopts = &opt.ReadOptions{}
	_, err = qs.db.Get([]byte(horizonKey), qs.readopts)
	if err != nil && err != leveldb.ErrNotFound {
		glog.Errorln("couldn't read from leveldb during init")
		return err
	}
	if err != leveldb.ErrNotFound {
		return graph.ErrDatabaseExists
	}
	// Write some metadata
	if err = setVersion(qs.db, latestDataVersion, qs.writeopts); err != nil {
		glog.Errorln("couldn't write leveldb version during init")
		return err
	}
	qs.Close()
	return nil
}
Exemple #4
0
// Main loop for dispatching SyncQueue
// TODO exit
func Dispatch() {
	var err error
	for {
		select {
		case si := <-SyncQueue:
			if si.FullSync {
				syncAlbum(si)
			} else if si, err = NewSyncItemPhoto(si.Filename); err != nil {
				glog.Errorln(err)
			} else {
				syncAlbum(si)
			}
		case ai := <-AlbumQueue:
			switch {
			case ai.MetaUpdate:
				glog.Infoln("Updating Album meta")
				if err = updateMeta(ai.AlbumId); err != nil {
					glog.Errorln(err)
				} else {
					glog.Infof("Metainfo was updated for albumId", ai.AlbumId)
				}
			case ai.StatusUpdate:
				glog.Infoln("Reloading albums")
				if err = updateAlbums(); err != nil {
					glog.Errorln(err)
				} else {
					glog.Infoln("Albums were reloaded")
				}
			}
		}
	}
}
Exemple #5
0
func (p *pusher) Push(entry *protolog.Entry) error {
	if entry.Level == protolog.Level_LEVEL_DEBUG && !p.logDebug {
		return nil
	}
	dataBytes, err := p.marshaller.Marshal(entry)
	if err != nil {
		return err
	}
	data := string(dataBytes)
	switch entry.Level {
	case protolog.Level_LEVEL_DEBUG, protolog.Level_LEVEL_INFO:
		glog.Infoln(data)
	case protolog.Level_LEVEL_WARN:
		glog.Warningln(data)
	case protolog.Level_LEVEL_ERROR:
		glog.Errorln(data)
	case protolog.Level_LEVEL_FATAL:
		// cannot use fatal since this will exit before logging completes,
		// which is particularly important for a multi-pusher
		glog.Errorln(data)
	case protolog.Level_LEVEL_PANIC:
		// cannot use panic since this will panic before logging completes,
		// which is particularly important for a multi-pusher
		glog.Errorln(data)
	}
	return nil
}
Exemple #6
0
func (this *TaskType) realUpTask() {
	for {
		one := this.buff[1].Front()
		if one == nil {
			time.Sleep(100 * time.Millisecond)
			continue
		}

		t := one.Value.(*TaskInfo2DB)
		if t.sign == 'A' {
			_, err := newTask2DB(this.Name, t.taskInfo.Tid, t.taskInfo.Rid, t.taskInfo.Info, t.stat)
			if err != nil {
				glog.Errorln("NEWTASK2DB:", err.Error())
			} else if t.stat == 2 {
				this.lock[0].Lock()
				this.buff[0].PushBack(t.taskInfo) // 直接入分发队列
				this.lock[0].Unlock()
			}
		} else if t.sign == 'U' {
			_, err := upTask2DB(this.Name, t.taskInfo.Tid, t.rapper, t.msg, t.stat)
			if err != nil {
				glog.Errorln("UPTASK2DB:", err.Error())
			}
		}

		this.lock[1].Lock()
		this.buff[1].Remove(one)
		this.lock[1].Unlock()
	}
}
Exemple #7
0
func init() {
	if client, err := db.Client(); err != nil {
		glog.Errorln(err)
	} else {
		defer db.Release(client)
		{
			if len(config.Cfg.Metrics.AddScript) > 0 {
				if addSha, err = client.Cmd("SCRIPT", "LOAD", config.Cfg.Metrics.AddScript).Str(); err != nil {
					glog.Errorln(err)
				} else {
					glog.Infoln("ADD SHA", addSha)
				}
			}

			if len(config.Cfg.Metrics.GetScript) > 0 {
				if getSha, err = client.Cmd("SCRIPT", "LOAD", config.Cfg.Metrics.GetScript).Str(); err != nil {
					glog.Errorln(err)
				} else {
					glog.Infoln("GET SHA", getSha)
				}
			}

			if len(config.Cfg.Metrics.TtlScript) > 0 {
				if ttlSha, err = client.Cmd("SCRIPT", "LOAD", config.Cfg.Metrics.TtlScript).Str(); err != nil {
					glog.Errorln(err)
				} else {
					glog.Infoln("TTL SHA", ttlSha)
				}
			}
		}
	}
}
Exemple #8
0
func (r *Remote) writePump(outbound chan interface{}) {
	ticker := time.NewTicker(pingPeriod)
	defer func() {
		ticker.Stop()
	}()
	for {
		select {
		case message, ok := <-outbound:
			if !ok {
				r.ws.WriteMessage(websocket.CloseMessage, []byte{})
				return
			}
			b, err := json.Marshal(message)
			if err != nil {
				glog.Errorln(err)
				return
			}
			glog.V(2).Infoln(string(b))
			if err := r.ws.WriteMessage(websocket.TextMessage, b); err != nil {
				glog.Errorln(err)
				return
			}
		case <-ticker.C:
			if err := r.ws.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
				glog.Errorln(err)
				return
			}
		}
	}
}
// GetSession returns a SeverSession from the database.
// It checks memcached/redis first, and then falls back on the
// database.
func GetSession(id string) (*ServerSession, error) {
	conn := database.Pool.Get()
	defer conn.Close()

	var ss ServerSession

	reply, err := conn.Do("GET", id)
	if reply != nil && err == nil {
		b, ok := reply.([]byte)

		if ok {
			err = ss.UnmarshalJSON(b)
			if err != nil {
				glog.Errorln(err)
			}
		}
	} else {
		err = database.DB.QueryRow(`SELECT *
			FROM sessions
			WHERE session_id=$1`, id).
			Scan(&ss.ID, &ss.AuthToken, &ss.CSRFToken, &ss.Email, &ss.School, &ss.Date)
	}

	if err != nil {
		if err == sql.ErrNoRows {
			err = ErrNoSession
		} else {
			glog.Errorln(err)
		}
	}

	return &ss, err
}
Exemple #10
0
func Main() {
	var (
		SQS                        *sqs.SQS
		getUserQueueUrlOutput      *sqs.GetQueueUrlOutput
		getContainerQueueUrlOutput *sqs.GetQueueUrlOutput
		UserQueueUrl               *string
		ContainerQueueUrl          *string

		Dynamo *dynamodb.DynamoDB

		socialWorker *workers.SocialWorker
	)

	SQS = sqs.New(&aws.Config{Region: aws.String("cn-north-1")})
	getUserQueueUrlOutput, err := SQS.GetQueueUrl(&sqs.GetQueueUrlInput{QueueName: aws.String(USER_QUEUE_NAME)})
	if err != nil {
		glog.Errorln("Error on connect user queue url:", err.Error())
		return
	}
	UserQueueUrl = getUserQueueUrlOutput.QueueUrl
	getContainerQueueUrlOutput, err = SQS.GetQueueUrl(&sqs.GetQueueUrlInput{QueueName: aws.String(CONTAINER_QUEUE_NAME)})
	if err != nil {
		glog.Errorln("Error on connect container queue url:", err.Error())
		return
	}
	ContainerQueueUrl = getContainerQueueUrlOutput.QueueUrl

	Dynamo = dynamodb.New(&aws.Config{Region: aws.String("cn-north-1")})

	socialWorker = workers.NewSocialWorker(SQS, UserQueueUrl, ContainerQueueUrl, Dynamo)
	socialWorker.Start()
}
Exemple #11
0
func (m *Manager) Start() {
	m.started = time.Now()
	tick := time.NewTicker(time.Minute)
	for {
		select {
		case <-tick.C:
			glog.Infoln("Manager:", m.String())
		case in := <-m.Incoming:
			switch v := in.(type) {
			case *data.Ledger:
				m.stats["ledgers"]++
				wait := m.ledgers.Set(v.LedgerSequence)
				glog.V(2).Infof("Manager: Received: %d %0.04f/secs ", v.LedgerSequence, wait.Seconds())
				if err := m.db.Insert(v); err != nil {
					glog.Errorln("Manager: Ledger Insert:", err.Error())
				}
			case data.Transaction:
				m.stats["transactions"]++
				if err := m.db.Insert(v); err != nil {
					glog.Errorln("Manager: Transaction Insert:", err.Error())
				}
			}
		case missing := <-m.Missing:
			m.ledgers.Extend(missing.Request.End)
			missing.Response <- m.ledgers.TakeMiddle(missing.Request)
		}
	}
}
func handleGetPagination(w http.ResponseWriter, r *http.Request) {
	var err error
	switch r.Method {
	case "GET":
		engine, statuses := getJobsQueryParams(r)
		var minID int64
		if s := r.URL.Query().Get("min-id"); s != "" {
			if minID, err = strconv.ParseInt(s, 0, 64); err != nil {
				glog.Errorf("Failed to parse min-id (%s): %s", s, err)
				http.Error(w, "Invalid Param(s)", http.StatusBadRequest)
				return
			}
		}
		pagination, err := db.GetPagination(engine, statuses, minID)
		if err != nil || len(pagination) != 1 {
			glog.Errorln("Error getting pagination info from DB", err)
			error500(w)
			return
		}
		if res, err := json.Marshal(pagination[0]); err != nil {
			glog.Errorln("Error Marshalling pagination JSON:", err)
			error500(w)
			return
		} else {
			w.Write(res)
		}
	}
}
Exemple #13
0
func (context *clientContext) processSend() {
	if err := context.sendInitialize(); err != nil {
		glog.Errorln(err.Error())
		return
	}

	buf := make([]byte, 1024)

	for {
		size, err := context.pty.Read(buf)
		if err != nil {
			glog.Errorf("Command exited for: %s", context.request.RemoteAddr)
			return
		}
		context.record(append([]byte{rec.Output}, buf[:size]...))
		safeMessage := base64.StdEncoding.EncodeToString([]byte(buf[:size]))
		if errs := context.write(append([]byte{rec.Output},
			[]byte(safeMessage)...)); len(errs) > 0 {
			for _, e := range errs {
				glog.Errorln(e.err.Error())
				context.close(e.key)
			}
			if len(*context.connections) == 0 {
				return
			}
		}
	}
}
Exemple #14
0
func upgradeLevelDB(path string, opts graph.Options) error {
	db, err := leveldb.OpenFile(path, &opt.Options{})
	defer db.Close()

	if err != nil {
		glog.Errorln("Error, couldn't open! ", err)
		return err
	}
	version, err := getVersion(db)
	if err != nil {
		glog.Errorln("error:", err)
		return err
	}

	if version == latestDataVersion {
		fmt.Printf("Already at latest version: %d\n", latestDataVersion)
		return nil
	}

	if version > latestDataVersion {
		err := fmt.Errorf("Unknown data version: %d -- upgrade this tool", version)
		glog.Errorln("error:", err)
		return err
	}

	for i := version; i < latestDataVersion; i++ {
		err := migrateFunctions[i](db)
		if err != nil {
			return err
		}
		setVersion(db, i+1, nil)
	}

	return nil
}
func (s *queueServer) handleUpload(w http.ResponseWriter, r *http.Request) {
	defer logPanic()
	file, header, err := r.FormFile("upload")
	if err != nil {
		glog.Errorln("Couldn't create job", err)
		error500(w)
		return
	}
	jid, err := db.JobCreate(s.Name, header.Filename)
	if err != nil {
		glog.Errorln("Couldn't create job", err)
		error500(w)
		return
	}

	if err = s.doUpload(w, file, jid, header.Filename); err != nil {
		if err = db.JobSetError(jid, "Error starting job"); err != nil {
			glog.Errorf("Error setting job %d error: %s", jid, err)
		}
	} else {
		if err = db.JobSetStarted(jid); err != nil {
			glog.Errorf("Error setting job %d to running: %s", jid, err)
		}
	}
	glog.Infof("Job %d (%s) created successfully", jid, s.Name)
}
Exemple #16
0
func (it *AllIterator) makeCursor() {
	var cursor *sql.Rows
	var err error
	if it.cursor != nil {
		it.cursor.Close()
	}
	if it.table == "quads" {
		cursor, err = it.qs.db.Query(`SELECT
			subject_hash,
			predicate_hash,
			object_hash,
			label_hash
			FROM quads;`)
		if err != nil {
			glog.Errorln("Couldn't get cursor from SQL database: %v", err)
			cursor = nil
		}
	} else {
		glog.V(4).Infoln("sql: getting node query")
		cursor, err = it.qs.db.Query(`SELECT hash FROM nodes;`)
		if err != nil {
			glog.Errorln("Couldn't get cursor from SQL database: %v", err)
			cursor = nil
		}
		glog.V(4).Infoln("sql: got node query")
	}
	it.cursor = cursor
}
Exemple #17
0
func Listen(m *Manager, port string) {
	addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf(":%s", port))
	if err != nil {
		glog.Fatalln("HandleIncoming:", err)
	}
	l, err := net.ListenTCP("tcp", addr)
	if err != nil {
		glog.Fatalln("HandleIncoming:", err)
	}
	defer l.Close()
	for {
		conn, err := l.AcceptTCP()
		if err != nil {
			glog.Errorln("HandleIncoming:", err)
			continue
		}
		host, port, err := net.SplitHostPort(conn.RemoteAddr().String())
		if err != nil {
			glog.Errorln("HandleIncoming:", err)
			continue
		}
		glog.Infoln("Incoming Host: %s Port: %s", host, port)
		m.AddPeer(host, port, false, conn)
	}
}
Exemple #18
0
// tryFlushResponse flushes the response buffer (if not empty); returns true if flush succeeded
func (d *httpDecoder) tryFlushResponse(out *bytes.Buffer) {
	log.V(2).Infof(d.idtag+"try-flush-responses: %d bytes to flush", out.Len())
	// set a write deadline here so that we don't block for very long.
	err := d.setWriteTimeout()
	if err != nil {
		// this is a problem because if we can't set the timeout then we can't guarantee
		// how long a write op might block for. Log the error and skip this response.
		log.Errorln("failed to set write deadline, aborting response:", err.Error())
	} else {
		_, err = out.WriteTo(d.rw.Writer)
		if err != nil {
			if neterr, ok := err.(net.Error); ok && neterr.Timeout() && out.Len() > 0 {
				// we couldn't fully write before timing out, return rch and hope that
				// we have better luck next time.
				return
			}
			// we don't really know how to deal with other kinds of errors, so
			// log it and skip the rest of the response.
			log.Errorln("failed to write response buffer:", err.Error())
		}
		err = d.rw.Flush()
		if err != nil {
			if neterr, ok := err.(net.Error); ok && neterr.Timeout() && out.Len() > 0 {
				return
			}
			log.Errorln("failed to flush response buffer:", err.Error())
		}
	}
}
Exemple #19
0
func (this *SayhiHandler) doGet(w http.ResponseWriter, r *http.Request) {
	const USAGE = "GET /sayhi?type=typename&name=rappername"

	r.ParseForm()
	ttype, name := r.FormValue("type"), r.FormValue("name")
	if ttype == "" || name == "" {
		glog.Errorln("sayhi ERR:", ttype, name)
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte(USAGE))
		return
	}

	taskTypeOne, rapperOne := GetRapper(ttype, name)
	if taskTypeOne == nil {
		glog.Errorln("sayhi to nil type:", ttype)
		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte("no such task type."))
		return
	}

	if rapperOne == nil {
		taskTypeOne.AddRapper(name, NewRapper(name))
	} else {
		taskTypeOne.ResetRapper(rapperOne)
		rapperOne.Beat(true)
	}

	w.Write([]byte("OK"))
	return
}
Exemple #20
0
func (r *Remote) streamLedgerData(ledger interface{}, c chan data.LedgerEntrySlice) {
	defer close(c)
	cmd := newBinaryLedgerDataCommand(ledger, nil)
	for ; ; cmd = newBinaryLedgerDataCommand(ledger, cmd.Result.Marker) {
		r.outgoing <- cmd
		<-cmd.Ready
		if cmd.CommandError != nil {
			glog.Errorln(cmd.Error())
			return
		}
		les := make(data.LedgerEntrySlice, len(cmd.Result.State))
		for i, state := range cmd.Result.State {
			b, err := hex.DecodeString(state.Data + state.Index)
			if err != nil {
				glog.Errorln(cmd.Error())
				return
			}
			les[i], err = data.ReadLedgerEntry(bytes.NewReader(b), data.Hash256{})
			if err != nil {
				glog.Errorln(err.Error())
				return
			}
		}
		c <- les
		if cmd.Result.Marker == nil {
			return
		}
	}
}
func (c *ModifyUserAuthController) DoModify() {
	// 参数获取
	glog.Infoln("--modify request start--")
	user := c.GetString("user")
	glog.Infof("accout is %s \n", user)
	name := c.GetString("name")
	glog.Infof("image name is %s \n", name)
	mtype, err := c.GetInt("mtype")
	if err != nil {
		ret := map[string]interface{}{"success": false, "msg": "mtype参数错误"}
		c.Data["json"] = ret
		glog.Errorln("mtype 错误!!")
		c.ServeJson()
		return
	}
	glog.Infof("mtype is %s", mtype)
	ispull, err := c.GetBool("ispull")
	if err != nil {
		ret := map[string]interface{}{"success": false, "msg": "ispull参数错误"}
		c.Data["json"] = ret
		glog.Errorln("ispull 错误!!")
		c.ServeJson()
		return
	}
	glog.Infof("ispull is %s \n", ispull)

	success := models.ACManager.Update(user, &name, mtype, ispull)

	ret := map[string]interface{}{"success": success}
	c.Data["json"] = ret
	c.ServeJson() // 直接返回json数据

	glog.Flush()
}
func handleGetJobs(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case "GET":
		var err error
		maxIdx, limit, page := int64(0), int64(0), int64(0)
		if r.URL.Path != "" {
			if maxIdx, limit, page, err = parseGetJobsParamsOrBadRequest(w, r.URL.Path); err != nil {
				return
			}
		}
		engine, statuses := getJobsQueryParams(r)
		jobs, err := db.GetJobs(maxIdx, limit, page, engine, statuses)
		if err != nil {
			glog.Errorln("Error getting jobs from DB:", err)
			error500(w)
			return
		}
		if res, err := json.Marshal(map[string]interface{}{"jobs": jobs}); err != nil {
			glog.Errorln("Error Marshalling jobs JSON:", err)
			error500(w)
			return
		} else {
			w.Write(res)
		}
	}
}
Exemple #23
0
func (this *rapperVideo) updateTask() {
	for {
		// 取一个任务
		oneVideoTask := <-this.toUpdate

		// 回调
		para := map[string]string{"type": confJson["tasktype"].(string), "tid": oneVideoTask.Tid, "rid": oneVideoTask.Rid}
		if oneVideoTask.err != nil {
			para["msg"] = base64.StdEncoding.EncodeToString([]byte(oneVideoTask.err.Error()))
		}
		if oneVideoTask.nfid != "" {
			para["nfid"] = oneVideoTask.nfid
		}
		if oneVideoTask.nimg != "" {
			para["img"] = oneVideoTask.nimg
		}

		olderr := ""
		if oneVideoTask.err != nil {
			olderr = oneVideoTask.err.Error()
		}
		glog.Warningln("callbackTask: ", this.no, oneVideoTask.toString(), para)
		body, err := getRequest(oneVideoTask.Callback, &para)
		if err != nil {
			oneVideoTask.err = fmt.Errorf("%s\ncallbackERR: %s", olderr, err.Error())
			glog.Errorln("updateTask callbackERR:", oneVideoTask.toString())
		} else if string(body) != "true" {
			oneVideoTask.err = fmt.Errorf("%s\ncallbackERR: %s", olderr, body)
			glog.Errorln("updateTask callbackERR:", oneVideoTask.toString(), body)
		}

		// 更新任务状态
		delete(para, "rid")
		delete(para, "nfid")
		delete(para, "img")
		para["stat"] = "1"
		para["name"] = confJson["rappername"].(string)
		if oneVideoTask.err != nil {
			para["stat"] = "-1"
			para["msg"] = base64.StdEncoding.EncodeToString([]byte(oneVideoTask.err.Error()))
		}

		glog.Infoln("updateTask: ", this.no, oneVideoTask.toString(), para)
		_, err = getRequest(confJson["taskServ"].(string)+"/uptask", &para)
		if err == nil {
			glog.Warningln("updateTaskOK: ", this.no, oneVideoTask.toString())
		} else {
			glog.Errorln("updateTaskERR:", this.no, oneVideoTask.toString(), para, err.Error())
		}

		glog.Flush()

		// 删除临时文件
		fn := confJson["tmpdir"].(string) + oneVideoTask.Tid
		os.Remove(fn)
		os.Remove(fn + ".mp4")
		os.Remove(fn + ".jpg")
	}
}
Exemple #24
0
// connect to the server. Here we keep trying every 10 seconds until we manage
// to Dial to the server.
func (bot *ircBot) connect() (conn io.ReadWriteCloser) {

	var (
		err     error
		counter int
	)

	connectTimeout := time.After(0)

	bot.Lock()
	bot.isConnecting = true
	bot.isAuthenticating = false
	bot.Unlock()

	for {
		select {
		case <-connectTimeout:
			counter++
			connectTimeout = nil
			glog.Infoln("[Info] Connecting to IRC server: ", bot.address)
			conn, err = tls.Dial("tcp", bot.address, nil) // Always try TLS first
			if err == nil {
				glog.Infoln("Connected: TLS secure")
				return conn
			} else if _, ok := err.(x509.HostnameError); ok {
				glog.Errorln("Could not connect using TLS because: ", err)
				// Certificate might not match. This happens on irc.cloudfront.net
				insecure := &tls.Config{InsecureSkipVerify: true}
				conn, err = tls.Dial("tcp", bot.address, insecure)

				if err == nil && isCertValid(conn.(*tls.Conn)) {
					glog.Errorln("Connected: TLS with awkward certificate")
					return conn
				}
			} else if _, ok := err.(x509.UnknownAuthorityError); ok {
				glog.Errorln("x509.UnknownAuthorityError : ", err)
				insecure := &tls.Config{InsecureSkipVerify: true}
				conn, err = tls.Dial("tcp", bot.address, insecure)
				if err == nil {
					glog.Infoln("Connected: TLS with an x509.UnknownAuthorityError", err)
					return conn
				}
			} else {
				glog.Errorln("Could not establish a tls connection", err)

			}

			conn, err = net.Dial("tcp", bot.address)
			if err == nil {
				glog.Infoln("Connected: Plain text insecure")
				return conn
			}
			// TODO (yml) At some point we might want to panic
			delay := 5 * counter
			glog.Infoln("IRC Connect error. Will attempt to re-connect. ", err, "in", delay, "seconds")
			connectTimeout = time.After(time.Duration(delay) * time.Second)
		}
	}
}
Exemple #25
0
//列出图片
func listFiles(data *ListReqData, list *KindList) error {
	t, err := time.Parse("2006年1月", list.CurrentDirPath)
	if err != nil {
		glog.Errorln("解析时间错误:", err)
		return err
	}

	//取得bucket
	bucket, err := bucketdb.FindByName(data.Bucket)
	if err != nil {
		return err
	}

	list.CurrentUrl = bucket.ImgBaseUrl()
	list.MoveupDirPath = t.Format("2006年")
	prefix := t.Format(IMG_PRE_FMT)

	//取得图片列表
	list.FileList = make([]*KindFile, 0, 10)
	client := rsf.New(&digest.Mac{bucket.Ak, []byte(bucket.Sk)})
	marker := ""
	limit := 1000

	//    "is_dir": false,
	//    "has_file": false,
	//    "filesize": 208736,
	//    "is_photo": true,
	//    "filetype": "jpg",
	//    "filename": "1241601537255682809.jpg",
	//    "datetime": "2011-08-02 15:32:43"
	var es []rsf.ListItem
	for err == nil {
		es, marker, err = client.ListPrefix(nil, bucket.Name, prefix, marker, limit)
		for _, item := range es {
			f := &KindFile{
				IsDir:    false,
				HasFile:  false,
				IsPhoto:  true,
				Filesize: item.Fsize,
				Filetype: item.MimeType,
				Filename: item.Key,
				Datetime: time.Unix(item.PutTime, 0).Format("2006-01-02 15:04:05"),
			}
			list.FileList = append(list.FileList, f)
		}
	}
	if err != io.EOF {
		//非预期的错误
		glog.Errorln("listAll failed:", err)
		return err
	}
	list.TotalCount = len(list.FileList)
	list.Order = data.Order
	sort.Sort(list)
	return nil
}
func Write(data [][]interface{}, dataType string) bool {
	endpoint := fmt.Sprintf("%s:%d", config.Influxdb.Host, config.Influxdb.Port)
	c, err := client.NewClient(&client.ClientConfig{
		Host:     endpoint,
		Username: config.Influxdb.Username,
		Password: config.Influxdb.Password,
		Database: config.Influxdb.Database,
	})

	if err != nil {
		panic(err)
	}

	if argDbCreated == false {
		argDbCreated = true
		if err := c.CreateDatabase(config.Influxdb.Database); err != nil {
			glog.Errorf("Database creation failed with: %s", err)
		} else {
			glog.Info("Creating Database...")
		}
	}

	c.DisableCompression()

	var column []string

	switch dataType {
	case "machine":
		column = Machine
	case "stats":
		column = Stats
	case "network":
		column = Network
	default:
		glog.Error("Unrecognized database")
		return false
	}

	series := &client.Series{
		Name:    dataType,
		Columns: column,
		Points:  data,
	}
	glog.Infoln(series)

	if err := c.WriteSeriesWithTimePrecision([]*client.Series{series}, client.Second); err != nil {
		glog.Errorln("Failed to write", dataType, "to influxDb.", err)
		glog.Errorln("Data:", series)
		if strings.Contains(err.Error(), "400") {
			argDbCreated = false
		}
		return false
	}

	return true
}
func jobError(job string, msg string) {
	glog.Errorln("job", job, "terminated with error:", msg)

	body := strings.NewReader(msg)
	put, _ := http.NewRequest("PUT", fmt.Sprintf("http://%s/result/%s?status=error", cfg.Frontend, job), body)
	_, err := http.DefaultClient.Do(put)
	if err != nil {
		glog.Errorln("Error sending results", err)
		return
	}
}
// Implementing pwshandler.ConnManager interface
func (m *ConnManager) HandleError(ws *websocket.Conn, err error) {
	if err == nil {
		err = errors.New("Passed nil errer to reporting")
	}

	// Log error message
	if ws != nil {
		glog.Errorln("IP:", ws.Request().RemoteAddr, ", Error:", err)
	} else {
		glog.Errorln("Error:", err)
	}
}
Exemple #29
0
// Currently one client acceping will block all other clients' request
func (ln *TCPListener) AcceptTCP() (conn *TCPConn, err error) {
	var c net.Conn
	for {
		c, err = ln.Listener.Accept()
		if err != nil {
			glog.Errorln("fail to accept from listener", err)
			return conn, err
		}

		// in case idle connection session being cleaned by NAT server
		if err = c.(*net.TCPConn).SetKeepAlive(true); err != nil {
			glog.Errorln("fail to set keep alive", err)
			return
		}

		req := request{}
		if err := recieve(ln.cipher, c, &req); err != nil {
			glog.Errorln("fail to recieve request", err)
			continue
		}

		if req.Secret != ln.secret {
			send(ln.cipher, c, response{Status: StatusInvalidSecret})
			continue
		}

		ip, err := ln.ipAddrPool.Get()
		if err != nil {
			send(ln.cipher, c, response{Status: StatusNoIPAddrAvaliable})
			continue
		}
		conn = &TCPConn{
			remoteAddr: ip.IP.To4(),
			listener:   ln,
		}

		conn.cipher, err = cipher.NewCipher(req.Key[:])
		if err != nil {
			return conn, err
		}

		res := response{
			Status: StatusOK,
		}
		copy(res.IP[:], ip.IP.To4())
		copy(res.IPMask[:], ip.Mask)
		send(ln.cipher, c, &res)

		conn.Conn = c

		return conn, err
	}
}
// StoreSession stores a ServerSession in both memcached/redis and the
// backing PostgreSQL database.
func (s *ServerSession) StoreSession(id string) error {
	conn := database.Pool.Get()
	defer conn.Close()

	obj, err := s.MarshalJSON()
	if err != nil {
		glog.Errorln(err)
		return err
	}

	reply, err := conn.Do("SET", id, obj)
	if err != nil {
		glog.Errorln(err, reply)
		return err
	}

	_, err = database.DB.Exec(`WITH new_values (
			session_id, auth_token, csrf_token, email, school, date) as (
		  		values ($1::text,
		  				$2::bytea,
		  				$3::bytea,
		  				$4::text,
		  				$5::text,
		  				$6::bigint
		  			)
		),
		upsert as
		( 
		    UPDATE sessions m
				SET auth_token = nv.auth_token,
		            csrf_token = nv.csrf_token,
		            email      = nv.email,
		            school     = nv.school,
		            date       = nv.date
		    FROM new_values nv
		    WHERE m.session_id = nv.session_id
		    RETURNING m.*
		)
		INSERT INTO sessions (session_id, auth_token, csrf_token, email, school, date)
		SELECT session_id, auth_token, csrf_token, email, school, date
		FROM new_values
		WHERE NOT EXISTS (SELECT 1
		                  FROM upsert up
		                  WHERE up.session_id = new_values.session_id)`,
		id, s.AuthToken, s.CSRFToken, s.Email, s.School, s.Date)

	if err != nil {
		glog.Fatal(err)
	}

	return err
}