Netconf rpc - add as feature

README.md

@@ -79,6 +79,11 @@ States map to human readable names like this:
 4 = "Ex-Incr"
 5 = "Ex-Full"
 ```
+* VirtualChassis (status of members)
+```
+0 = "NotPrsnt"
+1 = "NotPrsnt"
+```
 * VRRP (state per interface)
 States map to human readable names like this:
 ```   

accounting/collector.go

@@ -96,9 +96,16 @@ func (c *accountingCollector) Collect(client *rpc.Client, ch chan<- prometheus.M
 
 func (c *accountingCollector) accountingFlows(client *rpc.Client) (*AccountingFlow, error) {
 	var x = AccountingFlowRpc{}
-	err := client.RunCommandAndParse("show services accounting flow inline-jflow", &x)
-	if err != nil {
-		return nil, err
+	if client.Netconf {
+		err := client.RunCommandAndParse("<get-service-accounting-error-inline-jflow-information></get-service-accounting-error-inline-jflow-information>", &x)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		err := client.RunCommandAndParse("show services accounting flow inline-jflow", &x)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	if x.Error.Message != "" {
@@ -119,9 +126,16 @@ func (c *accountingCollector) accountingFlows(client *rpc.Client) (*AccountingFl
 
 func (c *accountingCollector) accountingFailures(client *rpc.Client) (*AccountingError, error) {
 	var x = AccountingFlowErrorRpc{}
-	err := client.RunCommandAndParse("show services accounting errors inline-jflow fpc-slot 0", &x)
-	if err != nil {
-		return nil, err
+	if client.Netconf {
+		err := client.RunCommandAndParse("<get-service-accounting-error-inline-jflow-information><inline-jflow-error-information>0</inline-jflow-error-information></get-service-accounting-error-inline-jflow-information>", &x)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		err := client.RunCommandAndParse("show services accounting errors inline-jflow fpc-slot 0", &x)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	return &AccountingError{

alarm/collector.go

@@ -78,6 +78,13 @@ func (c *alarmCollector) alarmCounter(client *rpc.Client) (*AlarmCounter, *[]Ala
 		"show chassis alarms",
 	}
 
+	if client.Netconf {
+		cmds = []string{
+			"<get-system-alarm-information/>",
+			"<get-alarm-information/>",
+		}
+	}
+
 	var alarms []AlarmDetails
 
 	messages := make(map[string]interface{})

bfd/collector.go

@@ -41,10 +41,17 @@ func (*bfdCollector) Describe(ch chan<- *prometheus.Desc) {
 
 // Collect collects metrics from JunOS
 func (c *bfdCollector) Collect(client *rpc.Client, ch chan<- prometheus.Metric, labelValues []string) error {
-	var x = bfdRpc{}
-	err := client.RunCommandAndParse("show bfd session extensive", &x)
-	if err != nil {
-		return err
+        var x = bfdRpc{}
+	if client.Netconf {
+		err := client.RunCommandAndParse("<get-bfd-session-information><extensive/></get-bfd-session-information>", &x)
+		if err != nil {
+			return err
+		}
+	} else {
+	        err := client.RunCommandAndParse("show bfd session extensive", &x)
+		if err != nil {
+			return err
+		}
 	}
 
 	for _, bfds := range x.Information.BfdSessions {

bgp/collector.go

@@ -77,16 +77,21 @@ func (c *bgpCollector) Collect(client *rpc.Client, ch chan<- prometheus.Metric,
 func (c *bgpCollector) collect(client *rpc.Client, ch chan<- prometheus.Metric, labelValues []string) error {
 	var x = BGPRPC{}
 	var cmd strings.Builder
-	cmd.WriteString("show bgp neighbor")
-	if c.LogicalSystem != "" {
-		cmd.WriteString(" logical-system " + c.LogicalSystem)
+	if client.Netconf {
+		cmd.WriteString("<get-bgp-neighbor-information/>")
+	} else {
+		cmd.WriteString("show bgp neighbor")
+		if c.LogicalSystem != "" {
+			cmd.WriteString(" logical-system " + c.LogicalSystem)
+		}
 	}
 
 	err := client.RunCommandAndParse(cmd.String(), &x)
 	if err != nil {
 		return err
 	}
 
+
 	for _, peer := range x.Information.Peers {
 		c.collectForPeer(peer, ch, labelValues)
 	}

collectors.go

@@ -33,6 +33,7 @@ import (
 	"github.com/czerwonk/junos_exporter/security"
 	"github.com/czerwonk/junos_exporter/storage"
 	"github.com/czerwonk/junos_exporter/system"
+	"github.com/czerwonk/junos_exporter/virtualchassis"
 	"github.com/czerwonk/junos_exporter/vrrp"
 	"github.com/czerwonk/junos_exporter/vpws"
 )
@@ -105,6 +106,7 @@ func (c *collectors) initCollectorsForDevices(device *connector.Device) {
 	c.addCollectorIfEnabledForDevice(device, "system", f.System, system.NewCollector)
 	c.addCollectorIfEnabledForDevice(device, "power", f.Power, power.NewCollector)
 	c.addCollectorIfEnabledForDevice(device, "mac", f.MAC, mac.NewCollector)
+	c.addCollectorIfEnabledForDevice(device, "virtualchassis", f.VirtualChassis, virtualchassis.NewCollector)
 	c.addCollectorIfEnabledForDevice(device, "vrrp", f.VRRP, vrrp.NewCollector)
 	c.addCollectorIfEnabledForDevice(device, "vpws", f.VPWS, vpws.NewCollector)
 	c.addCollectorIfEnabledForDevice(device, "mpls_lsp", f.MPLS_LSP, mpls_lsp.NewCollector)

config/config.go

@@ -57,10 +57,12 @@ type FeatureConfig struct {
 	RPKI                bool `yaml:"rpki,omitempty"`
 	RPM                 bool `yaml:"rpm,omitempty"`
 	Satellite           bool `yaml:"satellite,omitempty"`
+	Netconf             bool `yaml:"netconf,omitempty"`
 	System              bool `yaml:"system,omitempty"`
 	Power               bool `yaml:"power,omitempty"`
 	MAC                 bool `yaml:"mac,omitempty"`
 	MPLS_LSP            bool `yaml:"mpls_lsp,omitempty"`
+	VirtualChassis      bool `yaml:"virtualchassis,omitempty"`
 	VPWS                bool `yaml:"vpws,omitempty"`
 	VRRP                bool `yaml:"vrrp,omitempty"`
 }
@@ -127,9 +129,11 @@ func setDefaultValues(c *Config) {
 	f.RPKI = false
 	f.RPM = false
 	f.Satellite = false
+	f.Netconf = false
 	f.Power = false
 	f.MAC = false
 	f.MPLS_LSP = false
+	f.VirtualChassis = false
 	f.VPWS = false
 	f.VRRP = false
 	f.BFD = false

connector/connection.go

@@ -4,10 +4,12 @@ import (
 	"bytes"
 	"net"
 	"sync"
-
+	"fmt"
+	"io"
 	"github.com/pkg/errors"
 
 	"golang.org/x/crypto/ssh"
+	"github.com/Juniper/go-netconf/netconf"
 )
 
 // SSHConnection encapsulates the connection to the device
@@ -17,10 +19,27 @@ type SSHConnection struct {
 	conn   net.Conn
 	mu     sync.Mutex
 	done   chan struct{}
+	netconf bool
+	netconfsession *netconf.Session
+}
+
+type TransportSSH struct {
+    transportBasicIO
+    sshClient  *ssh.Client
+    sshSession *ssh.Session
 }
 
+
 // RunCommand runs a command against the device
 func (c *SSHConnection) RunCommand(cmd string) ([]byte, error) {
+	if c.netconf	{
+		return c.RunCommandNETCONF(cmd)
+	} else {
+		return c.RunCommandSSH(cmd)
+	}
+}
+
+func (c *SSHConnection) RunCommandSSH(cmd string) ([]byte, error) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
@@ -45,6 +64,53 @@ func (c *SSHConnection) RunCommand(cmd string) ([]byte, error) {
 	return b.Bytes(), nil
 }
 
+
+func (c *SSHConnection) RunCommandNETCONF(cmd string) ([]byte, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	var err error
+
+	if c.client == nil {
+		return nil, errors.New("not connected")
+	}
+
+	t := &TransportSSH{}
+	if c.netconfsession == nil {
+		t.sshSession, err = c.client.NewSession()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not open session")
+		}
+
+		writer, err := t.sshSession.StdinPipe()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not open session stdin")
+		}
+
+		reader, err := t.sshSession.StdoutPipe()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not open session stdout")
+		}
+
+		t.ReadWriteCloser = netconf.NewReadWriteCloser(reader, writer)
+		t.sshSession.RequestSubsystem("netconf")
+		c.netconfsession = netconf.NewSession(t)
+	}
+
+	reply, err := c.netconfsession.Exec(netconf.RawMethod(cmd))
+
+	if err != nil {
+		if err == io.EOF {
+			//probably lost the session, closing to force a reopen
+			fmt.Println("Error - Closing")
+			c.netconfsession.Close()
+			c.netconfsession = nil
+		}
+		return nil, errors.Wrap(err, "could not run command")
+	}
+
+	return []byte(reply.RawReply), nil
+}
+
 func (c *SSHConnection) isConnected() bool {
 	return c.conn != nil
 }

connector/connection_manager.go

@@ -32,13 +32,15 @@ func WithKeepAliveInterval(d time.Duration) Option {
 	}
 }
 
+
 // WithKeepAliveTimeout sets the timeout after an ssh connection to be determined dead (default 15 seconds)
 func WithKeepAliveTimeout(d time.Duration) Option {
 	return func(m *SSHConnectionManager) {
 		m.keepAliveTimeout = d
 	}
 }
 
+
 // SSHConnectionManager manages SSH connections to different devices
 type SSHConnectionManager struct {
 	connections       map[string]*SSHConnection
@@ -65,7 +67,7 @@ func NewConnectionManager(opts ...Option) *SSHConnectionManager {
 }
 
 // Connect connects to a device or returns an long living connection
-func (m *SSHConnectionManager) Connect(device *Device) (*SSHConnection, error) {
+func (m *SSHConnectionManager) Connect(device *Device, netconf bool) (*SSHConnection, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
@@ -77,10 +79,10 @@ func (m *SSHConnectionManager) Connect(device *Device) (*SSHConnection, error) {
 		return connection, nil
 	}
 
-	return m.connect(device)
+	return m.connect(device, netconf)
 }
 
-func (m *SSHConnectionManager) connect(device *Device) (*SSHConnection, error) {
+func (m *SSHConnectionManager) connect(device *Device, netconf bool) (*SSHConnection, error) {
 	client, conn, err := m.connectToDevice(device)
 	if err != nil {
 		return nil, err
@@ -91,6 +93,7 @@ func (m *SSHConnectionManager) connect(device *Device) (*SSHConnection, error) {
 		client: client,
 		device: device,
 		done:   make(chan struct{}),
+		netconf: netconf,
 	}
 	go m.keepAlive(c)