package storage import ( "errors" "gopkg.in/yaml.v3" "sync" "tinyrdm/backend/types" sliceutil "tinyrdm/backend/utils/slice" ) type ConnectionsStorage struct { storage *localStorage mutex sync.Mutex } func NewConnections() *ConnectionsStorage { return &ConnectionsStorage{ storage: NewLocalStore("connections.yaml"), } } func (c *ConnectionsStorage) defaultConnections() []types.ConnectionGroup { return []types.ConnectionGroup{ { GroupName: "", Connections: []types.Connection{}, }, } } func (c *ConnectionsStorage) defaultConnectionItem() types.Connection { return types.Connection{ Name: "", Addr: "127.0.0.1", Port: 6379, Username: "", Password: "", DefaultFilter: "*", KeySeparator: ":", ConnTimeout: 60, ExecTimeout: 60, MarkColor: "", } } func (c *ConnectionsStorage) getConnections() (ret []types.ConnectionGroup) { b, err := c.storage.Load() if err != nil { ret = c.defaultConnections() return } if err = yaml.Unmarshal(b, &ret); err != nil { ret = c.defaultConnections() return } if len(ret) <= 0 { ret = c.defaultConnections() } //if !sliceutil.AnyMatch(ret, func(i int) bool { // return ret[i].GroupName == "" //}) { // ret = append(ret, c.defaultConnections()...) //} return } // GetConnections get all store connections from local func (c *ConnectionsStorage) GetConnections() (ret []types.ConnectionGroup) { c.mutex.Lock() defer c.mutex.Unlock() return c.getConnections() } // GetConnectionsFlat get all store connections from local flat(exclude group level) func (c *ConnectionsStorage) GetConnectionsFlat() (ret []types.Connection) { c.mutex.Lock() defer c.mutex.Unlock() conns := c.getConnections() for _, group := range conns { for _, conn := range group.Connections { ret = append(ret, conn) } } return } func (c *ConnectionsStorage) saveConnections(conns []types.ConnectionGroup) error { b, err := yaml.Marshal(&conns) if err != nil { return err } if err = c.storage.Store(b); err != nil { return err } return nil } // UpsertConnection update or insert a connection func (c *ConnectionsStorage) UpsertConnection(param types.Connection, replace bool) error { c.mutex.Lock() defer c.mutex.Unlock() conns := c.getConnections() groupIndex := -1 connIndex := -1 for i, group := range conns { for j, conn := range group.Connections { // check conflict connection name if conn.Name == param.Name { if !replace { return errors.New("duplicated connection name") } else { // different group name, should move group // remove from current group first if group.GroupName != param.Group { group.Connections = append(group.Connections[:j], group.Connections[j+1:]...) // find new group index groupIndex, _ = sliceutil.Find(conns, func(i int) bool { return conns[i].GroupName == param.Group }) } else { groupIndex = i connIndex = j } break } } } } if groupIndex >= 0 { // group exists if connIndex >= 0 { // connection exists conns[groupIndex].Connections[connIndex] = param } else { // new connection conns[groupIndex].Connections = append(conns[groupIndex].Connections, param) } } else { // new group group := types.ConnectionGroup{ GroupName: param.Group, Connections: []types.Connection{param}, } conns = append(conns, group) } return c.saveConnections(conns) } // RemoveConnection remove special connection func (c *ConnectionsStorage) RemoveConnection(group, name string) error { c.mutex.Lock() defer c.mutex.Unlock() conns := c.getConnections() for i, connGroup := range conns { if connGroup.GroupName == group { for j, conn := range connGroup.Connections { if conn.Name == name { connList := conns[i].Connections connList = append(connList[:j], connList[j+1:]...) conns[i].Connections = connList return c.saveConnections(conns) } } } } return errors.New("no match connection") } // UpsertGroup update or insert a group // When want to create group only, set group == param.name func (c *ConnectionsStorage) UpsertGroup(group string, param types.ConnectionGroup) error { c.mutex.Lock() defer c.mutex.Unlock() conns := c.getConnections() for i, connGroup := range conns { if connGroup.GroupName == group { conns[i].GroupName = param.GroupName return c.saveConnections(conns) } } // No match group, create one connGroup := types.ConnectionGroup{ GroupName: param.GroupName, Connections: []types.Connection{}, } conns = append(conns, connGroup) return c.saveConnections(conns) } // RemoveGroup remove special group, include all connections under it func (c *ConnectionsStorage) RemoveGroup(group string) error { c.mutex.Lock() defer c.mutex.Unlock() conns := c.getConnections() for i, connGroup := range conns { if connGroup.GroupName == group { conns = append(conns[:i], conns[i+1:]...) return c.saveConnections(conns) } } return errors.New("no match group") }