src/dma/vendor/github.com/go-redis/redis/parser.go

   1 package redis
   2
   3 import (
   4         "fmt"
   5         "net"
   6         "strconv"
   7         "time"
   8
   9         "github.com/go-redis/redis/internal/proto"
  10 )
  11
  12 // Implements proto.MultiBulkParse
  13 func sliceParser(rd *proto.Reader, n int64) (interface{}, error) {
  14         vals := make([]interface{}, 0, n)
  15         for i := int64(0); i < n; i++ {
  16                 v, err := rd.ReadReply(sliceParser)
  17                 if err != nil {
  18                         if err == Nil {
  19                                 vals = append(vals, nil)
  20                                 continue
  21                         }
  22                         if err, ok := err.(proto.RedisError); ok {
  23                                 vals = append(vals, err)
  24                                 continue
  25                         }
  26                         return nil, err
  27                 }
  28
  29                 switch v := v.(type) {
  30                 case []byte:
  31                         vals = append(vals, string(v))
  32                 default:
  33                         vals = append(vals, v)
  34                 }
  35         }
  36         return vals, nil
  37 }
  38
  39 // Implements proto.MultiBulkParse
  40 func boolSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
  41         bools := make([]bool, 0, n)
  42         for i := int64(0); i < n; i++ {
  43                 n, err := rd.ReadIntReply()
  44                 if err != nil {
  45                         return nil, err
  46                 }
  47                 bools = append(bools, n == 1)
  48         }
  49         return bools, nil
  50 }
  51
  52 // Implements proto.MultiBulkParse
  53 func stringSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
  54         ss := make([]string, 0, n)
  55         for i := int64(0); i < n; i++ {
  56                 s, err := rd.ReadStringReply()
  57                 if err == Nil {
  58                         ss = append(ss, "")
  59                 } else if err != nil {
  60                         return nil, err
  61                 } else {
  62                         ss = append(ss, s)
  63                 }
  64         }
  65         return ss, nil
  66 }
  67
  68 // Implements proto.MultiBulkParse
  69 func stringStringMapParser(rd *proto.Reader, n int64) (interface{}, error) {
  70         m := make(map[string]string, n/2)
  71         for i := int64(0); i < n; i += 2 {
  72                 key, err := rd.ReadStringReply()
  73                 if err != nil {
  74                         return nil, err
  75                 }
  76
  77                 value, err := rd.ReadStringReply()
  78                 if err != nil {
  79                         return nil, err
  80                 }
  81
  82                 m[key] = value
  83         }
  84         return m, nil
  85 }
  86
  87 // Implements proto.MultiBulkParse
  88 func stringIntMapParser(rd *proto.Reader, n int64) (interface{}, error) {
  89         m := make(map[string]int64, n/2)
  90         for i := int64(0); i < n; i += 2 {
  91                 key, err := rd.ReadStringReply()
  92                 if err != nil {
  93                         return nil, err
  94                 }
  95
  96                 n, err := rd.ReadIntReply()
  97                 if err != nil {
  98                         return nil, err
  99                 }
 100
 101                 m[key] = n
 102         }
 103         return m, nil
 104 }
 105
 106 // Implements proto.MultiBulkParse
 107 func stringStructMapParser(rd *proto.Reader, n int64) (interface{}, error) {
 108         m := make(map[string]struct{}, n)
 109         for i := int64(0); i < n; i++ {
 110                 key, err := rd.ReadStringReply()
 111                 if err != nil {
 112                         return nil, err
 113                 }
 114
 115                 m[key] = struct{}{}
 116         }
 117         return m, nil
 118 }
 119
 120 // Implements proto.MultiBulkParse
 121 func zSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
 122         zz := make([]Z, n/2)
 123         for i := int64(0); i < n; i += 2 {
 124                 var err error
 125
 126                 z := &zz[i/2]
 127
 128                 z.Member, err = rd.ReadStringReply()
 129                 if err != nil {
 130                         return nil, err
 131                 }
 132
 133                 z.Score, err = rd.ReadFloatReply()
 134                 if err != nil {
 135                         return nil, err
 136                 }
 137         }
 138         return zz, nil
 139 }
 140
 141 // Implements proto.MultiBulkParse
 142 func clusterSlotsParser(rd *proto.Reader, n int64) (interface{}, error) {
 143         slots := make([]ClusterSlot, n)
 144         for i := 0; i < len(slots); i++ {
 145                 n, err := rd.ReadArrayLen()
 146                 if err != nil {
 147                         return nil, err
 148                 }
 149                 if n < 2 {
 150                         err := fmt.Errorf("redis: got %d elements in cluster info, expected at least 2", n)
 151                         return nil, err
 152                 }
 153
 154                 start, err := rd.ReadIntReply()
 155                 if err != nil {
 156                         return nil, err
 157                 }
 158
 159                 end, err := rd.ReadIntReply()
 160                 if err != nil {
 161                         return nil, err
 162                 }
 163
 164                 nodes := make([]ClusterNode, n-2)
 165                 for j := 0; j < len(nodes); j++ {
 166                         n, err := rd.ReadArrayLen()
 167                         if err != nil {
 168                                 return nil, err
 169                         }
 170                         if n != 2 && n != 3 {
 171                                 err := fmt.Errorf("got %d elements in cluster info address, expected 2 or 3", n)
 172                                 return nil, err
 173                         }
 174
 175                         ip, err := rd.ReadStringReply()
 176                         if err != nil {
 177                                 return nil, err
 178                         }
 179
 180                         port, err := rd.ReadIntReply()
 181                         if err != nil {
 182                                 return nil, err
 183                         }
 184                         nodes[j].Addr = net.JoinHostPort(ip, strconv.FormatInt(port, 10))
 185
 186                         if n == 3 {
 187                                 id, err := rd.ReadStringReply()
 188                                 if err != nil {
 189                                         return nil, err
 190                                 }
 191                                 nodes[j].Id = id
 192                         }
 193                 }
 194
 195                 slots[i] = ClusterSlot{
 196                         Start: int(start),
 197                         End:   int(end),
 198                         Nodes: nodes,
 199                 }
 200         }
 201         return slots, nil
 202 }
 203
 204 func newGeoLocationParser(q *GeoRadiusQuery) proto.MultiBulkParse {
 205         return func(rd *proto.Reader, n int64) (interface{}, error) {
 206                 var loc GeoLocation
 207                 var err error
 208
 209                 loc.Name, err = rd.ReadStringReply()
 210                 if err != nil {
 211                         return nil, err
 212                 }
 213                 if q.WithDist {
 214                         loc.Dist, err = rd.ReadFloatReply()
 215                         if err != nil {
 216                                 return nil, err
 217                         }
 218                 }
 219                 if q.WithGeoHash {
 220                         loc.GeoHash, err = rd.ReadIntReply()
 221                         if err != nil {
 222                                 return nil, err
 223                         }
 224                 }
 225                 if q.WithCoord {
 226                         n, err := rd.ReadArrayLen()
 227                         if err != nil {
 228                                 return nil, err
 229                         }
 230                         if n != 2 {
 231                                 return nil, fmt.Errorf("got %d coordinates, expected 2", n)
 232                         }
 233
 234                         loc.Longitude, err = rd.ReadFloatReply()
 235                         if err != nil {
 236                                 return nil, err
 237                         }
 238                         loc.Latitude, err = rd.ReadFloatReply()
 239                         if err != nil {
 240                                 return nil, err
 241                         }
 242                 }
 243
 244                 return &loc, nil
 245         }
 246 }
 247
 248 func newGeoLocationSliceParser(q *GeoRadiusQuery) proto.MultiBulkParse {
 249         return func(rd *proto.Reader, n int64) (interface{}, error) {
 250                 locs := make([]GeoLocation, 0, n)
 251                 for i := int64(0); i < n; i++ {
 252                         v, err := rd.ReadReply(newGeoLocationParser(q))
 253                         if err != nil {
 254                                 return nil, err
 255                         }
 256                         switch vv := v.(type) {
 257                         case []byte:
 258                                 locs = append(locs, GeoLocation{
 259                                         Name: string(vv),
 260                                 })
 261                         case *GeoLocation:
 262                                 locs = append(locs, *vv)
 263                         default:
 264                                 return nil, fmt.Errorf("got %T, expected string or *GeoLocation", v)
 265                         }
 266                 }
 267                 return locs, nil
 268         }
 269 }
 270
 271 func geoPosParser(rd *proto.Reader, n int64) (interface{}, error) {
 272         var pos GeoPos
 273         var err error
 274
 275         pos.Longitude, err = rd.ReadFloatReply()
 276         if err != nil {
 277                 return nil, err
 278         }
 279
 280         pos.Latitude, err = rd.ReadFloatReply()
 281         if err != nil {
 282                 return nil, err
 283         }
 284
 285         return &pos, nil
 286 }
 287
 288 func geoPosSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
 289         positions := make([]*GeoPos, 0, n)
 290         for i := int64(0); i < n; i++ {
 291                 v, err := rd.ReadReply(geoPosParser)
 292                 if err != nil {
 293                         if err == Nil {
 294                                 positions = append(positions, nil)
 295                                 continue
 296                         }
 297                         return nil, err
 298                 }
 299                 switch v := v.(type) {
 300                 case *GeoPos:
 301                         positions = append(positions, v)
 302                 default:
 303                         return nil, fmt.Errorf("got %T, expected *GeoPos", v)
 304                 }
 305         }
 306         return positions, nil
 307 }
 308
 309 func commandInfoParser(rd *proto.Reader, n int64) (interface{}, error) {
 310         var cmd CommandInfo
 311         var err error
 312
 313         if n != 6 {
 314                 return nil, fmt.Errorf("redis: got %d elements in COMMAND reply, wanted 6", n)
 315         }
 316
 317         cmd.Name, err = rd.ReadStringReply()
 318         if err != nil {
 319                 return nil, err
 320         }
 321
 322         arity, err := rd.ReadIntReply()
 323         if err != nil {
 324                 return nil, err
 325         }
 326         cmd.Arity = int8(arity)
 327
 328         flags, err := rd.ReadReply(stringSliceParser)
 329         if err != nil {
 330                 return nil, err
 331         }
 332         cmd.Flags = flags.([]string)
 333
 334         firstKeyPos, err := rd.ReadIntReply()
 335         if err != nil {
 336                 return nil, err
 337         }
 338         cmd.FirstKeyPos = int8(firstKeyPos)
 339
 340         lastKeyPos, err := rd.ReadIntReply()
 341         if err != nil {
 342                 return nil, err
 343         }
 344         cmd.LastKeyPos = int8(lastKeyPos)
 345
 346         stepCount, err := rd.ReadIntReply()
 347         if err != nil {
 348                 return nil, err
 349         }
 350         cmd.StepCount = int8(stepCount)
 351
 352         for _, flag := range cmd.Flags {
 353                 if flag == "readonly" {
 354                         cmd.ReadOnly = true
 355                         break
 356                 }
 357         }
 358
 359         return &cmd, nil
 360 }
 361
 362 // Implements proto.MultiBulkParse
 363 func commandInfoSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
 364         m := make(map[string]*CommandInfo, n)
 365         for i := int64(0); i < n; i++ {
 366                 v, err := rd.ReadReply(commandInfoParser)
 367                 if err != nil {
 368                         return nil, err
 369                 }
 370                 vv := v.(*CommandInfo)
 371                 m[vv.Name] = vv
 372
 373         }
 374         return m, nil
 375 }
 376
 377 // Implements proto.MultiBulkParse
 378 func timeParser(rd *proto.Reader, n int64) (interface{}, error) {
 379         if n != 2 {
 380                 return nil, fmt.Errorf("got %d elements, expected 2", n)
 381         }
 382
 383         sec, err := rd.ReadInt()
 384         if err != nil {
 385                 return nil, err
 386         }
 387
 388         microsec, err := rd.ReadInt()
 389         if err != nil {
 390                 return nil, err
 391         }
 392
 393         return time.Unix(sec, microsec*1000), nil
 394 }