func NewRouter(ctx context.Context, config *Config) (*Router, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("Router: No space in context.")
}
r := &Router{
domainStrategy: config.DomainStrategy,
rules: make([]Rule, len(config.Rule)),
}
space.OnInitialize(func() error {
for idx, rule := range config.Rule {
r.rules[idx].Tag = rule.Tag
cond, err := rule.BuildCondition()
if err != nil {
return err
}
r.rules[idx].Condition = cond
}
r.dnsServer = dns.FromSpace(space)
if r.dnsServer == nil {
return errors.New("Router: DNS is not found in the space.")
}
return nil
})
return r, nil
}
func New(ctx context.Context, config *Config) (*Handler, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("Freedom: No space in context.")
}
f := &Handler{
domainStrategy: config.DomainStrategy,
timeout: config.Timeout,
destOverride: config.DestinationOverride,
}
space.OnInitialize(func() error {
if config.DomainStrategy == Config_USE_IP {
f.dns = dns.FromSpace(space)
if f.dns == nil {
return errors.New("Freedom: DNS server is not found in the space.")
}
}
return nil
})
return f, nil
}
// NewPoint returns a new Point server based on given configuration.
// The server is not started at this point.
func NewPoint(pConfig *Config) (*Point, error) {
var vpoint = new(Point)
if err := pConfig.Transport.Apply(); err != nil {
return nil, err
}
if err := pConfig.Log.Apply(); err != nil {
return nil, err
}
space := app.NewSpace()
ctx := app.ContextWithSpace(context.Background(), space)
vpoint.space = space
outboundHandlerManager := proxyman.OutboundHandlerManagerFromSpace(space)
if outboundHandlerManager == nil {
o, err := app.CreateAppFromConfig(ctx, new(proxyman.OutboundConfig))
if err != nil {
return nil, err
}
space.AddApplication(o)
outboundHandlerManager = o.(proxyman.OutboundHandlerManager)
}
inboundHandlerManager := proxyman.InboundHandlerManagerFromSpace(space)
if inboundHandlerManager == nil {
o, err := app.CreateAppFromConfig(ctx, new(proxyman.InboundConfig))
if err != nil {
return nil, err
}
space.AddApplication(o)
inboundHandlerManager = o.(proxyman.InboundHandlerManager)
}
for _, appSettings := range pConfig.App {
settings, err := appSettings.GetInstance()
if err != nil {
return nil, err
}
application, err := app.CreateAppFromConfig(ctx, settings)
if err != nil {
return nil, err
}
if err := space.AddApplication(application); err != nil {
return nil, err
}
}
dnsServer := dns.FromSpace(space)
if dnsServer == nil {
dnsConfig := &dns.Config{
NameServers: []*v2net.Endpoint{{
Address: v2net.NewIPOrDomain(v2net.LocalHostDomain),
}},
}
d, err := app.CreateAppFromConfig(ctx, dnsConfig)
if err != nil {
return nil, err
}
space.AddApplication(d)
dnsServer = d.(dns.Server)
}
disp := dispatcher.FromSpace(space)
if disp == nil {
d, err := app.CreateAppFromConfig(ctx, new(dispatcher.Config))
if err != nil {
return nil, err
}
space.AddApplication(d)
disp = d.(dispatcher.Interface)
}
for _, inbound := range pConfig.Inbound {
if err := inboundHandlerManager.AddHandler(ctx, inbound); err != nil {
return nil, err
}
}
for _, outbound := range pConfig.Outbound {
if err := outboundHandlerManager.AddHandler(ctx, outbound); err != nil {
return nil, err
}
}
if err := vpoint.space.Initialize(); err != nil {
return nil, err
}
return vpoint, nil
}