本文整理汇总了Golang中github.com/blackbeans/log4go.Warn函数的典型用法代码示例。如果您正苦于以下问题:Golang Warn函数的具体用法?Golang Warn怎么用?Golang Warn使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Warn函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: handshake
//握手包
func handshake(ga *c.GroupAuth, remoteClient *c.RemotingClient) (bool, error) {
for i := 0; i < 3; i++ {
p := protocol.MarshalConnMeta(ga.GroupId, ga.SecretKey)
rpacket := packet.NewPacket(protocol.CMD_CONN_META, p)
resp, err := remoteClient.WriteAndGet(*rpacket, 5*time.Second)
if nil != err {
//两秒后重试
time.Sleep(2 * time.Second)
log.Warn("kiteClient|handShake|FAIL|%s|%s\n", ga.GroupId, err)
} else {
authAck, ok := resp.(*protocol.ConnAuthAck)
if !ok {
return false, errors.New("Unmatches Handshake Ack Type! ")
} else {
if authAck.GetStatus() {
log.Info("kiteClient|handShake|SUCC|%s|%s\n", ga.GroupId, authAck.GetFeedback())
return true, nil
} else {
log.Warn("kiteClient|handShake|FAIL|%s|%s\n", ga.GroupId, authAck.GetFeedback())
return false, errors.New("Auth FAIL![" + authAck.GetFeedback() + "]")
}
}
}
}
return false, errors.New("handshake fail! [" + remoteClient.RemoteAddr() + "]")
}
示例2: remove
//remove segment
func (self *MessageStore) remove(s *Segment) {
self.Lock()
//remove from segments
for i, s := range self.segments {
if s.sid == s.sid {
self.segments = append(self.segments[0:i], self.segments[i+1:]...)
break
}
}
//remove from cache
for e := self.segmentCache.Front(); nil != e; e = e.Next() {
cs := e.Value.(*Segment)
if cs.sid == s.sid {
self.segmentCache.Remove(e)
break
}
}
//close segment
s.Close()
err := os.Remove(s.path)
if nil != err {
log.Warn("MessageStore|Remove|Segment|FAIL|%s|%s", err, s.path)
}
err = os.Remove(s.slog.path)
if nil != err {
log.Warn("MessageStore|Remove|SegmentLog|FAIL|%s|%s", err, s.slog.path)
}
self.Unlock()
log.Info("MessageStore|Remove|Segment|%s", s.path)
}
示例3: onBindChanged
//订阅关系改变
func (self *BindExchanger) onBindChanged(topic, groupId string, newbinds []*Binding) {
if len(groupId) <= 0 {
delete(self.exchanger, topic)
return
}
//不是当前服务可以处理的topic则直接丢地啊哦
if sort.SearchStrings(self.topics, topic) == len(self.topics) {
log.Warn("BindExchanger|onBindChanged|UnAccept Bindings|%s|%s|%s\n", topic, self.topics, newbinds)
return
}
v, ok := self.exchanger[topic]
if !ok {
v = make(map[string][]*Binding, 10)
self.exchanger[topic] = v
}
if len(newbinds) > 0 {
v[groupId] = newbinds
} else {
delete(v, groupId)
}
}
示例4: Process
func (self *RemotingHandler) Process(ctx *DefaultPipelineContext, event IEvent) error {
revent, ok := self.cast(event)
if !ok {
return ERROR_INVALID_EVENT_TYPE
}
// log.Printf("RemotingHandler|Process|%s|%t\n", self.GetName(), revent)
var futures map[string]*turbo.Future
if len(revent.GroupIds) <= 0 && len(revent.TargetHost) <= 0 {
log.Warn("RemotingHandler|%s|Process|NO GROUP OR HOSTS|%s|%s\n", self.GetName(), revent)
futures = EMPTY_FUTURE
} else {
//发送数据
futures = self.invokeGroup(revent)
}
//写入future的响应
revent.futures <- futures
close(revent.futures)
//创建创建网络写出结果
fe := NewRemoteFutureEvent(revent, futures)
ctx.SendForward(fe)
return nil
}
示例5: Process
func (self *ValidateHandler) Process(ctx *DefaultPipelineContext, event IEvent) error {
aevent, ok := self.cast(event)
if !ok {
return ERROR_INVALID_EVENT_TYPE
}
remoteClient := aevent.getClient()
//做权限校验.............
isAuth := self.clientManager.Validate(remoteClient)
// log.DebugLog("kite_handler", "ValidateHandler|CONNETION|%s|%s\n", remoteClient.RemoteAddr(), isAuth)
if isAuth {
ctx.SendForward(event)
} else {
log.Warn("ValidateHandler|UnAuth CONNETION|%s\n", remoteClient.RemoteAddr())
cmd := protocol.MarshalConnAuthAck(false, "未授权的访问,连接关闭!")
//响应包
p := packet.NewPacket(protocol.CMD_CONN_AUTH, cmd)
//直接写出去授权失败
remoteClient.Write(*p)
//断开连接
remoteClient.Shutdown()
}
return nil
}
示例6: Process
func (self *AccessHandler) Process(ctx *DefaultPipelineContext, event IEvent) error {
// log.Debug("accessEvent|Process|%s|%t\n", self.GetName(), event)
aevent, ok := self.cast(event)
if !ok {
return ERROR_INVALID_EVENT_TYPE
}
//做权限校验.............
if false {
log.Warn("accessEvent|Process|INVALID AUTH|%s|%s\n", aevent.groupId, aevent.secretKey)
}
// 权限验证通过 保存到clientmanager
self.clientManager.Auth(client.NewGroupAuth(aevent.groupId, aevent.secretKey), aevent.remoteClient)
// log.Info("accessEvent|Process|NEW CONNECTION|AUTH SUCC|%s|%s|%s\n", aevent.groupId, aevent.secretKey, aevent.remoteClient.RemoteAddr())
cmd := protocol.MarshalConnAuthAck(true, "授权成功")
//响应包
packet := packet.NewRespPacket(aevent.opaque, protocol.CMD_CONN_AUTH, cmd)
//向当前连接写入当前包
remoteEvent := NewRemotingEvent(packet, []string{aevent.remoteClient.RemoteAddr()})
//向后走网络传输
ctx.SendForward(remoteEvent)
return nil
}
示例7: enhancedPool
func (self *ConnPool) enhancedPool(size int) error {
//初始化一下最小的Poolsize,让入到idlepool中
for i := 0; i < size; i++ {
j := 0
var err error
var conn IConn
for ; j < 3; j++ {
err, conn = self.dialFunc(self.id())
if nil != err || nil == conn {
log.Warn("POOL_FACTORY|CREATE CONNECTION|INIT|FAIL|%s", err)
continue
} else {
break
}
}
if j >= 3 || nil == conn {
return errors.New("POOL_FACTORY|CREATE CONNECTION|INIT|FAIL|%s" + err.Error())
}
idleconn := &IdleConn{conn: conn, expiredTime: (time.Now().Add(self.idletime))}
self.idlePool.PushFront(idleconn)
}
return nil
}
示例8: keepAlive
func (self *HeartbeatHandler) keepAlive() {
for {
select {
case <-time.After(self.heartbeatPeriod):
//心跳检测
func() {
id := time.Now().Unix()
clients := self.clientMangager.ClientsClone()
p := protocol.MarshalHeartbeatPacket(id)
for h, c := range clients {
i := 0
//关闭的时候发起重连
if c.IsClosed() {
i = 3
} else {
//如果是空闲的则发起心跳
if c.Idle() {
for ; i < 3; i++ {
hp := packet.NewPacket(protocol.CMD_HEARTBEAT, p)
err := c.Ping(hp, time.Duration(self.heartbeatTimeout))
//如果有错误则需要记录
if nil != err {
log.Warn("HeartbeatHandler|KeepAlive|FAIL|%s|local:%s|remote:%s|%d\n", err, c.LocalAddr(), h, id)
continue
} else {
log.Info("HeartbeatHandler|KeepAlive|SUCC|local:%s|remote:%s|%d|%d ...\n", c.LocalAddr(), h, id, i)
break
}
}
}
}
if i >= 3 {
//说明连接有问题需要重连
c.Shutdown()
self.clientMangager.SubmitReconnect(c)
log.Warn("HeartbeatHandler|SubmitReconnect|%s\n", c.RemoteAddr())
}
}
}()
}
}
}
示例9: Ping
//同步发起ping的命令
func (self *RemotingClient) Ping(heartbeat *packet.Packet, timeout time.Duration) error {
pong, err := self.WriteAndGet(*heartbeat, timeout)
if nil != err {
return err
}
version, ok := pong.(int64)
if !ok {
log.Warn("RemotingClient|Ping|Pong|ERROR TYPE |%s\n", pong)
return ERROR_PONG
}
self.updateHeartBeat(version)
return nil
}
示例10: Replay
//traverse oplog
func (self *SegmentLog) Replay(do func(l *oplog)) {
self.Open()
offset := int64(0)
tmp := make([]byte, 1024)
//seek to head
self.rf.Seek(0, 0)
self.br.Reset(self.rf)
for {
var length int32
err := binary.Read(self.br, binary.BigEndian, &length)
if nil != err {
if err == io.EOF {
self.br.Reset(self.rf)
break
}
log.Warn("SegmentLog|Replay|LEN|%s|Skip...", err)
continue
}
// log.Debug("SegmentLog|Replay|LEN|%d", length)
if int(length) > cap(tmp) {
grow := make([]byte, int(length)-cap(tmp))
tmp = append(tmp, grow...)
}
err = binary.Read(self.br, binary.BigEndian, tmp[:int(length)-4])
if nil != err {
self.br.Reset(self.rf)
log.Error("SegmentLog|Replay|Data|%s", err)
break
}
var ol oplog
r := bytes.NewReader(tmp[:int(length)-4])
deco := gob.NewDecoder(r)
err = deco.Decode(&ol)
if nil != err {
log.Error("SegmentLog|Replay|unmarshal|oplog|FAIL|%s", err)
continue
}
// log.Debug("SegmentLog|Replay|oplog|%s", ol)
do(&ol)
//line
offset += int64(length)
}
self.offset = int64(offset)
}
示例11: HandleForward
func (self *BaseForwardHandler) HandleForward(ctx *DefaultPipelineContext, event IForwardEvent) error {
//处理逻辑成功则向后传递
if !self.processor.TypeAssert(event) {
ctx.SendForward(event)
return nil
} else {
now := time.Now().Unix()
err := self.processor.Process(ctx, event)
cost := time.Now().Unix() - now
if cost > 100 {
log.Warn("BaseForwardHandler|%s|cost:%d\n", self.GetName(), cost)
}
return err
}
}
示例12: listenEvent
//监听数据变更
func (self *ZKManager) listenEvent() {
for !self.isClose {
//根据zk的文档 watcher机制是无法保证可靠的,其次需要在每次处理完watcher后要重新注册watcher
change := <-self.eventChan
path := change.Path
switch change.Type {
case zk.EventSession:
if change.State == zk.StateExpired {
log.Warn("ZKManager|OnSessionExpired!")
//zk链接开则需要重新链接重新推送
self.watcher.OnSessionExpired()
}
case zk.EventNodeDeleted:
self.session.ExistsW(path)
self.watcher.NodeChange(path, ZkEvent(change.Type), []string{})
// log.Info("ZKManager|listenEvent|%s|%s\n", path, change)
case zk.EventNodeCreated, zk.EventNodeChildrenChanged:
childnodes, _, _, err := self.session.ChildrenW(path)
if nil != err {
log.Error("ZKManager|listenEvent|CD|%s|%s|%t\n", err, path, change.Type)
} else {
self.watcher.NodeChange(path, ZkEvent(change.Type), childnodes)
// log.Info("ZKManager|listenEvent|%s|%s|%s\n", path, change, childnodes)
}
case zk.EventNodeDataChanged:
split := strings.Split(path, "/")
//如果不是bind级别的变更则忽略
if len(split) < 5 || strings.LastIndex(split[4], "-bind") <= 0 {
continue
}
//获取一下数据
binds, err := self.getBindData(path)
if nil != err {
log.Error("ZKManager|listenEvent|Changed|Get DATA|FAIL|%s|%s\n", err, path)
//忽略
continue
}
self.watcher.DataChange(path, binds)
// log.Info("ZKManager|listenEvent|%s|%s|%s\n", path, change, binds)
}
}
}
示例13: DataChange
func (self *BindExchanger) DataChange(path string, binds []*Binding) {
//订阅关系变更才处理
if strings.HasPrefix(path, KITEQ_SUB) {
split := strings.Split(path, "/")
//获取topic
topic := split[3]
groupId := split[4]
self.lock.Lock()
defer self.lock.Unlock()
//开始处理变化的订阅关系
self.onBindChanged(topic, groupId, binds)
} else {
log.Warn("BindExchanger|DataChange|非SUB节点变更|%s\n", path)
}
}
示例14: sendMessage
func (self *ApnsConnection) sendMessage(msg *entry.Message) error {
//将当前的msg强制设置为当前conn的id作为标识
msg.ProcessId = self.connectionId
err, packet := msg.Encode()
if nil != err {
return err
}
length, sendErr := self.conn.Write(packet)
if nil != err || length != len(packet) {
log.Warn("CONNECTION|SEND MESSAGE|FAIL|%s", err)
} else {
log.Debug("CONNECTION|SEND MESSAGE|SUCC")
}
return sendErr
}
示例15: reconnect
/*
*重连zk
*/
func (self *ZKManager) reconnect() <-chan bool {
ch := make(chan bool, 1)
go func() {
reconnTimes := int64(0)
f := func() error {
ss, eventChan, err := zk.Connect(strings.Split(self.zkhosts, ","), 5*time.Second)
if nil != err {
log.Warn("连接zk失败.....%ds后重连任务重新发起...|", (reconnTimes+1)*5)
return err
} else {
log.Info("重连ZK任务成功....")
//初始化当前的状态
self.session = ss
self.eventChan = eventChan
ch <- true
close(ch)
return nil
}
}
//启动重连任务
for !self.isClose {
select {
case <-time.After(time.Duration(reconnTimes * time.Second.Nanoseconds())):
err := f()
if nil != err {
reconnTimes += 1
} else {
//重连成功则推出
break
}
}
}
//失败
ch <- false
close(ch)
}()
return ch
}