Modular 、Functional enhancement

lib/cache/lru.go

@@ -0,0 +1,102 @@
+package cache
+
+import (
+	"container/list"
+	"sync"
+)
+
+// Cache is an LRU cache. It is safe for concurrent access.
+type Cache struct {
+	// MaxEntries is the maximum number of cache entries before
+	// an item is evicted. Zero means no limit.
+	MaxEntries int
+
+	//Execute this callback function when an element is culled
+	OnEvicted func(key Key, value interface{})
+
+	ll    *list.List //list
+	cache sync.Map
+}
+
+// A Key may be any value that is comparable. See http://golang.org/ref/spec#Comparison_operators
+type Key interface{}
+
+type entry struct {
+	key   Key
+	value interface{}
+}
+
+// New creates a new Cache.
+// If maxEntries is 0, the cache has no length limit.
+// that eviction is done by the caller.
+func New(maxEntries int) *Cache {
+	return &Cache{
+		MaxEntries: maxEntries,
+		ll:         list.New(),
+		//cache:      make(map[interface{}]*list.Element),
+	}
+}
+
+// If the key value already exists, move the key to the front
+func (c *Cache) Add(key Key, value interface{}) {
+	if ee, ok := c.cache.Load(key); ok {
+		c.ll.MoveToFront(ee.(*list.Element)) // move to the front
+		ee.(*list.Element).Value.(*entry).value = value
+		return
+	}
+	ele := c.ll.PushFront(&entry{key, value})
+	c.cache.Store(key, ele)
+	if c.MaxEntries != 0 && c.ll.Len() > c.MaxEntries { // Remove the oldest element if the limit is exceeded
+		c.RemoveOldest()
+	}
+}
+
+// Get looks up a key's value from the cache.
+func (c *Cache) Get(key Key) (value interface{}, ok bool) {
+	if ele, hit := c.cache.Load(key); hit {
+		c.ll.MoveToFront(ele.(*list.Element))
+		return ele.(*list.Element).Value.(*entry).value, true
+	}
+	return
+}
+
+// Remove removes the provided key from the cache.
+func (c *Cache) Remove(key Key) {
+	if ele, hit := c.cache.Load(key); hit {
+		c.removeElement(ele.(*list.Element))
+	}
+}
+
+// RemoveOldest removes the oldest item from the cache.
+func (c *Cache) RemoveOldest() {
+	ele := c.ll.Back()
+	if ele != nil {
+		c.removeElement(ele)
+	}
+}
+
+func (c *Cache) removeElement(e *list.Element) {
+	c.ll.Remove(e)
+	kv := e.Value.(*entry)
+	c.cache.Delete(kv.key)
+	if c.OnEvicted != nil {
+		c.OnEvicted(kv.key, kv.value)
+	}
+}
+
+// Len returns the number of items in the cache.
+func (c *Cache) Len() int {
+	return c.ll.Len()
+}
+
+// Clear purges all stored items from the cache.
+func (c *Cache) Clear() {
+	if c.OnEvicted != nil {
+		c.cache.Range(func(key, value interface{}) bool {
+			kv := value.(*list.Element).Value.(*entry)
+			c.OnEvicted(kv.key, kv.value)
+			return true
+		})
+	}
+	c.ll = nil
+}

lib/common/const.go

