Merge pull request #8 from weave-lab/master

add sendevent

Author: 0x19

client.go

@@ -9,6 +9,9 @@ package goesl
 import (
 	"bufio"
 	"fmt"
+	"io"
+	"net"
+	"strconv"
 	"time"
 )
 
@@ -26,45 +29,49 @@ type Client struct {
 // EstablishConnection - Will attempt to establish connection against freeswitch and create new SocketConnection
 func (c *Client) EstablishConnection() error {
 	conn, err := c.Dial(c.Proto, c.Addr, time.Duration(c.Timeout*int(time.Second)))
+	if err != nil {
+		return err
+	}
 
 	c.SocketConnection = SocketConnection{
 		Conn: conn,
 		err:  make(chan error),
 		m:    make(chan *Message),
 	}
 
-	return err
+	return nil
 }
 
 // Authenticate - Method used to authenticate client against freeswitch. In case of any errors durring so
 // we will return error.
 func (c *Client) Authenticate() error {
 
 	m, err := newMessage(bufio.NewReaderSize(c, ReadBufferSize), false)
-
 	if err != nil {
 		Error(ECouldNotCreateMessage, err)
 		return err
 	}
 
 	cmr, err := m.tr.ReadMIMEHeader()
-
-	Debug("A: %v %v ", cmr, err)
-
 	if err != nil && err.Error() != "EOF" {
 		Error(ECouldNotReadMIMEHeaders, err)
 		return err
 	}
 
+	Debug("A: %v\n", cmr)
+
 	if cmr.Get("Content-Type") != "auth/request" {
 		Error(EUnexpectedAuthHeader, cmr.Get("Content-Type"))
 		return fmt.Errorf(EUnexpectedAuthHeader, cmr.Get("Content-Type"))
 	}
 
-	fmt.Fprintf(c, "auth %s\r\n\r\n", c.Passwd)
+	s := "auth " + c.Passwd + "\r\n\r\n"
+	_, err = io.WriteString(c, s)
+	if err != nil {
+		return err
+	}
 
 	am, err := m.tr.ReadMIMEHeader()
-
 	if err != nil && err.Error() != "EOF" {
 		Error(ECouldNotReadMIMEHeaders, err)
 		return err
@@ -80,22 +87,24 @@ func (c *Client) Authenticate() error {
 
 // NewClient - Will initiate new client that will establish connection and attempt to authenticate
 // against connected freeswitch server
-func NewClient(host string, port uint, passwd string, timeout int) (Client, error) {
+func NewClient(host string, port uint, passwd string, timeout int) (*Client, error) {
 	client := Client{
 		Proto:   "tcp", // Let me know if you ever need this open up lol
-		Addr:    fmt.Sprintf("%s:%d", host, port),
+		Addr:    net.JoinHostPort(host, strconv.Itoa(int(port))),
 		Passwd:  passwd,
 		Timeout: timeout,
 	}
 
-	if err := client.EstablishConnection(); err != nil {
-		return client, err
+	err := client.EstablishConnection()
+	if err != nil {
+		return nil, err
 	}
 
-	if err := client.Authenticate(); err != nil {
+	err = client.Authenticate()
+	if err != nil {
 		client.Close()
-		return client, err
+		return nil, err
 	}
 
-	return client, nil
+	return &client, nil
 }

connection.go

@@ -10,9 +10,11 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
+	"io"
 	"net"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -21,6 +23,7 @@ type SocketConnection struct {
 	net.Conn
 	err chan error
 	m   chan *Message
+	mtx sync.Mutex
 }
 
 // Dial - Will establish timedout dial against specified address. In this case, it will be freeswitch server
@@ -32,10 +35,22 @@ func (c *SocketConnection) Dial(network string, addr string, timeout time.Durati
 func (c *SocketConnection) Send(cmd string) error {
 
 	if strings.Contains(cmd, "\r\n") {
-		fmt.Errorf(EInvalidCommandProvided, cmd)
+		return fmt.Errorf(EInvalidCommandProvided, cmd)
 	}
 
-	fmt.Fprintf(c, "%s\r\n\r\n", cmd)
+	// lock mutex
+	c.mtx.Lock()
+	defer c.mtx.Unlock()
+
+	_, err := io.WriteString(c, cmd)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.WriteString(c, "\r\n\r\n")
+	if err != nil {
+		return err
+	}
 
 	return nil
 }
@@ -52,6 +67,42 @@ func (c *SocketConnection) SendMany(cmds []string) error {
 	return nil
 }
 
+// SendEvent - Will loop against passed event headers
+func (c *SocketConnection) SendEvent(eventHeaders []string) error {
+	if len(eventHeaders) <= 0 {
+		return fmt.Errorf(ECouldNotSendEvent, len(eventHeaders))
+	}
+
+	// lock mutex to prevent event headers from conflicting
+	c.mtx.Lock()
+	defer c.mtx.Unlock()
+
+	_, err := io.WriteString(c, "sendevent ")
+	if err != nil {
+		return err
+	}
+
+	for _, eventHeader := range eventHeaders {
+		_, err := io.WriteString(c, eventHeader)
+		if err != nil {
+			return err
+		}
+
+		_, err = io.WriteString(c, "\r\n")
+		if err != nil {
+			return err
+		}
+
+	}
+
+	_, err = io.WriteString(c, "\r\n")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // Execute - Helper fuck to execute commands with its args and sync/async mode
 func (c *SocketConnection) Execute(command, args string, sync bool) (m *Message, err error) {
 	return c.SendMsg(map[string]string{
@@ -107,9 +158,14 @@ func (c *SocketConnection) SendMsg(msg map[string]string, uuid, data string) (m
 		b.WriteString(data)
 	}
 
-	if _, err := b.WriteTo(c); err != nil {
+	// lock mutex
+	c.mtx.Lock()
+	_, err = b.WriteTo(c)
+	if err != nil {
+		c.mtx.Unlock()
 		return nil, err
 	}
+	c.mtx.Unlock()
 
 	select {
 	case err := <-c.err:

errors.go

@@ -20,4 +20,5 @@ var (
 	EUnexpectedAuthHeader    = "Expected auth/request content type. Got %s"
 	EInvalidPassword         = "Could not authenticate against freeswitch with provided password: %s"
 	ECouldNotCreateMessage   = "Error while creating new message: %s"
+	ECouldNotSendEvent       = "Must send at least one event header, detected `%d` header"
 )

helpers.go

@@ -6,11 +6,9 @@
 
 package goesl
 
-import "fmt"
-
 // Set - Helper that you can use to execute SET application against active ESL session
 func (sc *SocketConnection) ExecuteSet(key string, value string, sync bool) (m *Message, err error) {
-	return sc.Execute("set", fmt.Sprintf("%s=%s", key, value), sync)
+	return sc.Execute("set", key+"="+value, sync)
 }
 
 // ExecuteHangup - Helper desgned to help with executing Answer against active ESL session
@@ -29,12 +27,12 @@ func (sc *SocketConnection) ExecuteHangup(uuid string, args string, sync bool) (
 
 // BgApi - Helper designed to attach api in front of the command so that you do not need to write it
 func (sc *SocketConnection) Api(command string) error {
-	return sc.Send(fmt.Sprintf("api %s", command))
+	return sc.Send("api " + command)
 }
 
 // BgApi - Helper designed to attach bgapi in front of the command so that you do not need to write it
 func (sc *SocketConnection) BgApi(command string) error {
-	return sc.Send(fmt.Sprintf("bgapi %s", command))
+	return sc.Send("bgapi " + command)
 }
 
 // Connect - Helper designed to help you handle connection. Each outbound server when handling needs to connect e.g. accept