Beispiel #1
0
// Test multiple go routines - SEND
func BenchmarkMultipleGoRoutinesSend() {

	// SEND Phase
	// create a net.Conn, and pass that into Connect
	p := os.Getenv("STOMP_PORT")
	if p == "" {
		p = "61613"
	}
	nc, error := net.Dial("tcp", hap+p)
	if error != nil {
		log.Fatal(error)
	}
	// Connect
	ch := stompngo.Headers{"login", "guest", "passcode", "guest"}
	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}
	for i := 1; i <= nq; i++ {
		qn := fmt.Sprintf("%d", i)
		wgsend.Add(1)
		// All sending go routines share the same connection in this example
		go sendMessages(c, qname+qn, nmsgs, i)

	}
	wgsend.Wait()
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatal(error)
	}
	log.Println("Done with SENDs ....")
	wgboth.Done()
}
Beispiel #2
0
// Test multiple go routines - RECEIVE
func BenchmarkMultipleGoRoutinesRecv() {

	// RECEIVE Phase
	p := os.Getenv("STOMP_PORT")
	if p == "" {
		p = "61613"
	}
	nc2, error := net.Dial("tcp", hap+p)
	if error != nil {
		// Handle error properly
		log.Fatal(error)
	}
	// Connect
	ch := stompngo.Headers{"login", "guest", "passcode", "guest"}
	c, error := stompngo.Connect(nc2, ch)
	if error != nil {
		log.Fatal(error)
	}
	for i := 1; i <= nq; i++ {
		qn := fmt.Sprintf("%d", i)
		wgrecv.Add(1)
		// All receiving go routines share the same connection in this example
		go recMessages(c, qname+qn, i)
	}
	wgrecv.Wait()
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatal(error)
	}
	wgboth.Done()
}
Beispiel #3
0
// Test multiple go routines - SEND
func BenchmarkMultipleGoRoutinesSend() {

	// SEND Phase
	// create a net.Conn, and pass that into Connect
	nc, error := net.Dial("tcp", handp)
	if error != nil {
		log.Fatal(error)
	}
	// Connect
	ch := stompngo.Headers{"login", "guest", "passcode", "guest"}
	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}
	for i := 1; i <= nq; i++ {
		qn := fmt.Sprintf("%d", i)
		wgsend.Add(1)
		go sendMessages(c, qname+qn, nmsgs, i)

	}
	wgsend.Wait()
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatal(error)
	}
	log.Println("Done with SENDs ....")
	wgboth.Done()
}
Beispiel #4
0
// Test multiple go routines - RECEIVE
func BenchmarkMultipleGoRoutinesRecv() {

	// RECEIVE Phase
	nc2, error := net.Dial("tcp", handp)
	if error != nil {
		// Handle error properly
		log.Fatal(error)
	}
	// Connect
	ch := stompngo.Headers{"login", "guest", "passcode", "guest"}
	c, error := stompngo.Connect(nc2, ch)
	if error != nil {
		log.Fatal(error)
	}
	for i := 1; i <= nq; i++ {
		qn := fmt.Sprintf("%d", i)
		wgrecv.Add(1)
		go recMessages(c, qname+qn, i)
	}
	wgrecv.Wait()
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatal(error)
	}
	wgboth.Done()
}
func main() {

	n, e := net.Dial("tcp", net.JoinHostPort(h, p))
	if e != nil {
		log.Fatalln(e)
	}

	ch := stompngo.Headers{"accept-version", "1.2", "host", "localhost", "login", "gooduser", "passcode", "guest"}
	conn, e := stompngo.Connect(n, ch)
	if e != nil {
		log.Fatalln(e)
	}

	s := stompngo.Headers{"destination", dest}
	m := " message: "
	for i := 1; i <= 100; i++ {
		t := m + fmt.Sprintf("%d", i)
		e := conn.Send(s, t)
		if e != nil {
			log.Fatalln(e)
		}
		fmt.Println("send complete:", t)
	}

	e = conn.Disconnect(stompngo.Headers{})
	if e != nil {
		log.Fatalln(e)
	}

	e = n.Close()
	if e != nil {
		log.Fatalln(e)
	}
}
Beispiel #6
0
func main() {
	fmt.Println("Start...")

	p := os.Getenv("STOMP_PORT")
	if p == "" {
		p = "61613"
	}
	nc, error := net.Dial("tcp", hap+p)
	if error != nil {
		log.Fatal(error)
	}
	// Connect
	ch := stompngo.Headers{"login", "getter", "passcode", "recv1234"}
	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}
	for i := 1; i <= mq; i++ {
		qn := fmt.Sprintf("%d", i)
		wg.Add(1)
		go recMessages(c, qname+qn)
	}
	wg.Wait()
	select {
	case v := <-c.MessageData:
		fmt.Printf("frame1: %v\n", v)
	default:
		fmt.Println("Nothing to show")
	}
	fmt.Println("unsubs: starts")
	for i := 1; i <= mq; i++ {
		qn := fmt.Sprintf("%d", i)
		h := stompngo.Headers{"destination", qname + qn}
		fmt.Printf("unsubhdr: %v\n", h)
		error = c.Unsubscribe(h)
		if error != nil {
			log.Fatal(error)
		}
	}
	fmt.Printf("Num received: %d\n", numRecv)
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatal(error)
	}
	fmt.Println("done nc.Close()")
	nc.Close()
	ngor := runtime.NumGoroutine()
	fmt.Printf("egor: %v\n", ngor)
	select {
	case v := <-c.MessageData:
		fmt.Printf("frame2: %v\n", v)
	default:
		fmt.Println("Nothing to show")
	}
	fmt.Println("End...")
}
func main() {

	n, e := net.Dial("tcp", net.JoinHostPort(h, p))
	if e != nil {
		log.Fatalln(e)
	}
	ch := stompngo.Headers{"accept-version", "1.2", "host", "localhost", "login", "gooduser", "passcode", "guest"}
	conn, e := stompngo.Connect(n, ch)
	if e != nil {
		log.Fatalln(e)
	}

	u := stompngo.Uuid()
	s := stompngo.Headers{"destination", dest, "id", u}

	r, e := conn.Subscribe(s)
	if e != nil {
		log.Fatalln(e) // Handle this ...
	}

	// Read data from the returned channel
	for i := 1; i <= 10000; i++ {
		m := <-r
		if m.Error != nil {
			log.Fatalln(m.Error)
		}
		//
		fmt.Printf("Frame Type: %s\n", m.Message.Command)
		if m.Message.Command != stompngo.MESSAGE {
			log.Fatalln(m)
		}
		h := m.Message.Headers
		for j := 0; j < len(h)-1; j += 2 {
			fmt.Printf("Header: %s:%s\n", h[j], h[j+1])
		}
		fmt.Printf("Payload: %s\n", string(m.Message.Body))

		if h.Value("subscription") != u {
			fmt.Printf("Error condition, expected [%s], received [%s]\n", u, h.Value("subscription"))
			log.Fatalln("Bad subscription header")
		}
	}

	e = conn.Unsubscribe(s)
	if e != nil {
		log.Fatalln(e)
	}

	e = conn.Disconnect(stompngo.Headers{})
	if e != nil {
		log.Fatalln(e)
	}
	e = n.Close()
	if e != nil {
		log.Fatalln(e)
	}
}
// Common example connect logic
func CommonConnect(exampid, tag string, l *log.Logger) (net.Conn,
	*stompngo.Connection,
	error) {

	l.Printf("%stag:%s consess:%v common_connect_starts\n",
		exampid, tag, Lcs)

	// Set up the connection.
	h, p := senv.HostAndPort()
	hap := net.JoinHostPort(h, p)
	n, e := net.Dial("tcp", hap)
	if e != nil {
		return nil, nil, e
	}

	l.Printf("%stag:%s connsess:%s common_connect_host_and_port:%v\n",
		exampid, tag, Lcs,
		hap)

	// Create connect headers and connect to stompngo
	ch := ConnectHeaders()
	l.Printf("%stag:%s connsess:%s common_connect_headers headers:%v\n",
		exampid, tag, Lcs,
		ch)
	conn, e := stompngo.Connect(n, ch)
	if e != nil {
		return nil, conn, e
	}
	l.Printf("%stag:%s connsess:%s common_connect_complete host:%s port:%s vhost:%s protocol:%s server:%s\n",
		exampid, tag, conn.Session(),
		h, p, senv.Vhost(), conn.Protocol(), ServerIdent(conn))

	// Show connect response
	l.Printf("%stag:%s connsess:%s common_connect_response connresp:%v\n",
		exampid, tag, conn.Session(),
		conn.ConnectResponse)

	// Heartbeat Data
	l.Printf("%stag:%s connsess:%s common_connect_heart_beat_send hbsend:%d\n",
		exampid, tag, conn.Session(),
		conn.SendTickerInterval())
	l.Printf("%stag:%s connsess:%s common_connect_heart_beat_recv hbrecv:%d\n",
		exampid, tag, conn.Session(),
		conn.ReceiveTickerInterval())

	l.Printf("%stag:%s connsess:%s common_connect_local_addr:%s\n",
		exampid, tag, conn.Session(),
		n.LocalAddr().String())
	l.Printf("%stag:%s connsess:%s common_connect_remote_addr:%s\n",
		exampid, tag, conn.Session(),
		n.RemoteAddr().String())

	//
	return n, conn, nil
}
Beispiel #9
0
func main() {
	fmt.Println("Start...")

	//
	nc, error := net.Dial("tcp", hap+os.Getenv("STOMP_PORT"))
	if error != nil {
		log.Fatal(error)
	}

	// Connectionect
	ch := stompngo.Headers{"login", "putter", "passcode", "send1234",
		"accept-version", "1.1", "host", host}

	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}

	for i := 1; i <= mq; i++ {
		qn := fmt.Sprintf("%d", i)
		wg.Add(1)
		go sendMessages(c, qname+qn, nmsgs, i)

	}
	wg.Wait()
	fmt.Println("done with wait")

	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatal(error)
	}

	fmt.Println("done disconnect, start nc.Close()")
	nc.Close()

	fmt.Println("done nc.Close()")

	ngor := runtime.NumGoroutine()
	fmt.Printf("egor: %v\n", ngor)

	select {
	case v := <-c.MessageData:
		fmt.Printf("frame2: %v\n", v)
	default:
		fmt.Println("Nothing to show")
	}
	fmt.Println("End... mq:", mq, " nmsgs:", nmsgs)
}
Beispiel #10
0
func main() {
	fmt.Println("Receiver Start...")

	// create a net.Conn, and pass that into Connect
	p := os.Getenv("STOMP_PORT")
	if p == "" {
		p = "61613"
	}
	nc, error := net.Dial("tcp", hap+p)
	if error != nil {
		log.Fatal(error)
	}
	// Connect
	ch := stompngo.Headers{"login", "getter", "passcode", "recv1234"}
	ch = ch.Add("accept-version", "1.0") // 1.0 only
	ch = ch.Add("host", host)
	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}
	for i := 1; i <= mq; i++ {
		qn := fmt.Sprintf("%d", i)
		wg.Add(1)
		go recMessages(c, qname+qn)
	}
	wg.Wait()
	fmt.Println("Receiver done with wait")
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatalf("Receiver discerr %v\n", error)
	}
	// Sanity check for spurious errors
	select {
	case v := <-c.MessageData:
		fmt.Printf("Receiver frame2: %s\n", v.Message.Command)
		fmt.Printf("Receiver header2: %v\n", v.Message.Headers)
		fmt.Printf("Receiver data2: %s\n", string(v.Message.Body))
	default:
		fmt.Println("Receiver Nothing to show")
	}
	// Network close
	nc.Close()
	fmt.Println("Receiver done nc.Close()")
	ngor := runtime.NumGoroutine()
	fmt.Printf("Receiver ngor: %v\n", ngor)
	fmt.Println("Receiver End... numq:", mq, "Num received:", numRecv)
}
Beispiel #11
0
func main() {
	fmt.Println("Sender Start...")

	//
	p := os.Getenv("STOMP_PORT")
	if p == "" {
		p = "61613"
	}
	nc, error := net.Dial("tcp", hap+p)
	if error != nil {
		// Handle error properly
	}
	// Connect
	ch := stompngo.Headers{"login", "putter", "passcode", "send1234",
		"accept-version", "1.1", "host", host}
	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}
	for i := 1; i <= mq; i++ {
		qn := fmt.Sprintf("%d", i)
		wg.Add(1)
		go sendMessages(c, qname+qn, nmsgs, i)

	}
	wg.Wait()
	fmt.Println("Sender done with wait")
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatalf("Sender discerr %v\n", error)
	}
	// Sanity check for spurious errors.
	select {
	case v := <-c.MessageData:
		fmt.Printf("frame2: %v\n", v)
	default:
		fmt.Println("Sender Nothing to show")
	}
	fmt.Println("Sender done disconnect, start nc.Close()")
	// Network close
	nc.Close()
	fmt.Println("Sender done nc.Close()")
	ngor := runtime.NumGoroutine()
	fmt.Printf("Sender ngor: %v\n", ngor)
	fmt.Println("Sender End... numq:", mq, "Num sent:", numSend)
}
Beispiel #12
0
func Handle(handler func(xml []byte)) {
	n, err := net.Dial("tcp", net.JoinHostPort(JmsHost, JmsPort))
	CheckErr(err)
	ch := stompngo.Headers{"accept-version", "1.1", "host", JmsVHost}
	conn, err := stompngo.Connect(n, ch)
	CheckErr(err)

	s := stompngo.Headers{"destination", JmsDest, "id", JmsId}

	r, e := conn.Subscribe(s)
	if e != nil {
		log.Fatalln(e)
	}

	func() {
		for {
			select {
			case m := <-r:
				if m.Error != nil {
					log.Fatalln(m.Error)
				}
				if m.Message.Command != stompngo.MESSAGE {
					log.Fatalln(m)
				}

				err := hand(handler, m.Message.Body)
				if err != nil {
					log.Fatalln(err)
					continue
				}

			case <-time.After(600 * time.Second):
				println("timeout")
				return
			}
		}
	}()
	err = conn.Unsubscribe(s)
	CheckErr(err)

	err = conn.Disconnect(stompngo.Headers{})
	CheckErr(err)

	err = n.Close()
	CheckErr(err)
}
Beispiel #13
0
func main() {
	fmt.Println("Start...")

	// create a net.Conn, and pass that into Connect
	nc, error := net.Dial("tcp", hap+os.Getenv("STOMP_PORT"))
	if error != nil {
		log.Fatal(error)
	}
	// Connect
	ch := stompngo.Headers{"login", "getter", "passcode", "recv1234"}
	ch = ch.Add("accept-version", "1.1")
	ch = ch.Add("host", host)
	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}
	for i := 1; i <= mq; i++ {
		qn := fmt.Sprintf("%d", i)
		wg.Add(1)
		go recMessages(c, qname+qn)
	}
	wg.Wait()
	fmt.Printf("Num received: %d\n", numRecv)
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatalf("discerr %v\n", error)
	}
	fmt.Println("done nc.Close()")
	nc.Close()
	ngor := runtime.NumGoroutine()
	fmt.Printf("egor: %v\n", ngor)
	select {
	case v := <-c.MessageData:
		fmt.Printf("frame2: %s\n", v.Message.Command)
		fmt.Printf("header2: %v\n", v.Message.Headers)
		fmt.Printf("data2: %s\n", string(v.Message.Body))
	default:
		fmt.Println("Nothing to show")
	}
	fmt.Println("End... mq:", mq)
}
Beispiel #14
0
func main() {

	// create a net.Conn, and pass that into Connect
	nc, error := net.Dial("tcp", hap+os.Getenv("STOMP_PORT"))
	if error != nil {
		// Handle error properly
	}
	// Connect
	ch := stompngo.Headers{"login", "guest", "passcode", "guest",
		"accept-version", "1.1", "host", host}
	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}
	sh := stompngo.Headers{"destination", qname}
	for i := 1; i <= nmsgs; i++ {
		msg := "subrecv message " + fmt.Sprintf("%d", i)
		error = c.Send(sh, msg)
		if error != nil {
			log.Fatal(error)
		}
		fmt.Printf("Sent message: %s\n", msg)
	}
	sc, error := c.Subscribe(sh)
	if error != nil {
		log.Fatal(error)
	}
	subid := ""
	i := 1
	for {
		// Sanity check.  Any unanticipated ERROR frames?
		select {
		case v := <-c.MessageData:
			log.Fatalf("frame1: %v\n", v)
		default:
			fmt.Println("Nothing to show - 1")
		}
		fmt.Println("Start receive ....")
		d := <-sc
		// fmt.Printf("d: %v\n", d)
		if d.Error != nil {
			log.Fatal(d.Error)
		}
		if i == 1 {
			subid = d.Message.Headers.Value("subscription")
			fmt.Printf("Subscription is: %s\n", subid)
		}
		//
		fmt.Printf("Received message: %s\n", d.Message.BodyString())
		i++
		if i > nmsgs {
			break
		}
	}
	uh := stompngo.Headers{"destination", qname, "id", subid}
	error = c.Unsubscribe(uh)
	if error != nil {
		log.Fatal(error)
	}
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatal(error)
	}
	// Sanity check.  Any unanticipated ERROR frames?
	select {
	case v := <-c.MessageData:
		log.Fatalf("frame2: %v\n", v)
	default:
		fmt.Println("Nothing to show - 2")
	}
	fmt.Println("done disconnect, start nc.Close()")
	nc.Close()
	fmt.Println("done nc.Close()")

}
Beispiel #15
0
		err := m.conn.Disconnect(stompngo.Headers{})
		if err != nil {
			return err
		}
		m.conn = nil
	}

	if m.netConn != nil {
		m.netConn.Close()
	}

	return nil
}

