1 files changed, 151 insertions, 0 deletions

diff --git a/clients/netbox/config_file_client.go b/clients/netbox/config_file_client.go
new file mode 100644
index 0000000..6023916
--- /dev/null
+++ b/clients/netbox/config_file_client.go
@@ -0,0 +1,151 @@
+package netbox
+
+import (
+        "context"
+        "encoding/json"
+        "fmt"
+        "io/fs"
+        "net"
+        "path/filepath"
+
+        "github.com/mitchellh/mapstructure"
+        "gopkg.in/yaml.v2"
+)
+
+type ConfigFileNetboxClient struct {
+        cfg map[string]any
+}
+
+var _ NetboxClient = (*ConfigFileNetboxClient)(nil)
+
+// NewConfigFileClient creates a new ConfigFileNetboxClient by loading a
+// named config file from a filesystem and unmarshalling it. The config
+// file can be in JSON or YAML format, determined by a .json, .yaml, or
+// .yml extension. The configuration must be nested within a key in that
+// file to support sharing the file with other subsystems.
+//
+// See method docs for the extected format of this file.
+func NewConfigFileClient(filesystem fs.FS, name, key string) (NetboxClient, error) {
+        fp, err := filesystem.Open(name)
+        if err != nil {
+                return nil, err
+        }
+        defer fp.Close()
+
+        fc := map[string]any{}
+
+        switch e := filepath.Ext(name); e {
+        case ".yaml", ".yml":
+                if err := yaml.NewDecoder(fp).Decode(&fc); err != nil {
+                        return nil, err
+                }
+        case ".json":
+                if err := json.NewDecoder(fp).Decode(&fc); err != nil {
+                        return nil, err
+                }
+        default:
+                return nil, fmt.Errorf("Config files with extension %s are not supported", e)
+        }
+
+        ck, ok := fc[key]
+        if !ok {
+                return nil, fmt.Errorf("Key %s does not exist in config file", key)
+        }
+
+        cfg := map[string]any{}
+        if err := mapstructure.Decode(ck, &cfg); err != nil {
+                return nil, fmt.Errorf("Config file key was not of correct type: %w", err)
+        }
+
+        return &ConfigFileNetboxClient{
+                cfg: cfg,
+        }, nil
+}
+
+// GetSitePrefixesWithTag gets a list of IP prefixes for a site based on
+// some tag.
+//
+// The data format of the config file should be, under the key "sites":
+//
+//  map[string]map[string][]string{
+//      "site_name": map[string][]string{
+//              "tag_name": []string{
+//                      "127.0.0.1/24",
+//              },
+//      },
+//  }
+//
+// In JSON format:
+//
+// { "sites": {
+//     "site": {
+//       "tag_name": [ "127.0.0.1/24" ]
+//     }
+// }
+func (c *ConfigFileNetboxClient) GetSitePrefixesWithTag(ctx context.Context, site string, tag string) ([]*net.IPNet, error) {
+        s, ok := c.cfg["sites"]
+        if !ok {
+                return nil, fmt.Errorf("No key 'sites' in config file")
+        }
+
+        sites := map[string]map[string][]string{}
+        if err := mapstructure.Decode(s, &sites); err != nil {
+                return nil, fmt.Errorf("Key 'sites' not in correct format: %w", err)
+        }
+
+        tags, ok := sites[site]
+        if !ok {
+                return nil, fmt.Errorf("Site %s not in sites", site)
+        }
+
+        values, ok := tags[tag]
+        if !ok {
+                return nil, fmt.Errorf("Tag %s not in tags", tag)
+        }
+
+        return parseValues(values)
+}
+
+// GetPrefixesWithTag gets a list fo IP prefixes based on some tag.
+//
+// The data format of the config file should be, under the key "tags":
+//
+//  map[string][]string{
+//      "tag_name": []string{
+//          "127.0.0.1/24",
+//      },
+//  }
+//
+// In JSON format:
+//
+// { "tags": { "tag_name": [ "127.0.0.1/24" ] } }
+func (c *ConfigFileNetboxClient) GetPrefixesWithTag(ctx context.Context, tag string) ([]*net.IPNet, error) {
+        t, ok := c.cfg["tags"]
+        if !ok {
+                return nil, fmt.Errorf("No key 'tags' in config file")
+        }
+
+        tags := map[string][]string{}
+        if err := mapstructure.Decode(t, &tags); err != nil {
+                return nil, fmt.Errorf("Key 'tags' not in correct format: %w", err)
+        }
+
+        values, ok := tags[tag]
+        if !ok {
+                return nil, fmt.Errorf("Tag %s not in tags", tag)
+        }
+
+        return parseValues(values)
+}
+
+func parseValues(v []string) ([]*net.IPNet, error) {
+        out := make([]*net.IPNet, len(v))
+        for i, n := range v {
+                _, in, err := net.ParseCIDR(n)
+                if err != nil {
+                        return nil, err
+                }
+                out[i] = in
+        }
+        return out, nil
+}