@@ -13,6 +13,10 @@ const (
 	WORK_P2P          = "p2pm"
 	WORK_P2P_VISITOR  = "p2pv"
 	WORK_P2P_PROVIDER = "p2pp"
+	WORK_P2P_CONNECT  = "p2pc"
+	WORK_P2P_SUCCESS  = "p2ps"
+	WORK_P2P_END      = "p2pe"
+	WORK_P2P_LAST     = "p2pl"
 	WORK_STATUS       = "stus"
 	RES_MSG           = "msg0"
 	RES_CLOSE         = "clse"

lib/common/util.go

@@ -218,6 +218,7 @@ func GetPorts(p string) []int {
 	return ps
 }
 
+//is the string a port
 func IsPort(p string) bool {
 	pi, err := strconv.Atoi(p)
 	if err != nil {
@@ -229,6 +230,7 @@ func IsPort(p string) bool {
 	return true
 }
 
+//if the s is just a port,return 127.0.0.1:s
 func FormatAddress(s string) string {
 	if strings.Contains(s, ":") {
 		return s
@@ -236,6 +238,7 @@ func FormatAddress(s string) string {
 	return "127.0.0.1:" + s
 }
 
+//get address from the complete address
 func GetIpByAddr(addr string) string {
 	arr := strings.Split(addr, ":")
 	return arr[0]
@@ -279,6 +282,7 @@ func GetLocalUdpAddr() (net.Conn, error) {
 	return tmpConn, tmpConn.Close()
 }
 
+//parse template
 func ParseStr(str string) (string, error) {
 	tmp := template.New("npc")
 	var err error
@@ -305,6 +309,7 @@ func GetEnvMap() map[string]string {
 	return m
 }
 
+//throw the empty element of the string array
 func TrimArr(arr []string) []string {
 	newArr := make([]string, 0)
 	for _, v := range arr {
@@ -315,6 +320,7 @@ func TrimArr(arr []string) []string {
 	return newArr
 }
 
+//
 func IsArrContains(arr []string, val string) bool {
 	if arr == nil {
 		return false
@@ -327,6 +333,7 @@ func IsArrContains(arr []string, val string) bool {
 	return false
 }
 
+//remove value from string array
 func RemoveArrVal(arr []string, val string) []string {
 	for k, v := range arr {
 		if v == val {
@@ -337,6 +344,7 @@ func RemoveArrVal(arr []string, val string) []string {
 	return arr
 }
 
+//convert bytes to num
 func BytesToNum(b []byte) int {
 	var str string
 	for i := 0; i < len(b); i++ {
@@ -346,6 +354,7 @@ func BytesToNum(b []byte) int {
 	return int(x)
 }
 
+//get the length of the sync map
 func GeSynctMapLen(m sync.Map) int {
 	var c int
 	m.Range(func(key, value interface{}) bool {
@@ -354,3 +363,12 @@ func GeSynctMapLen(m sync.Map) int {
 	})
 	return c
 }
+
+func GetExtFromPath(path string) string {
+	s := strings.Split(path, ".")
+	re, err := regexp.Compile(`(\w+)`)
+	if err != nil {
+		return ""
+	}
+	return string(re.Find([]byte(s[0])))
+}

lib/conn/link.go

@@ -17,15 +17,17 @@ type Link struct {
 	Host       string //目标
 	Crypt      bool   //加密
 	Compress   bool
+	LocalProxy bool
 	RemoteAddr string
 }
 
-func NewLink(connType string, host string, crypt bool, compress bool, remoteAddr string) *Link {
+func NewLink(connType string, host string, crypt bool, compress bool, remoteAddr string, localProxy bool) *Link {
 	return &Link{
 		RemoteAddr: remoteAddr,
 		ConnType:   connType,
 		Host:       host,
 		Crypt:      crypt,
 		Compress:   compress,
+		LocalProxy: localProxy,
 	}
 }

lib/file/obj.go

@@ -48,6 +48,7 @@ type Client struct {
 	WebUserName     string     //the username of web login
 	WebPassword     string     //the password of web login
 	ConfigConnAllow bool       //is allow connected by config file
+	MaxTunnelNum    int
 	sync.RWMutex
 }
 
@@ -97,6 +98,17 @@ func (s *Client) HasTunnel(t *Tunnel) (exist bool) {
 	return
 }
 
+func (s *Client) GetTunnelNum() (num int) {
+	GetDb().JsonDb.Tasks.Range(func(key, value interface{}) bool {
+		v := value.(*Tunnel)
+		if v.Client.Id == s.Id {
+			num++
+		}
+		return true
+	})
+	return
+}
+
 func (s *Client) HasHost(h *Host) bool {
 	var has bool
 	GetDb().JsonDb.Hosts.Range(func(key, value interface{}) bool {
@@ -164,9 +176,10 @@ type Host struct {
 }
 
 type Target struct {
-	nowIndex  int
-	TargetStr string
-	TargetArr []string
+	nowIndex   int
+	TargetStr  string
+	TargetArr  []string
+	LocalProxy bool
 	sync.RWMutex
 }