Example #1
0
func (h *streamHandler) onDefault(name string, callback float64, r *amf0.Reader) error {
	if p := h.publish.p; p == nil {
		xlog.OutLog.Printf("[session]: xid = %d, reader.fid = %d, writer.fid = %d, message on non-published stream\n", h.session.xid, h.fr.fid, h.fw.fid)
		return nil
	} else if p.rpc {
		xlog.OutLog.Printf("[session]: xid = %d, reader.fid = %d, writer.fid = %d, unhandled call on rpc stream\n", h.session.xid, h.fr.fid, h.fw.fid)
		return nil
	} else {
		if w, err := newAmfBytesWriter(name); err != nil {
			return errors.New("stream.onAmfData.write name")
		} else if err := w.WriteBytes(r.Bytes()); err != nil {
			return errors.New("stream.onAmfData.write body")
		} else {
			data := split(w.Bytes())
			call := func(x *streamHandler) {
				s := x.session
				s.Lock()
				defer s.Unlock()
				if s.closed || x.play.p != p {
					return
				}
				defer s.flush()
				x.fw.AddFragments(p.reliable, data...)
			}
			async.Call(p.gid, func() {
				if l, ok := p.list(); ok && l != nil {
					for e := l.Front(); e != nil; e = e.Next() {
						call(e.Value.(*streamHandler))
					}
				}
			})
		}
		return nil
	}
}
Example #2
0
func BroadcastByXid(xids []uint32, data []byte, from uint32, reliable bool) {
	if bs, err := newBroadcastByXidMessage(data, from, reliable); err != nil {
		xlog.ErrLog.Printf("[session]: broadcastByXid error = '%v'\n", err)
	} else {
		data := split(bs)
		call := func(s *Session) {
			s.Lock()
			defer s.Unlock()
			if s.closed {
				return
			}
			defer s.flush()
			if fw := s.mainfw; fw != nil {
				fw.AddFragments(reliable, data...)
			}
		}
		async.Call(uint64(time.Now().UnixNano()), func() {
			for _, xid := range xids {
				if s := FindByXid(xid); s != nil {
					call(s)
				}
			}
		})
	}
}
Example #3
0
func Exit(xid uint32, raddr *net.UDPAddr) {
	if clt := tcp.GetClient(); clt == nil {
		return
	} else if bs, err := newXRequest(xid, raddr, "exit", 0, nil, true); err != nil {
		counts.Count("rpc.exit.error", 1)
		xlog.ErrLog.Printf("[rpc]: rpc exit error = '%v'\n", err)
	} else {
		counts.Count("rpc.exit", 1)
		async.Call(uint64(xid), func() {
			clt.Send(bs)
		})
	}
}
Example #4
0
func CloseAll(xids []uint32) {
	call := func(s *Session) {
		s.Lock()
		defer s.Unlock()
		s.Close()
	}
	async.Call(uint64(time.Now().UnixNano()), func() {
		for _, xid := range xids {
			if s := FindByXid(xid); s != nil {
				call(s)
			}
		}
	})
}
Example #5
0
func Call(xid uint32, raddr *net.UDPAddr, callback float64, data []byte, reliable bool) {
	if clt := tcp.GetClient(); clt == nil {
		counts.Count("rpc.call.noclient", 1)
		xlog.ErrLog.Printf("[rpc]: rpc is disabled\n")
	} else if bs, err := newXRequest(xid, raddr, "call", callback, data, reliable); err != nil {
		counts.Count("rpc.call.error", 1)
		xlog.ErrLog.Printf("[rpc]: rpc call error = '%v'\n", err)
	} else {
		counts.Count("rpc.call", 1)
		async.Call(uint64(xid), func() {
			clt.Send(bs)
		})
	}
}
Example #6
0
func Callback(xid uint32, data []byte, callback float64, reliable bool) {
	if bs, err := newCallbackMessage(callback, data); err != nil {
		xlog.ErrLog.Printf("[session]: callback error = '%v'\n", err)
	} else {
		async.Call(uint64(time.Now().UnixNano()), func() {
			if s := FindByXid(xid); s != nil {
				s.Lock()
				defer s.Unlock()
				if s.closed {
					return
				}
				defer s.flush()
				if fw := s.mainfw; fw != nil {
					fw.AddFragments(reliable, split(bs)...)
				}
			}
		})
	}
}
Example #7
0
func (h *streamHandler) onPublish(callback float64, r *amf0.Reader) error {
	if err := h.disenage(); err != nil {
		return errors.New("stream.onPublish.disenage")
	}
	if stream, err := r.ReadString(); err != nil {
		return errors.New("stream.onPublish.read stream")
	} else {
		if p := newPublication(stream); p.start(h) {
			if err := h.newPublishSuccessResponse(stream, callback); err != nil {
				return errors.New("stream.onPublish.publish response")
			}
			h.publish.p, h.unstable = p, !p.reliable
			h.publish.callback = callback
			if !p.rpc {
				call := func(x *streamHandler) {
					s := x.session
					s.Lock()
					defer s.Unlock()
					if s.closed || x.play.p != p {
						return
					}
					defer s.flush()
					x.newPublishNotifyResponse(p.name, x.play.callback)
				}
				async.Call(p.gid, func() {
					if l, _ := p.list(); l != nil {
						for e := l.Front(); e != nil; e = e.Next() {
							call(e.Value.(*streamHandler))
						}
					}
				})
			}
		} else {
			if err := h.newPublishFailedResponse(stream, callback); err != nil {
				return errors.New("stream.onPublish.failed response")
			}
		}
		return nil
	}
}
Example #8
0
func (h *streamHandler) disenage() error {
	if p := h.play.p; p != nil {
		name, callback := p.name, h.play.callback
		h.play.p = nil
		p.remove(h)
		if err := h.newUnplayResponse(name, callback); err != nil {
			return err
		}
	}
	if p := h.publish.p; p != nil {
		name, callback := p.name, h.publish.callback
		h.publish.p, h.unstable = nil, false
		p.stop()
		if !p.rpc {
			call := func(x *streamHandler) {
				s := x.session
				s.Lock()
				defer s.Unlock()
				if s.closed || x.play.p != p {
					return
				}
				defer s.flush()
				x.newUnpublishNotifyResponse(p.name, x.play.callback)
			}
			async.Call(p.gid, func() {
				if l, _ := p.list(); l != nil {
					for e := l.Front(); e != nil; e = e.Next() {
						call(e.Value.(*streamHandler))
					}
				}
			})
		}
		if err := h.newUnpublishResponse(name, callback); err != nil {
			return err
		}
	}
	return nil
}
Example #9
0
func (h *connHandler) onRelay(callback float64, r *amf0.Reader) error {
	if pidss, err := r.ReadString(); err != nil {
		return errors.New("conn.onRelay.read pid")
	} else if pidbs, err := hex.DecodeString(pidss); err != nil || len(pidbs) != 0x20 {
		return errors.New("conn.onRelay.decode pid")
	} else if bs, err := newRelayMessage(h.session.pid, r.Bytes()); err != nil {
		return errors.New("conn.onRelay.generate response")
	} else {
		async.Call(uint64(h.session.xid), func() {
			if s := FindByPid(string(pidbs)); s != nil {
				s.Lock()
				defer s.Unlock()
				if s.closed {
					return
				}
				defer s.flush()
				if fw := s.mainfw; fw != nil {
					fw.AddFragments(true, split(bs)...)
				}
			}
		})
		return nil
	}
}