var getStompConn = func(n net.Conn, h stompngo.Headers) (connectioner, error) {
	return stompngo.Connect(n, h)
}

func (m *Mediator) Read() (stompngo.MessageData, error) {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.conn.Connected() {
		return <-m.sub, nil
	}

	return stompngo.MessageData{}, ErrNotConnected
}

func (m *Mediator) ReadAsync() <-chan stompngo.MessageData {
	out := make(chan stompngo.MessageData, 1)
Beispiel #16
0
func main() {

	// create a net.Conn, and pass that into Connect
	p := os.Getenv("STOMP_PORT")
	if p == "" {
		p = "61613"
	}
	nc, error := net.Dial("tcp", hap+p)
	if error != nil {
		// Handle error properly
	}
	// Connect
	ch := stompngo.Headers{"login", "guest", "passcode", "guest",
		"accept-version", "1.1", "host", host}
	c, error := stompngo.Connect(nc, ch)
	if error != nil {
		log.Fatal(error)
	}
	sh := stompngo.Headers{"destination", qname}
	for i := 1; i <= nmsgs; i++ {
		msg := "subrecv message " + fmt.Sprintf("%d", i)
		error = c.Send(sh, msg)
		if error != nil {
			log.Fatal(error)
		}
		fmt.Printf("Sent message: %s\n", msg)
	}
	// No 'id' header is present -> the stompngo client library creates one.
	// The assigned subscription id must be determined from subsequent traffic.
	sc, error := c.Subscribe(sh)
	if error != nil {
		log.Fatal(error)
	}
	subid := ""
	i := 1
	for {
		// Sanity check.  Any unanticipated ERROR frames?
		select {
		case v := <-c.MessageData:
			log.Fatalf("frame1: %v\n", v)
		default:
			fmt.Println("Nothing to show - 1")
		}
		fmt.Println("Start receive ....")
		d := <-sc
		// fmt.Printf("d: %v\n", d)
		if d.Error != nil {
			log.Fatal(d.Error)
		}
		// Save the subscription id in use for the eventual UNSUBSCRIBE.
		if i == 1 {
			subid = d.Message.Headers.Value("subscription")
			fmt.Printf("Subscription is: %s\n", subid)
		}
		//
		fmt.Printf("Received message: %s\n", d.Message.BodyString())
		i++
		if i > nmsgs {
			break
		}
	}
	uh := stompngo.Headers{"destination", qname, "id", subid} // Unsubscribe headers
	error = c.Unsubscribe(uh)
	if error != nil {
		log.Fatal(error)
	}
	// Disconnect
	nh := stompngo.Headers{}
	error = c.Disconnect(nh)
	if error != nil {
		log.Fatal(error)
	}
	// Sanity check.  Any unanticipated ERROR frames?
	select {
	case v := <-c.MessageData:
		log.Fatalf("frame2: %v\n", v)
	default:
		fmt.Println("Nothing to show - 2")
	}
	fmt.Println("done disconnect, start nc.Close()")
	nc.Close()
	fmt.Println("done nc.Close()")

}
Beispiel #17
0
// Common example TLS connect logic
func CommonTLSConnect(exampid, tag string, l *log.Logger,
	c *tls.Config) (net.Conn, *stompngo.Connection, error) {

	l.Printf("%stag:%s consess:%s common_tls_connect_starts\n",
		exampid, tag, Lcs)

	// Set up the connection.
	h, p := senv.HostAndPort()
	hap := net.JoinHostPort(h, p)
	n, e := net.Dial("tcp", hap)
	if e != nil {
		return nil, nil, e
	}

	c.ServerName = h // SNI

	nc := tls.Client(n, c) // Returns: *tls.Conn : implements net.Conn
	e = nc.Handshake()
	if e != nil {
		if e.Error() == "EOF" {
			l.Printf("%stag:%s consess:%s common_tls_handshake_EOF_Is_the_broker_port_TLS_enabled? port:%s\n",
				exampid, tag, Lcs,
				p)
		}
		l.Fatalf("%stag:%s consess:%s common_tls_handshake_failed error:%v\n",
			exampid, tag, Lcs,
			e.Error())
	}
	l.Printf("%stag:%s consess:%s common_tls_handshake_complete\n",
		exampid, tag, Lcs)

	l.Printf("%stag:%s connsess:%s common_tls_connect_host_and_port:%v\n",
		exampid, tag, Lcs,
		hap)

	// Create connect headers and connect to stompngo
	ch := ConnectHeaders()
	l.Printf("%stag:%s connsess:%s common_tls_connect_headers headers:%v\n",
		exampid, tag, Lcs,
		ch)
	conn, e := stompngo.Connect(nc, ch)
	if e != nil {
		return nil, nil, e
	}
	l.Printf("%stag:%s connsess:%s common_tls_connect_complete host:%s vhost:%s protocol:%s server:%s\n",
		exampid, tag, conn.Session(),
		h, senv.Vhost(), conn.Protocol(), ServerIdent(conn))

	// Show connect response
	l.Printf("%stag:%s connsess:%s common_tls_connect_response connresp:%v\n",
		exampid, tag, conn.Session(),
		conn.ConnectResponse)

	// Show heartbeat data (if heart beats are being used)
	if senv.Heartbeats() != "" {
		l.Printf("%stag:%s connsess:%s common_tls_connect_heart_beat_send hbsend:%v\n",
			exampid, tag, conn.Session(),
			conn.SendTickerInterval())
		l.Printf("%stag:%s connsess:%s common_tls_connect_heart_beat_recv hbrecv:%v\n",
			exampid, tag, conn.Session(),
			conn.ReceiveTickerInterval())
	}

	l.Printf("%stag:%s connsess:%s common_tls_connect_local_addr:%s\n",
		exampid, tag, conn.Session(),
		n.LocalAddr().String())
	l.Printf("%stag:%s connsess:%s common_tls_connect_remote_addr:%s\n",
		exampid, tag, conn.Session(),
		n.RemoteAddr().String())

	//
	return nc, conn, nil
}