go-netconf: github.com/Juniper/go-netconf/netconf Index | Files

package netconf

import "github.com/Juniper/go-netconf/netconf"

This library is a simple NETCONF client based on RFC6241 and RFC6242 (although not fully compliant yet).

Index

Package Files

rpc.go session.go transport.go transport_junos.go transport_ssh.go

Variables

var DefaultCapabilities = []string{
    "urn:ietf:params:netconf:base:1.0",
}

DefaultCapabilities sets the default capabilities of the client library

func SSHConfigPassword Uses

func SSHConfigPassword(user string, pass string) *ssh.ClientConfig

SSHConfigPassword is a convenience function that takes a username and password and returns a new ssh.ClientConfig setup to pass that username and password. Convenience means that HostKey checks are disabled so it's probably less secure

func SSHConfigPubKeyAgent Uses

func SSHConfigPubKeyAgent(user string) (*ssh.ClientConfig, error)

SSHConfigPubKeyAgent is a convience function that takes a username and returns a new ssh.Clientconfig setup to pass credentials received from an ssh agent

func SSHConfigPubKeyFile Uses

func SSHConfigPubKeyFile(user string, file string, passphrase string) (*ssh.ClientConfig, error)

SSHConfigPubKeyFile is a convenience function that takes a username, private key and passphrase and returns a new ssh.ClientConfig setup to pass credentials to DialSSH

type HelloMessage Uses

type HelloMessage struct {
    XMLName      xml.Name `xml:"urn:ietf:params:xml:ns:netconf:base:1.0 hello"`
    Capabilities []string `xml:"capabilities>capability"`
    SessionID    int      `xml:"session-id,omitempty"`
}

HelloMessage is used when bringing up a NETCONF session

type RPCError Uses

type RPCError struct {
    Type     string `xml:"error-type"`
    Tag      string `xml:"error-tag"`
    Severity string `xml:"error-severity"`
    Path     string `xml:"error-path"`
    Message  string `xml:"error-message"`
    Info     string `xml:",innerxml"`
}

RPCError defines an error reply to a RPC request

func (*RPCError) Error Uses

func (re *RPCError) Error() string

Error generates a string representation of the provided RPC error

type RPCMessage Uses

type RPCMessage struct {
    MessageID string
    Methods   []RPCMethod
}

RPCMessage represents an RPC Message to be sent.

func NewRPCMessage Uses

func NewRPCMessage(methods []RPCMethod) *RPCMessage

NewRPCMessage generates a new RPC Message structure with the provided methods

func (*RPCMessage) MarshalXML Uses

func (m *RPCMessage) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML marshals the NETCONF XML data

type RPCMethod Uses

type RPCMethod interface {
    MarshalMethod() string
}

RPCMethod defines the interface for creating an RPC method.

type RPCReply Uses

type RPCReply struct {
    XMLName  xml.Name   `xml:"rpc-reply"`
    Errors   []RPCError `xml:"rpc-error,omitempty"`
    Data     string     `xml:",innerxml"`
    Ok       bool       `xml:",omitempty"`
    RawReply string     `xml:"-"`
}

RPCReply defines a reply to a RPC request

type RawMethod Uses

type RawMethod string

RawMethod defines how a raw text request will be responded to

func MethodGetConfig Uses

func MethodGetConfig(source string) RawMethod

MethodGetConfig files a NETCONF get-config source request with the remote host

func MethodLock Uses

func MethodLock(target string) RawMethod

MethodLock files a NETCONF lock target request with the remote host

func MethodUnlock Uses

func MethodUnlock(target string) RawMethod

MethodUnlock files a NETCONF unlock target request with the remote host

func (RawMethod) MarshalMethod Uses

func (r RawMethod) MarshalMethod() string

MarshalMethod converts the method's output into a string

type ReadWriteCloser Uses

type ReadWriteCloser struct {
    io.Reader
    io.WriteCloser
}

ReadWriteCloser represents a combined IO Reader and WriteCloser

func NewReadWriteCloser Uses

func NewReadWriteCloser(r io.Reader, w io.WriteCloser) *ReadWriteCloser

NewReadWriteCloser creates a new combined IO Reader and Write Closer from the provided objects

type Session Uses

type Session struct {
    Transport          Transport
    SessionID          int
    ServerCapabilities []string
    ErrOnWarning       bool
}

Session defines the necessary components for a NETCONF session

func DialJunos Uses

func DialJunos() (*Session, error)

DialJunos creates a new NETCONF session via Junos local shell NETCONF interface (xml-mode netconf need-trailer).

func DialSSH Uses

func DialSSH(target string, config *ssh.ClientConfig) (*Session, error)

DialSSH creates a new NETCONF session using a SSH Transport. See TransportSSH.Dial for arguments.

func DialSSHTimeout Uses

func DialSSHTimeout(target string, config *ssh.ClientConfig, timeout time.Duration) (*Session, error)

