Example #1
0
//BaseProtocol returns a new protocol instance
func BaseProtocol(desc *ProtocolDescriptor, rc *RouteConfig) *Protocol {
	return &Protocol{
		NewBase(desc),
		make(chan struct{}),
		NewSessionManager(),
		rc,
		NewRoute(desc.Service, rc.buffer, rc.timeout, rc.fail),
		flux.PushSocket(0),
		flux.PushSocket(0),
		flux.PushSocket(0),
	}
}
Example #2
0
//FromRoute returns a route based on a previous route
func FromRoute(r *Route, path string) *Route {
	return RawRoute(path, flux.DoPushSocket(r.Valid, func(v interface{}, s flux.SocketInterface) {
		req, ok := v.(*Request)

		if !ok {
			return
		}

		nreq := FromRequest(req, nil)

		s.Emit(nreq)
	}), flux.PushSocket(r.DTO), r.DTO, r.fail)
}
Example #3
0
//NewRoute returns a route struct for a specific route path
// which allows us to do NewRoute('{id:[/d+/]}')
//note when using long paths eg /apple/dog/back
//this returns the root path 'apple' and not the final path 'back' route object
func NewRoute(path string, buf int, ts int, fail Failure) *Route {
	vs := splitPatternAndRemovePrefix(path)

	if len(vs) <= 0 {
		panic(fmt.Sprintf("path after split is is %v not valid", vs))
	}

	fs := vs[0]

	if len(vs) > 1 {
		vs = vs[1:]
	} else {
		vs = vs[0:0]
	}

	rw := RawRoute(fs, flux.PushSocket(buf), flux.PushSocket(buf), ts, fail)

	if len(vs) > 0 {
		rw.New(strings.Join(vs, "/"))
	}

	return rw
}
Example #4
0
//PasswordSSHProtocol creates a ssh-server that handles ssh-connections
func PasswordSSHProtocol(rc *RouteConfig, service, addr string, port int, rsaFile string, auth PassAuth) *SSHProtocol {
	pbytes, err := ioutil.ReadFile(rsaFile)

	if err != nil {
		panic(fmt.Sprintf("ReadError %v \nFailed to load private key file: %s", err, rsaFile))
	}

	private, err := ssh.ParsePrivateKey(pbytes)

	if err != nil {
		panic(fmt.Sprintf("ParseError:(%s): \n %s -> %v", rsaFile, "Failed to parse private key!", err))
	}

	desc := NewDescriptor("ssh", service, addr, port, "0", "ssh")

	conf := &ssh.ServerConfig{
		PasswordCallback: auth,
	}

	conf.AddHostKey(private)

	sd := &SSHProtocol{
		BaseProtocol(desc, rc),
		flux.PushSocket(0),
		flux.PushSocket(0),
		flux.PushSocket(0),
		conf,
		nil,
		nil,
		nil,
	}

	setupServer(sd)

	return sd
}
Example #5
0
//InvertRoute returns a route based on a previous route rejection of a request
//provides a divert like or not path logic (i.e if that path does not match the parent route)
//then this gets validate that rejected route)
//the fail action can be set as nil which then uses the previous fail action from
//the previous route
func InvertRoute(r *Route, path string, fail Failure) *Route {
	valids := flux.DoPushSocket(r.Invalid, func(v interface{}, s flux.SocketInterface) {
		req, ok := v.(*Request)

		if !ok {
			return
		}

		s.Emit(req)
	})

	if fail == nil {
		fail = r.fail
	}

	return RawRoute(path, valids, flux.PushSocket(r.DTO), r.DTO, fail)
}