func main() {
flag.Parse()
if *username == "" {
fmt.Printf("Enter a valid username: "******"<get-system-information/>"))
if err != nil {
panic(err)
}
var q SystemInformation
xml.Unmarshal([]byte(reply.RawReply), &q)
fmt.Printf("hostname: %s\n", q.HostName)
fmt.Printf("model: %s\n", q.HardwareModel)
fmt.Printf("version: %s\n", q.OsVersion)
}
func main() {
sshConfig := &ssh.ClientConfig{
Config: ssh.Config{
Ciphers: []string{"aes128-cbc", "hmac-sha1"},
},
User: "******",
Auth: []ssh.AuthMethod{ssh.Password("mypass")},
}
s, err := netconf.DialSSH("1.1.1.1", sshConfig)
if err != nil {
log.Fatal(err)
}
defer s.Close()
fmt.Println(s.ServerCapabilities)
fmt.Println(s.SessionID)
// Sends raw XML
reply, err := s.Exec(netconf.RawMethod("<get-chassis-inventory/>"))
if err != nil {
panic(err)
}
fmt.Printf("Reply: %+v", reply)
}
// RunCommand Run a command against a host
func (a *JunosAgent) RunCommand(command string) {
r, err := a.Session.Exec(netconf.RawMethod(fmt.Sprintf("<command format=\"ascii\">%s</command>", command)))
if err != nil {
a.returnMsg(r.Data, command, err)
}
v := a.parser.Trim(r.Data)
a.returnMsg(v, command, err)
}
// LoadConfig load a set of configuration data to the device
func (a *JunosAgent) LoadConfig(config string, cfgType CfgType, overwrite bool) {
// pull the config to the agent
// open the configuration mode
// commit the configuration
r, err := a.Session.Exec(netconf.RawMethod(fmt.Sprintf("", config)))
if err != nil {
a.returnMsg(r.Data, "config", err)
}
a.returnMsg(r.Data, "config", err)
}
func main() {
rawMethod := netconf.RawMethod("<traceroute><host>8.8.8.8</host></traceroute>")
s := new(netconf.Session)
var err error
if s, err = netconf.DialSSH("192.168.1.1", netconf.SSHConfigPassword("username", "password")); err != nil {
log.Fatal(err)
} else {
defer s.Close()
}
tr := new(traceroute.TraceRoute)
if ncReply, err := s.Exec(rawMethod); err != nil {
log.Fatal(err)
} else if _, err := tr.ReadXMLFrom(bytes.NewBuffer([]byte(ncReply.Data))); err != nil {
log.Fatal(err)
} else {
tr.WriteCLITo(os.Stdout)
}
}
func foo() {
username := "******"
password := "******"
host := "172.19.100.49"
s, err := netconf.DialSSH(host, netconf.SSHConfigPassword(username, password))
if err != nil {
panic(err)
}
defer s.Close()
fmt.Printf("Session Id: %d\n\n", s.SessionID)
reply, err := s.Exec(netconf.RawMethod("<command format=\"ascii\">show version</command>"))
if err != nil {
panic(err)
}
p := &Parser{}
v := p.Trim(reply.Data)
fmt.Println("REPLY START")
fmt.Printf("%s", v)
fmt.Println("REPLY END")
}
//SetUp sets up vm to with environment
func init() {
gohanRemoteInit := func(env *Environment) {
vm := env.VM
builtins := map[string]interface{}{
"gohan_netconf_open": func(call otto.FunctionCall) otto.Value {
if len(call.ArgumentList) != 2 {
panic("Wrong number of arguments in gohan_netconf_open call.")
}
rawHost, _ := call.Argument(0).Export()
host, ok := rawHost.(string)
if !ok {
return otto.NullValue()
}
rawUserName, _ := call.Argument(1).Export()
userName, ok := rawUserName.(string)
if !ok {
return otto.NullValue()
}
config := util.GetConfig()
publicKeyFile := config.GetString("ssh/key_file", "")
if publicKeyFile == "" {
return otto.NullValue()
}
sshConfig := &ssh.ClientConfig{
User: userName,
Auth: []ssh.AuthMethod{
util.PublicKeyFile(publicKeyFile),
},
}
s, err := netconf.DialSSH(host, sshConfig)
if err != nil {
ThrowOttoException(&call, "Error during gohan_netconf_open: %s", err.Error())
}
value, _ := vm.ToValue(s)
return value
},
"gohan_netconf_close": func(call otto.FunctionCall) otto.Value {
if len(call.ArgumentList) != 1 {
panic("Wrong number of arguments in gohan_netconf_close call.")
}
rawSession, _ := call.Argument(0).Export()
s, ok := rawSession.(*netconf.Session)
if !ok {
ThrowOttoException(&call, "Error during gohan_netconf_close")
}
s.Close()
return otto.NullValue()
},
"gohan_netconf_exec": func(call otto.FunctionCall) otto.Value {
if len(call.ArgumentList) != 2 {
panic("Wrong number of arguments in gohan_netconf_exec call.")
}
rawSession, _ := call.Argument(0).Export()
s, ok := rawSession.(*netconf.Session)
if !ok {
return otto.NullValue()
}
rawCommand, _ := call.Argument(1).Export()
command, ok := rawCommand.(string)
if !ok {
return otto.NullValue()
}
reply, err := s.Exec(netconf.RawMethod(command))
resp := map[string]interface{}{}
if err != nil {
resp["status"] = "error"
resp["output"] = err.Error()
} else {
resp["status"] = "success"
resp["output"] = reply
}
value, _ := vm.ToValue(resp)
return value
},
"gohan_ssh_open": func(call otto.FunctionCall) otto.Value {
if len(call.ArgumentList) != 2 {
panic("Wrong number of arguments in gohan_netconf_open call.")
}
rawHost, _ := call.Argument(0).Export()
host, ok := rawHost.(string)
if !ok {
return otto.NullValue()
}
rawUserName, _ := call.Argument(1).Export()
userName, ok := rawUserName.(string)
if !ok {
return otto.NullValue()
}
config := util.GetConfig()
publicKeyFile := config.GetString("ssh/key_file", "")
if publicKeyFile == "" {
return otto.NullValue()
}
sshConfig := &ssh.ClientConfig{
User: userName,
Auth: []ssh.AuthMethod{
util.PublicKeyFile(publicKeyFile),
},
}
conn, err := ssh.Dial("tcp", host, sshConfig)
if err != nil {
ThrowOttoException(&call, "Error during gohan_ssh_open %s", err)
}
session, err := conn.NewSession()
if err != nil {
ThrowOttoException(&call, "Error during gohan_ssh_open %s", err)
}
value, _ := vm.ToValue(session)
return value
},
"gohan_ssh_close": func(call otto.FunctionCall) otto.Value {
if len(call.ArgumentList) != 1 {
panic("Wrong number of arguments in gohan_netconf_close call.")
}
rawSession, _ := call.Argument(0).Export()
s, ok := rawSession.(*ssh.Session)
if !ok {
ThrowOttoException(&call, "Error during gohan_ssh_close")
}
s.Close()
return otto.NullValue()
},
"gohan_ssh_exec": func(call otto.FunctionCall) otto.Value {
if len(call.ArgumentList) != 2 {
panic("Wrong number of arguments in gohan_netconf_exec call.")
}
rawSession, _ := call.Argument(0).Export()
s, ok := rawSession.(*ssh.Session)
if !ok {
return otto.NullValue()
}
rawCommand, _ := call.Argument(1).Export()
command, ok := rawCommand.(string)
if !ok {
return otto.NullValue()
}
var stdoutBuf bytes.Buffer
s.Stdout = &stdoutBuf
err := s.Run(command)
resp := map[string]interface{}{}
if err != nil {
resp["status"] = "error"
resp["output"] = err.Error()
} else {
resp["status"] = "success"
resp["output"] = stdoutBuf.String()
}
value, _ := vm.ToValue(resp)
return value
},
}
for name, object := range builtins {
vm.Set(name, object)
}
}
RegistInit(gohanRemoteInit)
}
func (*ChassisEnvCmd) Method() netconf.RawMethod {
return netconf.RawMethod(CHASSIS_ENV_CMD_TMPL)
}
func (*ChassisZonesRequest) Method() netconf.RawMethod {
return netconf.RawMethod(CHASSIS_ZONES_REQUEST_TMPL)
}