DialSSHTimeout creates a new NETCONF session using a SSH Transport with timeout. See TransportSSH.Dial for arguments. The timeout value is used for both connection establishment and Read/Write operations.

func NewSSHSession Uses

func NewSSHSession(conn net.Conn, config *ssh.ClientConfig) (*Session, error)

NewSSHSession creates a new NETCONF session using an existing net.Conn.

func NewSession Uses

func NewSession(t Transport) *Session

NewSession creates a new NETCONF session using the provided transport layer.

func (*Session) Close Uses

func (s *Session) Close() error

Close is used to close and end a transport session

func (*Session) Exec Uses

func (s *Session) Exec(methods ...RPCMethod) (*RPCReply, error)

Exec is used to execute an RPC method or methods

type Transport Uses

type Transport interface {
    Send([]byte) error
    Receive() ([]byte, error)
    Close() error
    ReceiveHello() (*HelloMessage, error)
    SendHello(*HelloMessage) error
}

Transport interface defines what characterisitics make up a NETCONF transport layer object.

type TransportJunos Uses

type TransportJunos struct {
    // contains filtered or unexported fields
}

TransportJunos maintains the information necessary to communicate with Junos via local shell NETCONF interface.

func (*TransportJunos) Close Uses

func (t *TransportJunos) Close() error

Close closes an existing local NETCONF session.

func (*TransportJunos) Open Uses

func (t *TransportJunos) Open() error

Open creates a new local NETCONF session.

func (*TransportJunos) Receive Uses

func (t *TransportJunos) Receive() ([]byte, error)

func (*TransportJunos) ReceiveHello Uses

func (t *TransportJunos) ReceiveHello() (*HelloMessage, error)

func (*TransportJunos) Send Uses

func (t *TransportJunos) Send(data []byte) error

Sends a well formated NETCONF rpc message as a slice of bytes adding on the nessisary framining messages.

func (*TransportJunos) SendHello Uses

func (t *TransportJunos) SendHello(hello *HelloMessage) error

func (*TransportJunos) WaitForBytes Uses

func (t *TransportJunos) WaitForBytes(b []byte) ([]byte, error)

func (*TransportJunos) WaitForFunc Uses

func (t *TransportJunos) WaitForFunc(f func([]byte) (int, error)) ([]byte, error)

func (*TransportJunos) WaitForRegexp Uses

func (t *TransportJunos) WaitForRegexp(re *regexp.Regexp) ([]byte, [][]byte, error)

func (*TransportJunos) WaitForString Uses

func (t *TransportJunos) WaitForString(s string) (string, error)

func (*TransportJunos) Writeln Uses

func (t *TransportJunos) Writeln(b []byte) (int, error)

type TransportSSH Uses

type TransportSSH struct {
    // contains filtered or unexported fields
}

TransportSSH maintains the information necessary to communicate with the remote device over SSH

func (*TransportSSH) Close Uses

func (t *TransportSSH) Close() error

Close closes an existing SSH session and socket if they exist.

func (*TransportSSH) Dial Uses

func (t *TransportSSH) Dial(target string, config *ssh.ClientConfig) error

Dial connects and establishes SSH sessions

target can be an IP address (e.g.) 172.16.1.1 which utlizes the default NETCONF over SSH port of 830. Target can also specify a port with the following format <host>:<port (e.g 172.16.1.1:22)

config takes a ssh.ClientConfig connection. See documentation for go.crypto/ssh for documenation. There is a helper function SSHConfigPassword thar returns a ssh.ClientConfig for simple username/password authentication

func (*TransportSSH) Receive Uses

func (t *TransportSSH) Receive() ([]byte, error)

func (*TransportSSH) ReceiveHello Uses

func (t *TransportSSH) ReceiveHello() (*HelloMessage, error)

func (*TransportSSH) Send Uses

func (t *TransportSSH) Send(data []byte) error

Sends a well formated NETCONF rpc message as a slice of bytes adding on the nessisary framining messages.

func (*TransportSSH) SendHello Uses

func (t *TransportSSH) SendHello(hello *HelloMessage) error

func (*TransportSSH) WaitForBytes Uses

func (t *TransportSSH) WaitForBytes(b []byte) ([]byte, error)

func (*TransportSSH) WaitForFunc Uses

func (t *TransportSSH) WaitForFunc(f func([]byte) (int, error)) ([]byte, error)

func (*TransportSSH) WaitForRegexp Uses

func (t *TransportSSH) WaitForRegexp(re *regexp.Regexp) ([]byte, [][]byte, error)

func (*TransportSSH) WaitForString Uses

func (t *TransportSSH) WaitForString(s string) (string, error)

func (*TransportSSH) Writeln Uses

func (t *TransportSSH) Writeln(b []byte) (int, error)

Package netconf imports 16 packages (graph) and is imported by 20 packages. Updated 2018-04-26. Refresh now. Tools for package owners.