forked from hswaw/hscloud
132 lines
3.2 KiB
Go
132 lines
3.2 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"net"
|
|
"net/http"
|
|
|
|
"code.hackerspace.pl/q3k/hspki"
|
|
"github.com/golang/glog"
|
|
"github.com/q3k/statusz"
|
|
"github.com/ziutek/telnet"
|
|
"golang.org/x/net/trace"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/reflection"
|
|
"google.golang.org/grpc/status"
|
|
|
|
pb "code.hackerspace.pl/q3k/m6220-proxy/proto"
|
|
)
|
|
|
|
var (
|
|
flagListenAddress string
|
|
flagDebugAddress string
|
|
flagSwitchAddress string
|
|
flagSwitchUsername string
|
|
flagSwitchPassword string
|
|
)
|
|
|
|
func init() {
|
|
flag.Set("logtostderr", "true")
|
|
}
|
|
|
|
type service struct {
|
|
connectionSemaphore chan int
|
|
}
|
|
|
|
func (s *service) connect() (*cliClient, error) {
|
|
s.connectionSemaphore <- 1
|
|
conn, err := telnet.Dial("tcp", flagSwitchAddress)
|
|
if err != nil {
|
|
<-s.connectionSemaphore
|
|
return nil, err
|
|
}
|
|
|
|
cli := newCliClient(conn, flagSwitchUsername, flagSwitchPassword)
|
|
return cli, nil
|
|
}
|
|
|
|
func (s *service) disconnect() {
|
|
<-s.connectionSemaphore
|
|
}
|
|
|
|
func (s *service) RunCommand(ctx context.Context, req *pb.RunCommandRequest) (*pb.RunCommandResponse, error) {
|
|
if req.Command == "" {
|
|
return nil, status.Error(codes.InvalidArgument, "command cannot be null")
|
|
}
|
|
|
|
cli, err := s.connect()
|
|
if err != nil {
|
|
return nil, status.Error(codes.Unavailable, "could not connect to backend")
|
|
}
|
|
defer s.disconnect()
|
|
|
|
lines, effective, err := cli.runCommand(ctx, req.Command)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res := &pb.RunCommandResponse{
|
|
EffectiveCommand: effective,
|
|
Lines: lines,
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func main() {
|
|
flag.StringVar(&flagListenAddress, "listen_address", "127.0.0.1:42000", "Address to listen on for gRPC")
|
|
flag.StringVar(&flagDebugAddress, "debug_address", "127.0.0.1:42001", "Address to listen on for Debug HTTP")
|
|
flag.StringVar(&flagSwitchAddress, "switch_address", "127.0.0.1:23", "Telnet address of M6220")
|
|
flag.StringVar(&flagSwitchUsername, "switch_username", "admin", "Switch login username")
|
|
flag.StringVar(&flagSwitchPassword, "switch_password", "admin", "Switch login password")
|
|
flag.Parse()
|
|
|
|
s := &service{
|
|
connectionSemaphore: make(chan int, 1),
|
|
}
|
|
|
|
grpc.EnableTracing = true
|
|
grpcLis, err := net.Listen("tcp", flagListenAddress)
|
|
if err != nil {
|
|
glog.Exitf("Could not listen on %v: %v", flagListenAddress, err)
|
|
}
|
|
grpcSrv := grpc.NewServer(hspki.WithServerHSPKI()...)
|
|
pb.RegisterM6220ProxyServer(grpcSrv, s)
|
|
reflection.Register(grpcSrv)
|
|
|
|
glog.Infof("Starting gRPC on %v", flagListenAddress)
|
|
go func() {
|
|
if err := grpcSrv.Serve(grpcLis); err != nil {
|
|
glog.Exitf("Could not start gRPC: %v", err)
|
|
}
|
|
}()
|
|
|
|
if flagDebugAddress != "" {
|
|
glog.Infof("Starting debug on %v", flagDebugAddress)
|
|
httpMux := http.NewServeMux()
|
|
httpMux.HandleFunc("/debug/status", statusz.StatusHandler)
|
|
httpMux.HandleFunc("/debug/requests", trace.Traces)
|
|
httpMux.HandleFunc("/", statusz.StatusHandler)
|
|
|
|
httpLis, err := net.Listen("tcp", flagDebugAddress)
|
|
if err != nil {
|
|
glog.Exitf("Could not listen on %v: %v", flagDebugAddress, err)
|
|
}
|
|
httpSrv := &http.Server{
|
|
Addr: flagDebugAddress,
|
|
Handler: httpMux,
|
|
}
|
|
|
|
go func() {
|
|
if err := httpSrv.Serve(httpLis); err != nil {
|
|
glog.Exitf("Could not start HTTP server: %v", err)
|
|
}
|
|
}()
|
|
|
|
}
|
|
|
|
glog.Infof("Running!")
|
|
|
|
select {}
|
|
}
|