Example #1
0
//Request is the base level method upon which all protocolink requests are handled
//for the sake of being a valid protcollink it implements the method signature
// (string,io.Reader) but for flexibilty string
func (h *SSHProtocolLink) Request(path string, body io.Reader) flux.ActionStackInterface {

	req := flux.NewAction()
	err := flux.NewAction()
	act := req.Chain(2)
	st := flux.NewActionStackBy(act, err)

	if h.conn == nil {
		st.Complete(ErrorNoConnection)
		return st
	}

	act.OverrideBefore(1, func(b interface{}, next flux.ActionInterface) {
		se, ok := b.(*SSHClientSession)

		if !ok {
			return
		}

		se.Close()
		next.Fullfill(b)
	})

	session, erro := h.conn.NewSession()

	if erro != nil {
		st.Complete(erro)
	} else {
		st.Complete(NewSSHClientSession(session, body))
	}

	return st

}
Example #2
0
//FS creates a ftp client on the remote connection and allows file base op
func (h *SSHProtocolLink) FS() flux.ActionStackInterface {
	req := flux.NewAction()
	eo := flux.NewAction()
	st := flux.NewActionStackBy(req, eo)

	ch := req.Chain(2)

	ch.OverrideBefore(1, func(b interface{}, next flux.ActionInterface) {
		ce, ok := b.(*sftp.Client)

		if !ok {
			return
		}

		ce.Close()
	})

	cl, err := sftp.NewClient(h.conn)

	if err != nil {
		st.Complete(err)
	} else {
		st.Complete(cl)
	}

	return st
}
Example #3
0
//NewPayloadRack returns a new instance of the payloadrack
func NewPayloadRack(timeout int, fx Failure) *PayloadRack {
	p := &PayloadRack{
		make(chan interface{}),
		time.Duration(timeout) * time.Millisecond,
		flux.NewAction(),
		flux.NewAction(),
		new(sync.Once),
	}

	if fx != nil {
		fx(p.Failed())
	}

	return p
}
Example #4
0
//RSASSHProtocolLink returns a new sshProtocollink to communicate with ssh servers
//you pass
func RSASSHProtocolLink(service, addr string, port int, user string, pkeyFile string) *SSHProtocolLink {

	pbytes, err := ioutil.ReadFile(pkeyFile)

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

	private, err := ssh.ParsePrivateKey(pbytes)

	if err != nil {
		log.Println(fmt.Sprintf("ParseError:(%s):", pkeyFile), err)
		panic("Failed to parse private key")
	}

	auth := []ssh.AuthMethod{
		ssh.PublicKeys(private),
	}

	config := &ssh.ClientConfig{
		User: user,
		Auth: auth,
	}

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

	nsh := &SSHProtocolLink{
		NewProtocolLink(desc),
		config,
		nil,
		flux.NewAction(),
	}

	return nsh
}
Example #5
0
//PasswordSSHProtocolLink returns a new sshProtocollink to communicate with ssh servers
//you pass
func PasswordSSHProtocolLink(service, addr string, port int, user string, password string) *SSHProtocolLink {

	auth := []ssh.AuthMethod{
		ssh.Password(password),
	}

	config := &ssh.ClientConfig{
		User: user,
		Auth: auth,
	}

	desc := NewDescriptor("ssh", service, addr, port, "0", "ssh")
	//should we store the password?
	// desc.Misc["password"]=password

	nsh := &SSHProtocolLink{
		NewProtocolLink(desc),
		config,
		nil,
		flux.NewAction(),
	}

	return nsh
}
Example #6
0
//Request is the base level method upon which all protocolink requests are handled
func (h *HTTPProtocolLink) Request(path string, body io.Reader) flux.ActionStackInterface {
	log.Printf("Initiating HTTPLink: New HTTP Request for %s", path)
	addr := fmt.Sprintf("%s:%d/%s", h.Descriptor().Address, h.Descriptor().Port, h.Descriptor().Service)
	addr = ExcessSlash.ReplaceAllString(addr, "/")
	addr = EndSlash.ReplaceAllString(addr, "")
	path = ExcessSlash.ReplaceAllString(path, "/")
	path = EndSlash.ReplaceAllString(path, "")
	resuri := fmt.Sprintf("%s/%s", addr, path)
	resuri = ExcessSlash.ReplaceAllString(resuri, "/")
	url := fmt.Sprintf("%s://%s", h.Descriptor().Scheme, resuri)

	log.Printf("HTTPLink: New HTTP Request for %s", url)

	red := flux.NewAction()
	erd := flux.NewAction()

	act := red.Chain(3)

	//we do these so we can override what happens after the user adds all they
	//want on the request
	act.OverrideBefore(1, func(b interface{}, next flux.ActionInterface) {
		rq, ok := b.(*http.Request)

		if !ok {
			// next.Fullfill(b interface)
			return
		}

		rq.Header.Set("X-Service-Request", h.Descriptor().Service)

		log.Printf("HTTPLink: Request Header Set,Initiaing RequestClient Sending...")
		res, err := h.client.Do(rq)

		if err == nil {
			log.Printf("HTTPLink: Recieved Request (%s) Response Status: %d", rq.URL, res.StatusCode)
		} else {
			log.Printf("HTTPLink: Recieved Request (%s) Response Error: %v", rq.URL, err)
		}

		pck := NewHTTPPacket(res, rq, err)

		next.Fullfill(pck)
	})

	cl := flux.NewActionStackBy(act, erd)

	var req *http.Request
	var err error

	if body == nil {
		req, err = http.NewRequest("GET", url, body)

		if err != nil {
			cl.Complete(err)
			return cl
		}

	} else {
		req, err = http.NewRequest("POST", url, body)

		if err != nil {
			cl.Complete(err)
			return cl
		}
	}

	log.Printf("HTTPLink: Initiating Http Request Method: (%+s), URI: (%+s)", req.Method, req.URL)

	cl.Complete(req)

	return cl
}