1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-23 02:26:49 -05:00
v2fly/app/proxyman/command/command.go

149 lines
4.3 KiB
Go
Raw Normal View History

2018-02-05 17:38:24 -05:00
package command
import (
"context"
grpc "google.golang.org/grpc"
"v2ray.com/core"
"v2ray.com/core/common"
"v2ray.com/core/proxy"
)
2018-02-08 16:53:01 -05:00
// InboundOperation is the interface for operations that applies to inbound handlers.
2018-02-05 17:38:24 -05:00
type InboundOperation interface {
2018-02-08 16:53:01 -05:00
// ApplyInbound appliess this operation to the given inbound handler.
2018-02-05 17:38:24 -05:00
ApplyInbound(context.Context, core.InboundHandler) error
}
2018-02-08 16:53:01 -05:00
// OutboundOperation is the interface for operations that applies to outbound handlers.
2018-02-05 17:38:24 -05:00
type OutboundOperation interface {
2018-02-08 16:53:01 -05:00
// ApplyOutbound applies this operation to the given outbound handler.
2018-02-05 17:38:24 -05:00
ApplyOutbound(context.Context, core.OutboundHandler) error
}
2018-02-08 16:53:01 -05:00
func getInbound(handler core.InboundHandler) (proxy.Inbound, error) {
gi, ok := handler.(proxy.GetInbound)
2018-02-05 17:38:24 -05:00
if !ok {
2018-02-08 16:53:01 -05:00
return nil, newError("can't get inbound proxy from handler.")
}
return gi.GetInbound(), nil
}
// ApplyInbound implements InboundOperation.
func (op *AddUserOperation) ApplyInbound(ctx context.Context, handler core.InboundHandler) error {
p, err := getInbound(handler)
if err != nil {
return err
2018-02-05 17:38:24 -05:00
}
um, ok := p.(proxy.UserManager)
if !ok {
return newError("proxy is not an UserManager")
}
return um.AddUser(ctx, op.User)
}
2018-02-08 16:53:01 -05:00
// ApplyInbound implements InboundOperation.
func (op *RemoveUserOperation) ApplyInbound(ctx context.Context, handler core.InboundHandler) error {
p, err := getInbound(handler)
if err != nil {
return err
2018-02-05 17:38:24 -05:00
}
um, ok := p.(proxy.UserManager)
if !ok {
2018-02-08 16:53:01 -05:00
return newError("proxy is not an UserManager")
2018-02-05 17:38:24 -05:00
}
2018-02-08 16:53:01 -05:00
return um.RemoveUser(ctx, op.Email)
2018-02-05 17:38:24 -05:00
}
type handlerServer struct {
s *core.Instance
ihm core.InboundHandlerManager
ohm core.OutboundHandlerManager
}
func (s *handlerServer) AddInbound(ctx context.Context, request *AddInboundRequest) (*AddInboundResponse, error) {
rawHandler, err := s.s.CreateObject(request.Inbound)
if err != nil {
return nil, err
}
handler, ok := rawHandler.(core.InboundHandler)
if !ok {
return nil, newError("not an InboundHandler.")
}
return &AddInboundResponse{}, s.ihm.AddHandler(ctx, handler)
}
func (s *handlerServer) RemoveInbound(ctx context.Context, request *RemoveInboundRequest) (*RemoveInboundResponse, error) {
return &RemoveInboundResponse{}, s.ihm.RemoveHandler(ctx, request.Tag)
}
func (s *handlerServer) AlterInbound(ctx context.Context, request *AlterInboundRequest) (*AlterInboundResponse, error) {
rawOperation, err := request.Operation.GetInstance()
if err != nil {
return nil, newError("unknown operation").Base(err)
}
operation, ok := rawOperation.(InboundOperation)
if !ok {
return nil, newError("not an inbound operation")
}
handler, err := s.ihm.GetHandler(ctx, request.Tag)
if err != nil {
return nil, newError("failed to get handler: ", request.Tag).Base(err)
}
return &AlterInboundResponse{}, operation.ApplyInbound(ctx, handler)
}
func (s *handlerServer) AddOutbound(ctx context.Context, request *AddOutboundRequest) (*AddOutboundResponse, error) {
rawHandler, err := s.s.CreateObject(request.Outbound)
if err != nil {
return nil, err
}
handler, ok := rawHandler.(core.OutboundHandler)
if !ok {
return nil, newError("not an OutboundHandler.")
}
return &AddOutboundResponse{}, s.ohm.AddHandler(ctx, handler)
}
func (s *handlerServer) RemoveOutbound(ctx context.Context, request *RemoveOutboundRequest) (*RemoveOutboundResponse, error) {
return &RemoveOutboundResponse{}, s.ohm.RemoveHandler(ctx, request.Tag)
}
func (s *handlerServer) AlterOutbound(ctx context.Context, request *AlterOutboundRequest) (*AlterOutboundResponse, error) {
rawOperation, err := request.Operation.GetInstance()
if err != nil {
return nil, newError("unknown operation").Base(err)
}
operation, ok := rawOperation.(OutboundOperation)
if !ok {
return nil, newError("not an outbound operation")
}
handler := s.ohm.GetHandler(request.Tag)
return &AlterOutboundResponse{}, operation.ApplyOutbound(ctx, handler)
}
2018-02-08 17:24:35 -05:00
type service struct {
v *core.Instance
2018-02-05 17:38:24 -05:00
}
2018-02-08 17:24:35 -05:00
func (s *service) Register(server *grpc.Server) {
RegisterHandlerServiceServer(server, &handlerServer{
s: s.v,
ihm: s.v.InboundHandlerManager(),
ohm: s.v.OutboundHandlerManager(),
})
2018-02-08 09:39:46 -05:00
}
2018-02-05 17:38:24 -05:00
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, cfg interface{}) (interface{}, error) {
s := core.FromContext(ctx)
if s == nil {
return nil, newError("V is not in context.")
}
2018-02-08 17:24:35 -05:00
return &service{v: s}, nil
2018-02-05 17:38:24 -05:00
}))
}