w
Size: a a a
p
A
A
ВС
ВС
A
E
type SshConnection struct {
Client *ssh.Client
}
ssh := &SshConnection{}
addr := fmt.Sprintf("%s:%s", "remote2.host", "22")
clientConfig := &ssh.ClientConfig{
User: "test",
Auth: []ssh.AuthMethod{
ssh.Password("test"),
},
Timeout: 5 * time.Minute,
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
}
c.Client, err = ssh.Dial("tcp", addr, clientConfig)
if err != nil {
return errors.Wrap(err, "initialize connect")
}
//---------------------------//
asRemoteAddr := fmt.Sprintf("%s:%s",
"remote3.host", "3000")
asLocalAddr := fmt.Sprintf("%s:%s",
"localhost", "3000")
err = ssh.OpenTunnel(asRemoteAddr, asLocalAddr)
if err != nil {
return errors.Wrap(err, "open tunnel for as")
}
//---------------------------//
asClient, err = aerospike.NewClient("localhost", 3000)
if err != nil {
panic(err)
}
type SshConnection struct {
Client *ssh.Client
}
ssh := &SshConnection{}
addr := fmt.Sprintf("%s:%s", "remote2.host", "22")
clientConfig := &ssh.ClientConfig{
User: "test",
Auth: []ssh.AuthMethod{
ssh.Password("test"),
},
Timeout: 5 * time.Minute,
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
}
c.Client, err = ssh.Dial("tcp", addr, clientConfig)
if err != nil {
return errors.Wrap(err, "initialize connect")
}
//---------------------------//
asRemoteAddr := fmt.Sprintf("%s:%s",
"remote3.host", "3000")
asLocalAddr := fmt.Sprintf("%s:%s",
"localhost", "3000")
err = ssh.OpenTunnel(asRemoteAddr, asLocalAddr)
if err != nil {
return errors.Wrap(err, "open tunnel for as")
}
//---------------------------//
asClient, err = aerospike.NewClient("localhost", 3000)
if err != nil {
panic(err)
}
//---------------------------//
func (c *SshConnection) OpenTunnel(remoteAddr, localAddr string) error {
remote, err := c.Client.Dial("tcp", remoteAddr)
if err != nil {
return errors.Wrap(err, "open remote connection")
}
local, err := net.Listen("tcp", localAddr)
if err != nil {
return errors.Wrap(err, "open local connection")
}
go func(remote net.Conn, local net.Listener) {
defer remote.Close()
defer local.Close()
for {
l, err := local.Accept()
if err != nil {
log.Fatalf("tunnel: listen Accept failed %s", err)
}
go func() {
_, err := io.Copy(l, remote)
if err != nil {
log.Fatalf("tunnel: io.Copy failed: %v", err)
}
}()
go func() {
_, err := io.Copy(remote, l)
if err != nil {
log.Fatalf("tunnel: io.Copy failed: %v", err)
}
}()
}
}(remote, local)
return nil
}
AS
type SshConnection struct {
Client *ssh.Client
}
ssh := &SshConnection{}
addr := fmt.Sprintf("%s:%s", "remote2.host", "22")
clientConfig := &ssh.ClientConfig{
User: "test",
Auth: []ssh.AuthMethod{
ssh.Password("test"),
},
Timeout: 5 * time.Minute,
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
}
c.Client, err = ssh.Dial("tcp", addr, clientConfig)
if err != nil {
return errors.Wrap(err, "initialize connect")
}
//---------------------------//
asRemoteAddr := fmt.Sprintf("%s:%s",
"remote3.host", "3000")
asLocalAddr := fmt.Sprintf("%s:%s",
"localhost", "3000")
err = ssh.OpenTunnel(asRemoteAddr, asLocalAddr)
if err != nil {
return errors.Wrap(err, "open tunnel for as")
}
//---------------------------//
asClient, err = aerospike.NewClient("localhost", 3000)
if err != nil {
panic(err)
}
//---------------------------//
func (c *SshConnection) OpenTunnel(remoteAddr, localAddr string) error {
remote, err := c.Client.Dial("tcp", remoteAddr)
if err != nil {
return errors.Wrap(err, "open remote connection")
}
local, err := net.Listen("tcp", localAddr)
if err != nil {
return errors.Wrap(err, "open local connection")
}
go func(remote net.Conn, local net.Listener) {
defer remote.Close()
defer local.Close()
for {
l, err := local.Accept()
if err != nil {
log.Fatalf("tunnel: listen Accept failed %s", err)
}
go func() {
_, err := io.Copy(l, remote)
if err != nil {
log.Fatalf("tunnel: io.Copy failed: %v", err)
}
}()
go func() {
_, err := io.Copy(remote, l)
if err != nil {
log.Fatalf("tunnel: io.Copy failed: %v", err)
}
}()
}
}(remote, local)
return nil
}
E
func (c *SshConnection) OpenTunnel(remoteAddr, localAddr string) error {
remote, err := c.Client.Dial("tcp", remoteAddr)
if err != nil {
return errors.Wrap(err, "open remote connection")
}
local, err := net.Listen("tcp", localAddr)
if err != nil {
return errors.Wrap(err, "open local connection")
}
go func(remote net.Conn, local net.Listener) {
defer remote.Close()
defer local.Close()
for {
l, err := local.Accept()
if err != nil {
log.Fatalf("tunnel: listen Accept failed %s", err)
}
go func() {
_, err := io.Copy(l, remote)
if err != nil {
log.Fatalf("tunnel: io.Copy failed: %v", err)
}
}()
go func() {
_, err := io.Copy(remote, l)
if err != nil {
log.Fatalf("tunnel: io.Copy failed: %v", err)
}
}()
}
}(remote, local)
return nil
}
E
AS
func (c *SshConnection) OpenTunnel(remoteAddr, localAddr string) error {
remote, err := c.Client.Dial("tcp", remoteAddr)
if err != nil {
return errors.Wrap(err, "open remote connection")
}
local, err := net.Listen("tcp", localAddr)
if err != nil {
return errors.Wrap(err, "open local connection")
}
go func(remote net.Conn, local net.Listener) {
defer remote.Close()
defer local.Close()
for {
l, err := local.Accept()
if err != nil {
log.Fatalf("tunnel: listen Accept failed %s", err)
}
go func() {
_, err := io.Copy(l, remote)
if err != nil {
log.Fatalf("tunnel: io.Copy failed: %v", err)
}
}()
go func() {
_, err := io.Copy(remote, l)
if err != nil {
log.Fatalf("tunnel: io.Copy failed: %v", err)
}
}()
}
}(remote, local)
return nil
}
E
AS
E
AS
E
ВС
ZH
E