fts/websocket/websocket.go

package websocket

import (
	"encoding/json"
	"fts/handle"
	"github.com/gorilla/websocket"
	"log"
	"net/http"
	"strconv"
	"strings"
)

var(
	upgrader = websocket.Upgrader{
		//允许跨域访问
		CheckOrigin: func(r *http.Request) bool {
			return true
		},
	}
)

func UploadHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param uploadHandler:"+string(data))

		params :=strings.Split(string(data),"|")
		mil,_:=strconv.ParseBool(params[7])
		err := handle.UploadCommand(conn,params[0],params[1],params[2],params[3],params[4],params[5],params[6],mil)
		if err!=nil{
			log.Println(err)
			goto ERR
		}
		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}

func DownloadHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param downloadHandler:"+string(data))

		params :=strings.Split(string(data),"|")
		err := handle.DownCommand(conn,params[0],params[1],params[2],params[3])
		if err!=nil{
			log.Println(err)
			goto ERR
		}

		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}

func InitLocalWorkSpaceHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param initLocalWorkSpaceHandler:"+string(data))

		params :=strings.Split(string(data),"|")
		//userId = "367294106252087297"
		err := handle.InitLocalWorkSpace(conn,params[0],params[1],params[2])
		if err!=nil{
			log.Println(err)
			goto ERR
		}

		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}

func OpenFileWithHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param OpenFileWithHandler:"+string(data))

		err := handle.OpenFileWith(string(data))
		if err!=nil{
			log.Println(err)
			if err := conn.WriteMessage(websocket.TextMessage, []byte("-1")); err != nil {
				log.Println(err)
				goto ERR
			}
			goto ERR
		}

		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}

func CheckForUpdatesHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param CheckForUpdatesHandler:"+string(data))

		err := handle.CheckForUpdates(string(data))
		if err!=nil{
			log.Println(err)
			if err := conn.WriteMessage(websocket.TextMessage, []byte("-1")); err != nil {
				log.Println(err)
				goto ERR
			}
			goto ERR
		}

		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}

func InitClientConfigHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param InitClientConfigHandler:"+string(data))
		params :=strings.Split(string(data),"|")
		err := handle.InitClientConfig(params[0],params[1])
		if err!=nil{
			log.Println(err)
			if err := conn.WriteMessage(websocket.TextMessage, []byte("-1")); err != nil {
				log.Println(err)
				goto ERR
			}
			goto ERR
		}

		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}

func GetFolderFileInfoHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param GetFolderFileInfo:"+string(data))

		err := handle.GetFolderFileInfo(conn,string(data))
		if err!=nil{
			log.Println(err)
			goto ERR
		}

		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}

func EditCommitHistoryMilestoneHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param EditCommitHistoryMilestoneHandler:"+string(data))
		params := strings.Split(string(data),"|")
		mil,_:=strconv.ParseBool(params[3])
		hash,err := handle.EditCommitHistoryMilestoneHandler(params[0],params[1],params[2],mil)
		if err!=nil{
			log.Println(err)
			if err := conn.WriteMessage(websocket.TextMessage, []byte("-1")); err != nil {
				log.Println(err)
				goto ERR
			}
		}else{
			if err := conn.WriteMessage(websocket.TextMessage, []byte(hash)); err != nil {
				log.Println(err)
				goto ERR
			}
		}

		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}

func SubscriptionFileChangeHandler(w http.ResponseWriter, r *http.Request){
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//log.Println("param subscriptionFileChangeHandler:"+string(data))
		err = handle.SubscriptionFileChange(conn,string(data))

		if err != nil {
			//报错了
			log.Println(err)
			goto ERR
		}
		goto ERR
	}
	//error的标签
ERR:
	conn.Close()}



var  IsKeeplive bool = false //客户端是否存活
func KeepliveHandler(w http.ResponseWriter, r *http.Request){
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	IsKeeplive = true
	var (
		conn *websocket.Conn
		err error
		//msgType int
		//data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		log.Println(err)
		return
	}

	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, _, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			log.Println(err)
			goto ERR
		}
		IsKeeplive = true
		//goto ERR
	}
	//error的标签
ERR:
	conn.Close()

}

//消息通知
func MessageNotifyHandler(w http.ResponseWriter, r *http.Request){
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		//data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}

	//读取通道消息
	for msg := range handle.GobalMessageNotify {
		if err := conn.WriteMessage(websocket.TextMessage, []byte(msg)); err != nil {
			log.Println(err)
			goto ERR
		}
	}
	//error的标签
ERR:
	conn.Close()
}

//查询历史版本记录
func QueryCommitHistoryHandler(w http.ResponseWriter, r *http.Request) {
	//w.Write([]byte("hello"))
	//收到http请求(upgrade),完成websocket协议转换
	//在应答的header中放上upgrade:websoket
	var (
		conn *websocket.Conn
		err error
		//msgType int
		data []byte
	)
	if conn, err = upgrader.Upgrade(w, r, nil); err !=nil {
		//报错了，直接返回底层的websocket链接就会终断掉
		return
	}
	//得到了websocket.Conn长连接的对象，实现数据的收发
	for {
		//Text(json), Binary
		//if _, data, err = conn.ReadMessage(); err != nil {
		if _, data, err = conn.ReadMessage(); err != nil {
			//报错关闭websocket
			goto ERR
		}
		//发送数据，判断返回值是否报错
		//eg: 文件路径|历史版本文件Hash
		dataString := string(data)
		//log.Println("param QueryCommitHistoryHandler:"+dataString)
		params := strings.Split(dataString,"|")

		dataList,err := handle.QueryCommitHistory(params[0],params[1])
		if err!=nil{
			log.Println(err)
			if err := conn.WriteMessage(websocket.TextMessage, []byte("-1")); err != nil {
				log.Println(err)
			}
			goto ERR
		}else{
			result,_ :=json.Marshal(dataList)

			if err := conn.WriteMessage(websocket.TextMessage, result); err != nil {
				log.Println(err)
			}
			goto ERR
		}

		goto ERR
	}
	//error的标签
ERR:
	conn.Close()
}




func main() {


}