318 lines
8.1 KiB
Go
318 lines
8.1 KiB
Go
package rpc
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
"time"
|
|
|
|
"forge.cadoles.com/Pyxis/orion/emlid"
|
|
"forge.cadoles.com/Pyxis/orion/emlid/updater"
|
|
"forge.cadoles.com/Pyxis/orion/openwrt"
|
|
"github.com/gorilla/rpc"
|
|
"github.com/gorilla/rpc/json"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// OrionService is the JSON-RPC API
|
|
type OrionService struct {
|
|
UCI *openwrt.UCI
|
|
}
|
|
|
|
// NewOrionService create a new OrionService !
|
|
func NewOrionService() *OrionService {
|
|
uci := openwrt.NewUCI()
|
|
return &OrionService{
|
|
UCI: uci,
|
|
}
|
|
}
|
|
|
|
// UCIArgs argument structure for exported method OwrtListWifiDevices
|
|
type UCIArgs struct{}
|
|
|
|
// UCIResponse is the response structure for exposed method OwrtListWifiDevices
|
|
type UCIResponse struct {
|
|
Devices []map[string]string
|
|
}
|
|
|
|
// OwrtListWifiDevices offers an RPC Method to list Wifi nics in a OpenWRT device.
|
|
func (o *OrionService) OwrtListWifiDevices(r *http.Request, args *UCIArgs, reply *UCIResponse) error {
|
|
o.UCI.LoadWirelessConf()
|
|
devs := o.UCI.GetWifiDevices()
|
|
reply.Devices = devs
|
|
return nil
|
|
}
|
|
|
|
// ListIfaceArgs argument structure for exported method OwrtListWifiDevices
|
|
type ListIfaceArgs struct{}
|
|
|
|
// ListIfaceResponse is the response structure for exposed method OwrtListWifiDevices
|
|
type ListIfaceResponse struct {
|
|
Interfaces []*openwrt.UCIWirelessInterface
|
|
}
|
|
|
|
// OwrtListWifiInterfaces offers an RPC Method to list wifi interfaces in a OpenWRT device.
|
|
func (o *OrionService) OwrtListWifiInterfaces(r *http.Request, args *ListIfaceArgs, reply *ListIfaceResponse) error {
|
|
o.UCI.LoadWirelessConf()
|
|
reply.Interfaces = o.UCI.GetWifiIfaces()
|
|
return nil
|
|
}
|
|
|
|
// CreateIfaceArgs argument structure for exported method OwrtCreateWifiInterface
|
|
type CreateIfaceArgs struct {
|
|
Iface *openwrt.UCIWirelessInterface
|
|
Cleanup bool
|
|
}
|
|
|
|
// CreateIfaceResponse argument structure for exported method OwrtCreateWifiInterface
|
|
type CreateIfaceResponse struct {
|
|
Iface *openwrt.UCIWirelessInterface
|
|
Errors []*openwrt.Action
|
|
}
|
|
|
|
// OwrtCreateWifiInterface Create a WifiInterface in openwrt
|
|
func (o *OrionService) OwrtCreateWifiInterface(r *http.Request,
|
|
args *CreateIfaceArgs,
|
|
reply *CreateIfaceResponse) error {
|
|
reply.Iface = nil
|
|
|
|
if args.Cleanup {
|
|
o.UCI.LoadWirelessConf()
|
|
w := o.UCI.GetWifiIfaces()
|
|
for _, iface := range w {
|
|
iface.Delete(o.UCI)
|
|
}
|
|
o.UCI.Commit()
|
|
o.UCI.Reload()
|
|
time.Sleep(3 * time.Second)
|
|
}
|
|
|
|
o.UCI.LoadWirelessConf()
|
|
create := args.Iface.Create(o.UCI)
|
|
if create.ReturnCode != 0 {
|
|
reply.Errors = append(reply.Errors, create)
|
|
return nil
|
|
}
|
|
create = args.Iface.SysAdd(o.UCI)
|
|
if create.ReturnCode == 233 {
|
|
delete := args.Iface.SysDel(o.UCI)
|
|
if delete.ReturnCode != 0 {
|
|
reply.Errors = append(reply.Errors, delete)
|
|
return nil
|
|
}
|
|
create = args.Iface.SysAdd(o.UCI)
|
|
if create.ReturnCode != 0 {
|
|
reply.Errors = append(reply.Errors, create)
|
|
return nil
|
|
}
|
|
}
|
|
create = args.Iface.Up(o.UCI)
|
|
if create.ReturnCode != 0 {
|
|
reply.Errors = append(reply.Errors, create)
|
|
return nil
|
|
}
|
|
create = args.Iface.Save(o.UCI)
|
|
if create.ReturnCode != 0 {
|
|
reply.Errors = append(reply.Errors, create)
|
|
return nil
|
|
}
|
|
reply.Iface = args.Iface
|
|
return nil
|
|
}
|
|
|
|
// ConnectIfaceArgs argument structure for exported method OwrtCreateWifiInterface
|
|
type ConnectIfaceArgs struct {
|
|
Iface *openwrt.UCIWirelessInterface
|
|
SSID string
|
|
Key string
|
|
}
|
|
|
|
// ConnectIfaceResponse argument structure for exported method OwrtCreateWifiInterface
|
|
type ConnectIfaceResponse struct {
|
|
status int
|
|
Errors []string
|
|
}
|
|
|
|
// OwrtConnectWifiInterface connects a given Wifi Interface to a given SSID
|
|
func (o *OrionService) OwrtConnectWifiInterface(r *http.Request,
|
|
args *ConnectIfaceArgs,
|
|
reply *ConnectIfaceResponse) error {
|
|
o.UCI.LoadWirelessConf()
|
|
iface := o.UCI.GetWifiIface(args.Iface.Index)
|
|
cells := iface.Scan()
|
|
|
|
for _, cell := range cells {
|
|
if cell.Ssid == args.SSID {
|
|
cn := iface.Connect(o.UCI, cell, args.Key)
|
|
if cn.ReturnCode != 0 {
|
|
reply.status = cn.ReturnCode
|
|
reply.Errors = append(reply.Errors, cn.Stdout, cn.Stderr, cn.Command)
|
|
}
|
|
reply.status = 0
|
|
return nil
|
|
}
|
|
}
|
|
reply.status = 1
|
|
msg := fmt.Sprintf("Wifi Cell with SSID %s is not available !", args.SSID)
|
|
reply.Errors = append(reply.Errors, msg)
|
|
return nil
|
|
}
|
|
|
|
// OrionBox describe an fresh Orion box (base or rover)
|
|
type OrionBox struct {
|
|
Address string
|
|
SSID string
|
|
Security string
|
|
WifiKey string
|
|
}
|
|
|
|
// OrionServer describe the Orion master server
|
|
type OrionServer struct {
|
|
Address string
|
|
SSID string
|
|
Security string
|
|
WifiKey string
|
|
ClientIface *openwrt.UCIWirelessInterface
|
|
}
|
|
|
|
// UpdateOrionBoxArgs argument structure for exported method OwrtCreateWifiInterface
|
|
type UpdateOrionBoxArgs struct {
|
|
Box *OrionBox
|
|
Server *OrionServer
|
|
}
|
|
|
|
// UpdateOrionBoxResponse argument structure for exported method OwrtCreateWifiInterface
|
|
type UpdateOrionBoxResponse struct {
|
|
IP string
|
|
Netmask string
|
|
Synced bool
|
|
Version string
|
|
Errors []string
|
|
}
|
|
|
|
// Connect wifi interface to a Orion box wifi hotspot!
|
|
func (o *OrionService) connectBox(box *OrionBox, server *OrionServer) error {
|
|
o.UCI.LoadWirelessConf()
|
|
if server == nil {
|
|
return fmt.Errorf("Server definition is empty")
|
|
}
|
|
|
|
if box == nil {
|
|
return fmt.Errorf("Box definitioni is emtpy")
|
|
}
|
|
fmt.Println("DEBUG")
|
|
fmt.Println(server)
|
|
fmt.Println("DEBUG")
|
|
iface := server.ClientIface
|
|
cells := iface.Scan()
|
|
for _, cell := range cells {
|
|
fmt.Printf("Cell : %s\n", cell.Ssid)
|
|
if cell.Ssid == box.SSID {
|
|
cn := iface.Connect(o.UCI, cell, box.WifiKey)
|
|
if cn.ReturnCode != 0 {
|
|
return fmt.Errorf("%s\n%s", cn.Stdout, cn.Stderr)
|
|
}
|
|
dhcli := openwrt.NewDhcpClient(iface.SysDevName)
|
|
dhres := dhcli.AskForIP()
|
|
if dhres.CmdRes.ReturnCode != 0 {
|
|
return fmt.Errorf("%s\n%s", cn.Stdout, cn.Stderr)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
return fmt.Errorf("Wifi cell with SSID %s is not available", box.SSID)
|
|
}
|
|
|
|
// UpdateOrionBox starts provisionning process for an Orion box (base or rover)
|
|
func (o *OrionService) UpdateOrionBox(r *http.Request,
|
|
args *UpdateOrionBoxArgs,
|
|
reply *UpdateOrionBoxResponse) error {
|
|
|
|
if err := o.connectBox(args.Box, args.Server); err != nil {
|
|
reply.Errors = append(reply.Errors, err.Error())
|
|
return errors.Wrap(err, "Connect to box failed")
|
|
}
|
|
|
|
re := o.UCI.Reload()
|
|
if re.ReturnCode != 0 {
|
|
return fmt.Errorf("%s\n%s", re.Stdout, re.Stderr)
|
|
}
|
|
|
|
ssid := args.Server.SSID
|
|
security := args.Server.Security
|
|
wifiKey := args.Server.WifiKey
|
|
|
|
if security == "" {
|
|
security = string(updater.SecurityWPAPSK)
|
|
}
|
|
|
|
//services, err := emlid.Discover(20 * time.Second)
|
|
//if err != nil {
|
|
// return err
|
|
//}
|
|
|
|
//if len(services) == 0 {
|
|
// return fmt.Errorf("Discovery don't find any Orion Box")
|
|
//}
|
|
|
|
//fmt.Println(services)
|
|
boxCli := updater.NewClient(
|
|
//emlid.WithService(services[0]),
|
|
emlid.WithEndpoint(args.Box.Address, 80),
|
|
)
|
|
|
|
if err := boxCli.Connect(); err != nil {
|
|
return errors.Wrap(err, "Box connect to master failed")
|
|
}
|
|
defer boxCli.Close()
|
|
|
|
ctx, addWifiCancel := context.WithTimeout(r.Context(), 55*time.Second)
|
|
defer addWifiCancel()
|
|
|
|
done, err := boxCli.AddWifiNetwork(ctx, ssid, updater.WifiSecurity(security), wifiKey)
|
|
if err != nil {
|
|
return errors.Wrap(err, "AddWifiNetworkFailed")
|
|
}
|
|
|
|
if !done {
|
|
return fmt.Errorf("Impossible to add wifi network")
|
|
}
|
|
|
|
ctx, joinWifiCancel := context.WithTimeout(ctx, 55*time.Second)
|
|
defer joinWifiCancel()
|
|
|
|
if err := boxCli.JoinWifiNetwork(ctx, ssid, true); err != nil {
|
|
return errors.Wrap(err, "Time sync failed")
|
|
}
|
|
|
|
ctx, timeSyncedCancel := context.WithTimeout(r.Context(), 55*time.Second)
|
|
defer timeSyncedCancel()
|
|
synced, err := boxCli.TimeSynced(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "Time sync failed")
|
|
}
|
|
reply.Synced = synced
|
|
|
|
ctx, reachviewVersionCancel := context.WithTimeout(r.Context(), 55*time.Second)
|
|
defer reachviewVersionCancel()
|
|
version, err := boxCli.ReachViewVersion(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reply.Version = version
|
|
|
|
ctx, rebootCancel := context.WithTimeout(r.Context(), 55*time.Second)
|
|
defer rebootCancel()
|
|
return boxCli.RebootNow(ctx, true)
|
|
}
|
|
|
|
// NewServer returns a new configured JSON-RPC server
|
|
func NewServer() *rpc.Server {
|
|
server := rpc.NewServer()
|
|
server.RegisterCodec(json.NewCodec(), "application/json")
|
|
if err := server.RegisterService(NewOrionService(), "Orion"); err != nil {
|
|
panic(err)
|
|
}
|
|
return server
|
|
}
|