maxmind-geoip2 1.0.0 → 1.2.0

data/test/data/pkg/writer/maxmind.go

@@ -0,0 +1,245 @@
+package writer
+
+import (
+	"fmt"
+	"net/netip"
+
+	"github.com/maxmind/mmdbwriter"
+	"github.com/maxmind/mmdbwriter/mmdbtype"
+	"go4.org/netipx"
+)
+
+// WriteIPv4TestDB writes mmdb files for an ip range between 1.1.1.1 and 1.1.1.32
+// with various record sizes.
+func (w *Writer) WriteIPv4TestDB() error {
+	ipRange, err := parseIPRange("1.1.1.1", "1.1.1.32")
+	if err != nil {
+		return fmt.Errorf("parsing ip range: %w", err)
+	}
+
+	for _, recordSize := range []int{24, 28, 32} {
+		err := w.writeMaxMindTestDB(
+			recordSize,
+			[]netipx.IPRange{ipRange},
+			"ipv4",
+		)
+		if err != nil {
+			return fmt.Errorf("writing test database: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// WriteIPv6TestDB writes mmdb files for an ip range between ::1:ffff:ffff and ::2:0000:0059
+// with various record sizes.
+func (w *Writer) WriteIPv6TestDB() error {
+	ipRange, err := parseIPRange("::1:ffff:ffff", "::2:0000:0059")
+	if err != nil {
+		return fmt.Errorf("parsing ip range: %w", err)
+	}
+
+	for _, recordSize := range []int{24, 28, 32} {
+		err := w.writeMaxMindTestDB(
+			recordSize,
+			[]netipx.IPRange{ipRange},
+			"ipv6",
+		)
+		if err != nil {
+			return fmt.Errorf("writing test database: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// WriteMixedIPTestDB writes mmdb files for a mixed ip version range between ::1:ffff:ffff and ::2:0000:0059
+// with various record sizes.
+func (w *Writer) WriteMixedIPTestDB() error {
+	ipv6Range, err := parseIPRange("::1:ffff:ffff", "::2:0000:0059")
+	if err != nil {
+		return fmt.Errorf("parsing ip range: %w", err)
+	}
+
+	ipv4Range, err := parseIPRange("1.1.1.1", "1.1.1.32")
+	if err != nil {
+		return fmt.Errorf("parsing ip range: %w", err)
+	}
+
+	for _, recordSize := range []int{24, 28, 32} {
+		err := w.writeMaxMindTestDB(
+			recordSize,
+			[]netipx.IPRange{ipv6Range, ipv4Range},
+			"mixed",
+		)
+		if err != nil {
+			return fmt.Errorf("writing test database: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// writeMaxMindTestDB writes test mmdb files.
+func (w *Writer) writeMaxMindTestDB(
+	recordSize int,
+	ipRange []netipx.IPRange,
+	ipVersionName string,
+) error {
+	ipVersion := 6
+	if ipRange[0].From().Is4() {
+		ipVersion = 4
+	}
+
+	metadata := map[string]string{}
+	metadata["en"] = "Test Database"
+	metadata["zh"] = "Test Database Chinese"
+
+	dbWriter, err := mmdbwriter.New(
+		mmdbwriter.Options{
+			DatabaseType:        "Test",
+			Description:         metadata,
+			DisableIPv4Aliasing: ipVersion == 4,
+			IPVersion:           ipVersion,
+			Languages:           []string{"en", "zh"},
+			RecordSize:          recordSize,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("creating mmdbwriter: %w", err)
+	}
+
+	for _, ir := range ipRange {
+		for _, prefix := range ir.Prefixes() {
+			ipString := prefix.Addr().String()
+			if ipVersion == 6 && prefix.Addr().Is4() {
+				ipString = "::" + ipString
+			}
+
+			err := dbWriter.Insert(
+				netipx.PrefixIPNet(prefix),
+				mmdbtype.Map{
+					"ip": mmdbtype.String(ipString),
+				},
+			)
+			if err != nil {
+				return fmt.Errorf("inserting ip: %w", err)
+			}
+		}
+	}
+
+	fileName := fmt.Sprintf("MaxMind-DB-test-%s-%d.mmdb", ipVersionName, recordSize)
+	if err := w.write(dbWriter, fileName); err != nil {
+		return fmt.Errorf("writing database: %w", err)
+	}
+
+	return nil
+}
+
+// WriteNoIPv4TestDB writes an mmdb file with no ipv4 records.
+func (w *Writer) WriteNoIPv4TestDB() error {
+	dbWriter, err := mmdbwriter.New(
+		mmdbwriter.Options{
+			DatabaseType: "MaxMind DB No IPv4 Search Tree",
+			Description: map[string]string{
+				"en": "MaxMind DB No IPv4 Search Tree",
+			},
+			DisableIPv4Aliasing:     true,
+			IncludeReservedNetworks: true,
+			IPVersion:               6,
+			Languages:               []string{"en"},
+			RecordSize:              24,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("creating mmdbwriter: %w", err)
+	}
+
+	addr, err := netip.ParsePrefix("::/64")
+	if err != nil {
+		return fmt.Errorf("parsing ip: %w", err)
+	}
+
+	err = dbWriter.Insert(
+		netipx.PrefixIPNet(addr),
+		mmdbtype.String(addr.String()),
+	)
+	if err != nil {
+		return fmt.Errorf("inserting ip: %w", err)
+	}
+
+	if err := w.write(dbWriter, "MaxMind-DB-no-ipv4-search-tree.mmdb"); err != nil {
+		return fmt.Errorf("writing database: %w", err)
+	}
+	return nil
+}
+
+// WriteNoMapTestDB writes an mmdb file where each record points to
+// a string value.
+func (w *Writer) WriteNoMapTestDB() error {
+	dbWriter, err := mmdbwriter.New(
+		mmdbwriter.Options{
+			DatabaseType: "MaxMind DB String Value Entries",
+			Description: map[string]string{
+				"en": "MaxMind DB String Value Entries (no maps or arrays as values)",
+			},
+			IPVersion:  4,
+			Languages:  []string{"en"},
+			RecordSize: 24,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("creating mmdbwriter: %w", err)
+	}
+
+	ipRange, err := parseIPRange("1.1.1.1", "1.1.1.32")
+	if err != nil {
+		return fmt.Errorf("parsing ip range: %w", err)
+	}
+
+	for _, prefix := range ipRange.Prefixes() {
+		err := dbWriter.Insert(
+			netipx.PrefixIPNet(prefix),
+			mmdbtype.String(prefix.String()),
+		)
+		if err != nil {
+			return fmt.Errorf("inserting ip: %w", err)
+		}
+	}
+
+	if err := w.write(dbWriter, "MaxMind-DB-string-value-entries.mmdb"); err != nil {
+		return fmt.Errorf("writing database: %w", err)
+	}
+	return nil
+}
+
+// WriteMetadataPointersTestDB writes an mmdb file with metadata pointers allowed.
+func (w *Writer) WriteMetadataPointersTestDB() error {
+	repeatedString := "Lots of pointers in metadata"
+	dbWriter, err := mmdbwriter.New(
+		mmdbwriter.Options{
+			DatabaseType: repeatedString,
+			Description: map[string]string{
+				"en": repeatedString,
+				"es": repeatedString,
+				"zh": repeatedString,
+			},
+			DisableIPv4Aliasing: true,
+			IPVersion:           6,
+			Languages:           []string{"en", "es", "zh"},
+			RecordSize:          24,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("creating mmdbwriter: %w", err)
+	}
+
+	if err := populateAllNetworks(dbWriter); err != nil {
+		return fmt.Errorf("inserting all networks: %w", err)
+	}
+
+	if err := w.write(dbWriter, "MaxMind-DB-test-metadata-pointers.mmdb"); err != nil {
+		return fmt.Errorf("writing database: %w", err)
+	}
+	return nil
+}

data/test/data/pkg/writer/nestedstructures.go

@@ -0,0 +1,73 @@
+package writer
+
+import (
+	"fmt"
+	"net/netip"
+
+	"github.com/maxmind/mmdbwriter"
+	"github.com/maxmind/mmdbwriter/mmdbtype"
+	"go4.org/netipx"
+)
+
+// WriteDeeplyNestedStructuresTestDB writes an mmdb file with deeply nested record value types.
+func (w *Writer) WriteDeeplyNestedStructuresTestDB() error {
+	dbWriter, err := mmdbwriter.New(
+		mmdbwriter.Options{
+			DatabaseType: "MaxMind DB Nested Data Structures",
+			Description: map[string]string{
+				"en": "MaxMind DB Nested Data Structures Test database - contains deeply nested map/array structures",
+			},
+			DisableIPv4Aliasing:     false,
+			IncludeReservedNetworks: true,
+			IPVersion:               6,
+			Languages:               []string{"en"},
+			RecordSize:              24,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("creating mmdbwriter: %w", err)
+	}
+
+	addrs, err := parseIPSlice(ipSample)
+	if err != nil {
+		return fmt.Errorf("parsing ip addresses: %w", err)
+	}
+	if err := insertNestedStructure(dbWriter, addrs); err != nil {
+		return fmt.Errorf("inserting all types records: %w", err)
+	}
+
+	if err := w.write(dbWriter, "MaxMind-DB-test-nested.mmdb"); err != nil {
+		return fmt.Errorf("writing database: %w", err)
+	}
+	return nil
+}
+
+// insertNestedStructure inserts records with deeply nested structures.
+func insertNestedStructure(w *mmdbwriter.Tree, ipAddresses []netip.Prefix) error {
+	nestedStruct := mmdbtype.Map{
+		"map1": mmdbtype.Map{
+			"map2": mmdbtype.Map{
+				"array": mmdbtype.Slice{
+					mmdbtype.Map{
+						"map3": mmdbtype.Map{
+							"a": mmdbtype.Uint32(1),
+							"b": mmdbtype.Uint32(2),
+							"c": mmdbtype.Uint32(3),
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, addr := range ipAddresses {
+		err := w.Insert(
+			netipx.PrefixIPNet(addr),
+			nestedStruct,
+		)
+		if err != nil {
+			return fmt.Errorf("inserting ip: %w", err)
+		}
+	}
+	return nil
+}

data/test/data/pkg/writer/writer.go

@@ -0,0 +1,58 @@
+// Package writer defines database writers responsible
+// for generating test mmdb files.
+package writer
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/maxmind/mmdbwriter"
+)
+
+var ipSample = []string{
+	"::1.1.1.0/120",
+	"::2.2.0.0/112",
+	"::3.0.0.0/104",
+	"::4.5.6.7/128",
+	"abcd::/64",
+	"1000::1234:0000/112",
+}
+
+// Writer is responsible for writing test mmdb databases
+// based on the provided data sources.
+type Writer struct {
+	source string
+	target string
+}
+
+// New initializes a new test database writer struct.
+func New(source, target string) (*Writer, error) {
+	s := filepath.Clean(source)
+	if _, err := os.Stat(s); os.IsNotExist(err) {
+		return nil, fmt.Errorf("source directory does not exist: %w", err)
+	}
+
+	t := filepath.Clean(target)
+	if err := os.MkdirAll(t, os.ModePerm); err != nil {
+		return nil, fmt.Errorf("creating target directory: %w", err)
+	}
+
+	return &Writer{
+		source: s,
+		target: t,
+	}, nil
+}
+
+func (w *Writer) write(dbWriter *mmdbwriter.Tree, fileName string) error {
+	outputFile, err := os.Create(filepath.Clean(filepath.Join(w.target, fileName)))
+	if err != nil {
+		return fmt.Errorf("creating mmdb file: %w", err)
+	}
+	defer outputFile.Close()
+
+	if _, err := dbWriter.WriteTo(outputFile); err != nil {
+		return fmt.Errorf("writing mmdb file: %w", err)
+	}
+	return nil
+}