binapi/interface/interface_rest.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package interfaces
   4
   5 import (
   6         "encoding/json"
   7         "io/ioutil"
   8         "net/http"
   9 )
  10
  11 func RESTHandler(rpc RPCService) http.Handler {
  12         mux := http.NewServeMux()
  13         mux.HandleFunc("/collect_detailed_interface_stats", func(w http.ResponseWriter, req *http.Request) {
  14                 var request = new(CollectDetailedInterfaceStats)
  15                 b, err := ioutil.ReadAll(req.Body)
  16                 if err != nil {
  17                         http.Error(w, "read body failed", http.StatusBadRequest)
  18                         return
  19                 }
  20                 if err := json.Unmarshal(b, request); err != nil {
  21                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
  22                         return
  23                 }
  24                 reply, err := rpc.CollectDetailedInterfaceStats(req.Context(), request)
  25                 if err != nil {
  26                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
  27                         return
  28                 }
  29                 rep, err := json.MarshalIndent(reply, "", "  ")
  30                 if err != nil {
  31                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
  32                         return
  33                 }
  34                 w.Write(rep)
  35         })
  36         mux.HandleFunc("/create_loopback", func(w http.ResponseWriter, req *http.Request) {
  37                 var request = new(CreateLoopback)
  38                 b, err := ioutil.ReadAll(req.Body)
  39                 if err != nil {
  40                         http.Error(w, "read body failed", http.StatusBadRequest)
  41                         return
  42                 }
  43                 if err := json.Unmarshal(b, request); err != nil {
  44                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
  45                         return
  46                 }
  47                 reply, err := rpc.CreateLoopback(req.Context(), request)
  48                 if err != nil {
  49                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
  50                         return
  51                 }
  52                 rep, err := json.MarshalIndent(reply, "", "  ")
  53                 if err != nil {
  54                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
  55                         return
  56                 }
  57                 w.Write(rep)
  58         })
  59         mux.HandleFunc("/create_loopback_instance", func(w http.ResponseWriter, req *http.Request) {
  60                 var request = new(CreateLoopbackInstance)
  61                 b, err := ioutil.ReadAll(req.Body)
  62                 if err != nil {
  63                         http.Error(w, "read body failed", http.StatusBadRequest)
  64                         return
  65                 }
  66                 if err := json.Unmarshal(b, request); err != nil {
  67                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
  68                         return
  69                 }
  70                 reply, err := rpc.CreateLoopbackInstance(req.Context(), request)
  71                 if err != nil {
  72                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
  73                         return
  74                 }
  75                 rep, err := json.MarshalIndent(reply, "", "  ")
  76                 if err != nil {
  77                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
  78                         return
  79                 }
  80                 w.Write(rep)
  81         })
  82         mux.HandleFunc("/create_subif", func(w http.ResponseWriter, req *http.Request) {
  83                 var request = new(CreateSubif)
  84                 b, err := ioutil.ReadAll(req.Body)
  85                 if err != nil {
  86                         http.Error(w, "read body failed", http.StatusBadRequest)
  87                         return
  88                 }
  89                 if err := json.Unmarshal(b, request); err != nil {
  90                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
  91                         return
  92                 }
  93                 reply, err := rpc.CreateSubif(req.Context(), request)
  94                 if err != nil {
  95                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
  96                         return
  97                 }
  98                 rep, err := json.MarshalIndent(reply, "", "  ")
  99                 if err != nil {
 100                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 101                         return
 102                 }
 103                 w.Write(rep)
 104         })
 105         mux.HandleFunc("/create_vlan_subif", func(w http.ResponseWriter, req *http.Request) {
 106                 var request = new(CreateVlanSubif)
 107                 b, err := ioutil.ReadAll(req.Body)
 108                 if err != nil {
 109                         http.Error(w, "read body failed", http.StatusBadRequest)
 110                         return
 111                 }
 112                 if err := json.Unmarshal(b, request); err != nil {
 113                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 114                         return
 115                 }
 116                 reply, err := rpc.CreateVlanSubif(req.Context(), request)
 117                 if err != nil {
 118                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 119                         return
 120                 }
 121                 rep, err := json.MarshalIndent(reply, "", "  ")
 122                 if err != nil {
 123                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 124                         return
 125                 }
 126                 w.Write(rep)
 127         })
 128         mux.HandleFunc("/delete_loopback", func(w http.ResponseWriter, req *http.Request) {
 129                 var request = new(DeleteLoopback)
 130                 b, err := ioutil.ReadAll(req.Body)
 131                 if err != nil {
 132                         http.Error(w, "read body failed", http.StatusBadRequest)
 133                         return
 134                 }
 135                 if err := json.Unmarshal(b, request); err != nil {
 136                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 137                         return
 138                 }
 139                 reply, err := rpc.DeleteLoopback(req.Context(), request)
 140                 if err != nil {
 141                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 142                         return
 143                 }
 144                 rep, err := json.MarshalIndent(reply, "", "  ")
 145                 if err != nil {
 146                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 147                         return
 148                 }
 149                 w.Write(rep)
 150         })
 151         mux.HandleFunc("/delete_subif", func(w http.ResponseWriter, req *http.Request) {
 152                 var request = new(DeleteSubif)
 153                 b, err := ioutil.ReadAll(req.Body)
 154                 if err != nil {
 155                         http.Error(w, "read body failed", http.StatusBadRequest)
 156                         return
 157                 }
 158                 if err := json.Unmarshal(b, request); err != nil {
 159                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 160                         return
 161                 }
 162                 reply, err := rpc.DeleteSubif(req.Context(), request)
 163                 if err != nil {
 164                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 165                         return
 166                 }
 167                 rep, err := json.MarshalIndent(reply, "", "  ")
 168                 if err != nil {
 169                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 170                         return
 171                 }
 172                 w.Write(rep)
 173         })
 174         mux.HandleFunc("/hw_interface_set_mtu", func(w http.ResponseWriter, req *http.Request) {
 175                 var request = new(HwInterfaceSetMtu)
 176                 b, err := ioutil.ReadAll(req.Body)
 177                 if err != nil {
 178                         http.Error(w, "read body failed", http.StatusBadRequest)
 179                         return
 180                 }
 181                 if err := json.Unmarshal(b, request); err != nil {
 182                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 183                         return
 184                 }
 185                 reply, err := rpc.HwInterfaceSetMtu(req.Context(), request)
 186                 if err != nil {
 187                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 188                         return
 189                 }
 190                 rep, err := json.MarshalIndent(reply, "", "  ")
 191                 if err != nil {
 192                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 193                         return
 194                 }
 195                 w.Write(rep)
 196         })
 197         mux.HandleFunc("/interface_name_renumber", func(w http.ResponseWriter, req *http.Request) {
 198                 var request = new(InterfaceNameRenumber)
 199                 b, err := ioutil.ReadAll(req.Body)
 200                 if err != nil {
 201                         http.Error(w, "read body failed", http.StatusBadRequest)
 202                         return
 203                 }
 204                 if err := json.Unmarshal(b, request); err != nil {
 205                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 206                         return
 207                 }
 208                 reply, err := rpc.InterfaceNameRenumber(req.Context(), request)
 209                 if err != nil {
 210                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 211                         return
 212                 }
 213                 rep, err := json.MarshalIndent(reply, "", "  ")
 214                 if err != nil {
 215                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 216                         return
 217                 }
 218                 w.Write(rep)
 219         })
 220         mux.HandleFunc("/sw_interface_add_del_address", func(w http.ResponseWriter, req *http.Request) {
 221                 var request = new(SwInterfaceAddDelAddress)
 222                 b, err := ioutil.ReadAll(req.Body)
 223                 if err != nil {
 224                         http.Error(w, "read body failed", http.StatusBadRequest)
 225                         return
 226                 }
 227                 if err := json.Unmarshal(b, request); err != nil {
 228                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 229                         return
 230                 }
 231                 reply, err := rpc.SwInterfaceAddDelAddress(req.Context(), request)
 232                 if err != nil {
 233                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 234                         return
 235                 }
 236                 rep, err := json.MarshalIndent(reply, "", "  ")
 237                 if err != nil {
 238                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 239                         return
 240                 }
 241                 w.Write(rep)
 242         })
 243         mux.HandleFunc("/sw_interface_add_del_mac_address", func(w http.ResponseWriter, req *http.Request) {
 244                 var request = new(SwInterfaceAddDelMacAddress)
 245                 b, err := ioutil.ReadAll(req.Body)
 246                 if err != nil {
 247                         http.Error(w, "read body failed", http.StatusBadRequest)
 248                         return
 249                 }
 250                 if err := json.Unmarshal(b, request); err != nil {
 251                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 252                         return
 253                 }
 254                 reply, err := rpc.SwInterfaceAddDelMacAddress(req.Context(), request)
 255                 if err != nil {
 256                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 257                         return
 258                 }
 259                 rep, err := json.MarshalIndent(reply, "", "  ")
 260                 if err != nil {
 261                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 262                         return
 263                 }
 264                 w.Write(rep)
 265         })
 266         mux.HandleFunc("/sw_interface_address_replace_begin", func(w http.ResponseWriter, req *http.Request) {
 267                 var request = new(SwInterfaceAddressReplaceBegin)
 268                 reply, err := rpc.SwInterfaceAddressReplaceBegin(req.Context(), request)
 269                 if err != nil {
 270                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 271                         return
 272                 }
 273                 rep, err := json.MarshalIndent(reply, "", "  ")
 274                 if err != nil {
 275                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 276                         return
 277                 }
 278                 w.Write(rep)
 279         })
 280         mux.HandleFunc("/sw_interface_address_replace_end", func(w http.ResponseWriter, req *http.Request) {
 281                 var request = new(SwInterfaceAddressReplaceEnd)
 282                 reply, err := rpc.SwInterfaceAddressReplaceEnd(req.Context(), request)
 283                 if err != nil {
 284                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 285                         return
 286                 }
 287                 rep, err := json.MarshalIndent(reply, "", "  ")
 288                 if err != nil {
 289                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 290                         return
 291                 }
 292                 w.Write(rep)
 293         })
 294         mux.HandleFunc("/sw_interface_clear_stats", func(w http.ResponseWriter, req *http.Request) {
 295                 var request = new(SwInterfaceClearStats)
 296                 b, err := ioutil.ReadAll(req.Body)
 297                 if err != nil {
 298                         http.Error(w, "read body failed", http.StatusBadRequest)
 299                         return
 300                 }
 301                 if err := json.Unmarshal(b, request); err != nil {
 302                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 303                         return
 304                 }
 305                 reply, err := rpc.SwInterfaceClearStats(req.Context(), request)
 306                 if err != nil {
 307                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 308                         return
 309                 }
 310                 rep, err := json.MarshalIndent(reply, "", "  ")
 311                 if err != nil {
 312                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 313                         return
 314                 }
 315                 w.Write(rep)
 316         })
 317         mux.HandleFunc("/sw_interface_get_mac_address", func(w http.ResponseWriter, req *http.Request) {
 318                 var request = new(SwInterfaceGetMacAddress)
 319                 b, err := ioutil.ReadAll(req.Body)
 320                 if err != nil {
 321                         http.Error(w, "read body failed", http.StatusBadRequest)
 322                         return
 323                 }
 324                 if err := json.Unmarshal(b, request); err != nil {
 325                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 326                         return
 327                 }
 328                 reply, err := rpc.SwInterfaceGetMacAddress(req.Context(), request)
 329                 if err != nil {
 330                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 331                         return
 332                 }
 333                 rep, err := json.MarshalIndent(reply, "", "  ")
 334                 if err != nil {
 335                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 336                         return
 337                 }
 338                 w.Write(rep)
 339         })
 340         mux.HandleFunc("/sw_interface_get_table", func(w http.ResponseWriter, req *http.Request) {
 341                 var request = new(SwInterfaceGetTable)
 342                 b, err := ioutil.ReadAll(req.Body)
 343                 if err != nil {
 344                         http.Error(w, "read body failed", http.StatusBadRequest)
 345                         return
 346                 }
 347                 if err := json.Unmarshal(b, request); err != nil {
 348                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 349                         return
 350                 }
 351                 reply, err := rpc.SwInterfaceGetTable(req.Context(), request)
 352                 if err != nil {
 353                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 354                         return
 355                 }
 356                 rep, err := json.MarshalIndent(reply, "", "  ")
 357                 if err != nil {
 358                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 359                         return
 360                 }
 361                 w.Write(rep)
 362         })
 363         mux.HandleFunc("/sw_interface_set_flags", func(w http.ResponseWriter, req *http.Request) {
 364                 var request = new(SwInterfaceSetFlags)
 365                 b, err := ioutil.ReadAll(req.Body)
 366                 if err != nil {
 367                         http.Error(w, "read body failed", http.StatusBadRequest)
 368                         return
 369                 }
 370                 if err := json.Unmarshal(b, request); err != nil {
 371                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 372                         return
 373                 }
 374                 reply, err := rpc.SwInterfaceSetFlags(req.Context(), request)
 375                 if err != nil {
 376                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 377                         return
 378                 }
 379                 rep, err := json.MarshalIndent(reply, "", "  ")
 380                 if err != nil {
 381                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 382                         return
 383                 }
 384                 w.Write(rep)
 385         })
 386         mux.HandleFunc("/sw_interface_set_ip_directed_broadcast", func(w http.ResponseWriter, req *http.Request) {
 387                 var request = new(SwInterfaceSetIPDirectedBroadcast)
 388                 b, err := ioutil.ReadAll(req.Body)
 389                 if err != nil {
 390                         http.Error(w, "read body failed", http.StatusBadRequest)
 391                         return
 392                 }
 393                 if err := json.Unmarshal(b, request); err != nil {
 394                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 395                         return
 396                 }
 397                 reply, err := rpc.SwInterfaceSetIPDirectedBroadcast(req.Context(), request)
 398                 if err != nil {
 399                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 400                         return
 401                 }
 402                 rep, err := json.MarshalIndent(reply, "", "  ")
 403                 if err != nil {
 404                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 405                         return
 406                 }
 407                 w.Write(rep)
 408         })
 409         mux.HandleFunc("/sw_interface_set_mac_address", func(w http.ResponseWriter, req *http.Request) {
 410                 var request = new(SwInterfaceSetMacAddress)
 411                 b, err := ioutil.ReadAll(req.Body)
 412                 if err != nil {
 413                         http.Error(w, "read body failed", http.StatusBadRequest)
 414                         return
 415                 }
 416                 if err := json.Unmarshal(b, request); err != nil {
 417                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 418                         return
 419                 }
 420                 reply, err := rpc.SwInterfaceSetMacAddress(req.Context(), request)
 421                 if err != nil {
 422                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 423                         return
 424                 }
 425                 rep, err := json.MarshalIndent(reply, "", "  ")
 426                 if err != nil {
 427                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 428                         return
 429                 }
 430                 w.Write(rep)
 431         })
 432         mux.HandleFunc("/sw_interface_set_mtu", func(w http.ResponseWriter, req *http.Request) {
 433                 var request = new(SwInterfaceSetMtu)
 434                 b, err := ioutil.ReadAll(req.Body)
 435                 if err != nil {
 436                         http.Error(w, "read body failed", http.StatusBadRequest)
 437                         return
 438                 }
 439                 if err := json.Unmarshal(b, request); err != nil {
 440                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 441                         return
 442                 }
 443                 reply, err := rpc.SwInterfaceSetMtu(req.Context(), request)
 444                 if err != nil {
 445                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 446                         return
 447                 }
 448                 rep, err := json.MarshalIndent(reply, "", "  ")
 449                 if err != nil {
 450                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 451                         return
 452                 }
 453                 w.Write(rep)
 454         })
 455         mux.HandleFunc("/sw_interface_set_rx_mode", func(w http.ResponseWriter, req *http.Request) {
 456                 var request = new(SwInterfaceSetRxMode)
 457                 b, err := ioutil.ReadAll(req.Body)
 458                 if err != nil {
 459                         http.Error(w, "read body failed", http.StatusBadRequest)
 460                         return
 461                 }
 462                 if err := json.Unmarshal(b, request); err != nil {
 463                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 464                         return
 465                 }
 466                 reply, err := rpc.SwInterfaceSetRxMode(req.Context(), request)
 467                 if err != nil {
 468                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 469                         return
 470                 }
 471                 rep, err := json.MarshalIndent(reply, "", "  ")
 472                 if err != nil {
 473                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 474                         return
 475                 }
 476                 w.Write(rep)
 477         })
 478         mux.HandleFunc("/sw_interface_set_rx_placement", func(w http.ResponseWriter, req *http.Request) {
 479                 var request = new(SwInterfaceSetRxPlacement)
 480                 b, err := ioutil.ReadAll(req.Body)
 481                 if err != nil {
 482                         http.Error(w, "read body failed", http.StatusBadRequest)
 483                         return
 484                 }
 485                 if err := json.Unmarshal(b, request); err != nil {
 486                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 487                         return
 488                 }
 489                 reply, err := rpc.SwInterfaceSetRxPlacement(req.Context(), request)
 490                 if err != nil {
 491                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 492                         return
 493                 }
 494                 rep, err := json.MarshalIndent(reply, "", "  ")
 495                 if err != nil {
 496                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 497                         return
 498                 }
 499                 w.Write(rep)
 500         })
 501         mux.HandleFunc("/sw_interface_set_table", func(w http.ResponseWriter, req *http.Request) {
 502                 var request = new(SwInterfaceSetTable)
 503                 b, err := ioutil.ReadAll(req.Body)
 504                 if err != nil {
 505                         http.Error(w, "read body failed", http.StatusBadRequest)
 506                         return
 507                 }
 508                 if err := json.Unmarshal(b, request); err != nil {
 509                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 510                         return
 511                 }
 512                 reply, err := rpc.SwInterfaceSetTable(req.Context(), request)
 513                 if err != nil {
 514                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 515                         return
 516                 }
 517                 rep, err := json.MarshalIndent(reply, "", "  ")
 518                 if err != nil {
 519                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 520                         return
 521                 }
 522                 w.Write(rep)
 523         })
 524         mux.HandleFunc("/sw_interface_set_unnumbered", func(w http.ResponseWriter, req *http.Request) {
 525                 var request = new(SwInterfaceSetUnnumbered)
 526                 b, err := ioutil.ReadAll(req.Body)
 527                 if err != nil {
 528                         http.Error(w, "read body failed", http.StatusBadRequest)
 529                         return
 530                 }
 531                 if err := json.Unmarshal(b, request); err != nil {
 532                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 533                         return
 534                 }
 535                 reply, err := rpc.SwInterfaceSetUnnumbered(req.Context(), request)
 536                 if err != nil {
 537                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 538                         return
 539                 }
 540                 rep, err := json.MarshalIndent(reply, "", "  ")
 541                 if err != nil {
 542                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 543                         return
 544                 }
 545                 w.Write(rep)
 546         })
 547         mux.HandleFunc("/sw_interface_tag_add_del", func(w http.ResponseWriter, req *http.Request) {
 548                 var request = new(SwInterfaceTagAddDel)
 549                 b, err := ioutil.ReadAll(req.Body)
 550                 if err != nil {
 551                         http.Error(w, "read body failed", http.StatusBadRequest)
 552                         return
 553                 }
 554                 if err := json.Unmarshal(b, request); err != nil {
 555                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 556                         return
 557                 }
 558                 reply, err := rpc.SwInterfaceTagAddDel(req.Context(), request)
 559                 if err != nil {
 560                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 561                         return
 562                 }
 563                 rep, err := json.MarshalIndent(reply, "", "  ")
 564                 if err != nil {
 565                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 566                         return
 567                 }
 568                 w.Write(rep)
 569         })
 570         mux.HandleFunc("/want_interface_events", func(w http.ResponseWriter, req *http.Request) {
 571                 var request = new(WantInterfaceEvents)
 572                 b, err := ioutil.ReadAll(req.Body)
 573                 if err != nil {
 574                         http.Error(w, "read body failed", http.StatusBadRequest)
 575                         return
 576                 }
 577                 if err := json.Unmarshal(b, request); err != nil {
 578                         http.Error(w, "unmarshal data failed", http.StatusBadRequest)
 579                         return
 580                 }
 581                 reply, err := rpc.WantInterfaceEvents(req.Context(), request)
 582                 if err != nil {
 583                         http.Error(w, "request failed: "+err.Error(), http.StatusInternalServerError)
 584                         return
 585                 }
 586                 rep, err := json.MarshalIndent(reply, "", "  ")
 587                 if err != nil {
 588                         http.Error(w, "marshal failed: "+err.Error(), http.StatusInternalServerError)
 589                         return
 590                 }
 591                 w.Write(rep)
 592         })
 593         return http.HandlerFunc(mux.ServeHTTP)
 594 }