Vendor main dependencies.

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/account/apikey.go

@@ -0,0 +1,13 @@
+package account
+
+// APIKey wraps an NS1 /account/apikeys resource
+type APIKey struct {
+	// Read-only fields
+	ID         string `json:"id,omitempty"`
+	Key        string `json:"key,omitempty"`
+	LastAccess int    `json:"last_access,omitempty"`
+
+	Name        string         `json:"name"`
+	TeamIDs     []string       `json:"teams"`
+	Permissions PermissionsMap `json:"permissions"`
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/account/doc.go

@@ -0,0 +1,2 @@
+// Package account contains definitions for NS1 apikeys/teams/users/etc.
+package account

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/account/permissions.go

@@ -0,0 +1,44 @@
+package account
+
+// PermissionsMap wraps a User's "permissions" attribute
+type PermissionsMap struct {
+	DNS        PermissionsDNS        `json:"dns"`
+	Data       PermissionsData       `json:"data"`
+	Account    PermissionsAccount    `json:"account"`
+	Monitoring PermissionsMonitoring `json:"monitoring"`
+}
+
+// PermissionsDNS wraps a User's "permissions.dns" attribute
+type PermissionsDNS struct {
+	ViewZones           bool     `json:"view_zones"`
+	ManageZones         bool     `json:"manage_zones"`
+	ZonesAllowByDefault bool     `json:"zones_allow_by_default"`
+	ZonesDeny           []string `json:"zones_deny"`
+	ZonesAllow          []string `json:"zones_allow"`
+}
+
+// PermissionsData wraps a User's "permissions.data" attribute
+type PermissionsData struct {
+	PushToDatafeeds   bool `json:"push_to_datafeeds"`
+	ManageDatasources bool `json:"manage_datasources"`
+	ManageDatafeeds   bool `json:"manage_datafeeds"`
+}
+
+// PermissionsAccount wraps a User's "permissions.account" attribute
+type PermissionsAccount struct {
+	ManageUsers           bool `json:"manage_users"`
+	ManagePaymentMethods  bool `json:"manage_payment_methods"`
+	ManagePlan            bool `json:"manage_plan"`
+	ManageTeams           bool `json:"manage_teams"`
+	ManageApikeys         bool `json:"manage_apikeys"`
+	ManageAccountSettings bool `json:"manage_account_settings"`
+	ViewActivityLog       bool `json:"view_activity_log"`
+	ViewInvoices          bool `json:"view_invoices"`
+}
+
+// PermissionsMonitoring wraps a User's "permissions.monitoring" attribute
+type PermissionsMonitoring struct {
+	ManageLists bool `json:"manage_lists"`
+	ManageJobs  bool `json:"manage_jobs"`
+	ViewJobs    bool `json:"view_jobs"`
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/account/settings.go

@@ -0,0 +1,21 @@
+package account
+
+// Setting represents an accounts' contact info.
+type Setting struct {
+	CustomerID int     `json:"customerid,omitempty"`
+	FirstName  string  `json:"firstname,omitempty"`
+	LastName   string  `json:"lastname,omitempty"`
+	Company    string  `json:"company,omitempty"`
+	Phone      string  `json:"phone,omitempty"`
+	Email      string  `json:"email,omitempty"`
+	Address    Address `json:"address,omitempty"`
+}
+
+// Address for Setting struct.
+type Address struct {
+	Country string `json:"country,omitempty"`
+	Street  string `json:"street,omitempty"`
+	State   string `json:"state,omitempty"`
+	City    string `json:"city,omitempty"`
+	Postal  string `json:"postalcode,omitempty"`
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/account/team.go

@@ -0,0 +1,8 @@
+package account
+
+// Team wraps an NS1 /accounts/teams resource
+type Team struct {
+	ID          string         `json:"id,omitempty"`
+	Name        string         `json:"name"`
+	Permissions PermissionsMap `json:"permissions"`
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/account/user.go

@@ -0,0 +1,19 @@
+package account
+
+// User wraps an NS1 /account/users resource
+type User struct {
+	// Read-only fields
+	LastAccess float64 `json:"last_access"`
+
+	Name        string               `json:"name"`
+	Username    string               `json:"username"`
+	Email       string               `json:"email"`
+	TeamIDs     []string             `json:"teams"`
+	Notify      NotificationSettings `json:"notify"`
+	Permissions PermissionsMap       `json:"permissions"`
+}
+
+// NotificationSettings wraps a User's "notify" attribute
+type NotificationSettings struct {
+	Billing bool `json:"billing"`
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/account/warning.go

@@ -0,0 +1,17 @@
+package account
+
+// UsageWarning wraps an NS1 /account/usagewarnings resource
+type UsageWarning struct {
+	Records Warning `json:"records"`
+	Queries Warning `json:"queries"`
+}
+
+// Warning contains alerting toggles and thresholds for overage warning alert messages.
+// First thresholds must be smaller than Second ones and all thresholds
+// must be percentages between 0 and 100.
+type Warning struct {
+	Send bool `json:"send_warnings"`
+
+	First  int `json:"warning_1"`
+	Second int `json:"warning_2"`
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/data/doc.go

@@ -0,0 +1,2 @@
+// Package data contains definitions for NS1 metadata/sources/feeds/etc.
+package data

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/data/feed.go

@@ -0,0 +1,38 @@
+package data
+
+// Destination is the target resource the receives data from a feed/source.
+type Destination struct {
+	ID string `json:"destid"`
+
+	// All destinations must point to a record.
+	RecordID string `json:"record"`
+
+	// Type is the 'level' at which to apply the filters(on the targeted record).
+	// Options:
+	//   - answer (highest precedence)
+	//   - region
+	//   - record (lowest precendence)
+	Type string `json:"desttype"`
+
+	SourceID string `json:"-"`
+}
+
+// NewDestination returns an empty feed destination.
+func NewDestination() *Destination {
+	return &Destination{}
+}
+
+// Feed wraps an NS1 /data/feeds resource
+type Feed struct {
+	ID     string `json:"id,omitempty"`
+	Name   string `json:"name"`
+	Config Config `json:"config,omitempty"`
+	Data   Meta   `json:"data,omitempty"`
+
+	SourceID string
+}
+
+// NewFeed returns a data feed with given name and config.
+func NewFeed(name string, cfg Config) *Feed {
+	return &Feed{Name: name, Config: cfg}
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/data/meta.go

@@ -0,0 +1,127 @@
+package data
+
+// FeedPtr represents the dynamic metadata value in which a feed is providing the value.
+type FeedPtr struct {
+	FeedID string `json:"feed,omitempty"`
+}
+
+// Meta contains information on an entities metadata table. Metadata key/value
+// pairs are used by a records' filter pipeline during a dns query.
+// All values can be a feed id as well, indicating real-time updates of these values.
+// Structure/Precendence of metadata tables:
+//  - Record
+//    - Meta <- lowest precendence in filter
+//    - Region(s)
+//      - Meta <- middle precedence in filter chain
+//      - ...
+//    - Answer(s)
+//      - Meta <- highest precedence in filter chain
+//      - ...
+//    - ...
+type Meta struct {
+	// STATUS
+
+	// Indicates whether or not entity is considered 'up'
+	// bool or FeedPtr.
+	Up interface{} `json:"up,omitempty"`
+
+	// Indicates the number of active connections.
+	// Values must be positive.
+	// int or FeedPtr.
+	Connections interface{} `json:"connections,omitempty"`
+
+	// Indicates the number of active requests (HTTP or otherwise).
+	// Values must be positive.
+	// int or FeedPtr.
+	Requests interface{} `json:"requests,omitempty"`
+
+	// Indicates the "load average".
+	// Values must be positive, and will be rounded to the nearest tenth.
+	// float64 or FeedPtr.
+	LoadAvg interface{} `json:"loadavg,omitempty"`
+
+	// The Job ID of a Pulsar telemetry gathering job and routing granularities
+	// to associate with.
+	// string or FeedPtr.
+	Pulsar interface{} `json:"pulsar,omitempty"`
+
+	// GEOGRAPHICAL
+
+	// Must be between -180.0 and +180.0 where negative
+	// indicates South and positive indicates North.
+	// e.g., the longitude of the datacenter where a server resides.
+	// float64 or FeedPtr.
+	Latitude interface{} `json:"latitude,omitempty"`
+
+	// Must be between -180.0 and +180.0 where negative
+	// indicates West and positive indicates East.
+	// e.g., the longitude of the datacenter where a server resides.
+	// float64 or FeedPtr.
+	Longitude interface{} `json:"longitude,omitempty"`
+
+	// Valid geographic regions are: 'US-EAST', 'US-CENTRAL', 'US-WEST',
+	// 'EUROPE', 'ASIAPAC', 'SOUTH-AMERICA', 'AFRICA'.
+	// e.g., the rough geographic location of the Datacenter where a server resides.
+	// []string or FeedPtr.
+	Georegion interface{} `json:"georegion,omitempty"`
+
+	// Countr(ies) must be specified as ISO3166 2-character country code(s).
+	// []string or FeedPtr.
+	Country interface{} `json:"country,omitempty"`
+
+	// State(s) must be specified as standard 2-character state code(s).
+	// []string or FeedPtr.
+	USState interface{} `json:"us_state,omitempty"`
+
+	// Canadian Province(s) must be specified as standard 2-character province
+	// code(s).
+	// []string or FeedPtr.
+	CAProvince interface{} `json:"ca_province,omitempty"`
+
+	// INFORMATIONAL
+
+	// Notes to indicate any necessary details for operators.
+	// Up to 256 characters in length.
+	// string or FeedPtr.
+	Note interface{} `json:"note,omitempty"`
+
+	// NETWORK
+
+	// IP (v4 and v6) prefixes in CIDR format ("a.b.c.d/mask").
+	// May include up to 1000 prefixes.
+	// e.g., "1.2.3.4/24"
+	// []string or FeedPtr.
+	IPPrefixes interface{} `json:"ip_prefixes,omitempty"`
+
+	// Autonomous System (AS) number(s).
+	// May include up to 1000 AS numbers.
+	// []string or FeedPtr.
+	ASN interface{} `json:"asn,omitempty"`
+
+	// TRAFFIC
+
+	// Indicates the "priority tier".
+	// Lower values indicate higher priority.
+	// Values must be positive.
+	// int or FeedPtr.
+	Priority interface{} `json:"priority,omitempty"`
+
+	// Indicates a weight.
+	// Filters that use weights normalize them.
+	// Any positive values are allowed.
+	// Values between 0 and 100 are recommended for simplicity's sake.
+	// float64 or FeedPtr.
+	Weight interface{} `json:"weight,omitempty"`
+
+	// Indicates a "low watermark" to use for load shedding.
+	// The value should depend on the metric used to determine
+	// load (e.g., loadavg, connections, etc).
+	// int or FeedPtr.
+	LowWatermark interface{} `json:"low_watermark,omitempty"`
+
+	// Indicates a "high watermark" to use for load shedding.
+	// The value should depend on the metric used to determine
+	// load (e.g., loadavg, connections, etc).
+	// int or FeedPtr.
+	HighWatermark interface{} `json:"high_watermark,omitempty"`
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/data/region.go

@@ -0,0 +1,10 @@
+package data
+
+// Region is a metadata table with a name/key.
+// Can be thought of as metadata groupings.
+type Region struct {
+	Meta Meta `json:"meta,omitempty"`
+}
+
+// Regions is simply a mapping of Regions inside a record.
+type Regions map[string]Region

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/data/source.go

@@ -0,0 +1,28 @@
+package data
+
+// Config is a flat mapping where values are simple (no slices/maps).
+type Config map[string]interface{}
+
+// Source wraps an NS1 /data/sources resource
+type Source struct {
+	ID string `json:"id,omitempty"`
+
+	// Human readable name of the source.
+	Name string `json:"name"`
+
+	Type   string `json:"sourcetype"`
+	Config Config `json:"config,omitempty"`
+	Status string `json:"status,omitempty"`
+
+	Feeds []*Feed `json:"feeds,omitempty"`
+}
+
+// NewSource takes a name and type t.
+func NewSource(name string, t string) *Source {
+	return &Source{
+		Name:   name,
+		Type:   t,
+		Config: Config{},
+		Feeds:  []*Feed{},
+	}
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/dns/answer.go

@@ -0,0 +1,101 @@
+package dns
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"gopkg.in/ns1/ns1-go.v2/rest/model/data"
+)
+
+// Answer wraps the values of a Record's "filters" attribute
+type Answer struct {
+	Meta *data.Meta `json:"meta,omitempty"`
+
+	// Answer response data. eg:
+	// Av4: ["1.1.1.1"]
+	// Av6: ["2001:db8:85a3::8a2e:370:7334"]
+	// MX:  [10, "2.2.2.2"]
+	Rdata []string `json:"answer"`
+
+	// Region(grouping) that answer belongs to.
+	RegionName string `json:"region,omitempty"`
+}
+
+func (a Answer) String() string {
+	return strings.Trim(fmt.Sprint(a.Rdata), "[]")
+}
+
+// SetRegion associates a region with this answer.
+func (a *Answer) SetRegion(name string) {
+	a.RegionName = name
+}
+
+// NewAnswer creates a generic Answer with given rdata.
+func NewAnswer(rdata []string) *Answer {
+	return &Answer{
+		Meta:  &data.Meta{},
+		Rdata: rdata,
+	}
+}
+
+// NewAv4Answer creates an Answer for A record.
+func NewAv4Answer(host string) *Answer {
+	return &Answer{
+		Meta:  &data.Meta{},
+		Rdata: []string{host},
+	}
+}
+
+// NewAv6Answer creates an Answer for AAAA record.
+func NewAv6Answer(host string) *Answer {
+	return &Answer{
+		Meta:  &data.Meta{},
+		Rdata: []string{host},
+	}
+}
+
+// NewALIASAnswer creates an Answer for ALIAS record.
+func NewALIASAnswer(host string) *Answer {
+	return &Answer{
+		Meta:  &data.Meta{},
+		Rdata: []string{host},
+	}
+}
+
+// NewCNAMEAnswer creates an Answer for CNAME record.
+func NewCNAMEAnswer(name string) *Answer {
+	return &Answer{
+		Meta:  &data.Meta{},
+		Rdata: []string{name},
+	}
+}
+
+// NewTXTAnswer creates an Answer for TXT record.
+func NewTXTAnswer(text string) *Answer {
+	return &Answer{
+		Meta:  &data.Meta{},
+		Rdata: []string{text},
+	}
+}
+
+// NewMXAnswer creates an Answer for MX record.
+func NewMXAnswer(pri int, host string) *Answer {
+	return &Answer{
+		Meta:  &data.Meta{},
+		Rdata: []string{strconv.Itoa(pri), host},
+	}
+}
+
+// NewSRVAnswer creates an Answer for SRV record.
+func NewSRVAnswer(priority, weight, port int, target string) *Answer {
+	return &Answer{
+		Meta: &data.Meta{},
+		Rdata: []string{
+			strconv.Itoa(priority),
+			strconv.Itoa(weight),
+			strconv.Itoa(port),
+			target,
+		},
+	}
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/dns/doc.go

@@ -0,0 +1,2 @@
+// Package dns contains definitions for NS1 zones/records/answers/etc.
+package dns

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/dns/record.go

@@ -0,0 +1,76 @@
+package dns
+
+import (
+	"fmt"
+	"strings"
+
+	"gopkg.in/ns1/ns1-go.v2/rest/model/data"
+	"gopkg.in/ns1/ns1-go.v2/rest/model/filter"
+)
+
+// Record wraps an NS1 /zone/{zone}/{domain}/{type} resource
+type Record struct {
+	Meta *data.Meta `json:"meta,omitempty"`
+
+	ID              string `json:"id,omitempty"`
+	Zone            string `json:"zone"`
+	Domain          string `json:"domain"`
+	Type            string `json:"type"`
+	Link            string `json:"link,omitempty"`
+	TTL             int    `json:"ttl,omitempty"`
+	UseClientSubnet *bool  `json:"use_client_subnet,omitempty"`
+
+	// Answers must all be of the same type as the record.
+	Answers []*Answer `json:"answers"`
+	// The records' filter chain.
+	Filters []*filter.Filter `json:"filters,omitempty"`
+	// The records' regions.
+	Regions data.Regions `json:"regions,omitempty"`
+}
+
+func (r Record) String() string {
+	return fmt.Sprintf("%s %s", r.Domain, r.Type)
+}
+
+// NewRecord takes a zone, domain and record type t and creates a *Record with
+// UseClientSubnet: true & empty Answers.
+func NewRecord(zone string, domain string, t string) *Record {
+	if !strings.HasSuffix(domain, zone) {
+		domain = fmt.Sprintf("%s.%s", domain, zone)
+	}
+	return &Record{
+		Meta:    &data.Meta{},
+		Zone:    zone,
+		Domain:  domain,
+		Type:    t,
+		Answers: []*Answer{},
+		Regions: data.Regions{},
+	}
+}
+
+// LinkTo sets a Record Link to an FQDN.
+// to is the FQDN of the target record whose config should be used. Does
+// not have to be in the same zone.
+func (r *Record) LinkTo(to string) {
+	r.Meta = nil
+	r.Answers = []*Answer{}
+	r.Link = to
+}
+
+// AddAnswer adds an answer to the record.
+func (r *Record) AddAnswer(ans *Answer) {
+	if r.Answers == nil {
+		r.Answers = []*Answer{}
+	}
+
+	r.Answers = append(r.Answers, ans)
+}
+
+// AddFilter adds a filter to the records' filter chain(ordering of filters matters).
+func (r *Record) AddFilter(fil *filter.Filter) {
+	if r.Filters == nil {
+		r.Filters = []*filter.Filter{}
+	}
+
+	r.Filters = append(r.Filters, fil)
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/dns/zone.go

@@ -0,0 +1,157 @@
+package dns
+
+import "gopkg.in/ns1/ns1-go.v2/rest/model/data"
+
+// Zone wraps an NS1 /zone resource
+type Zone struct {
+	// Zones have metadata tables, but no filters act on 'zone-level' meta.
+	Meta *data.Meta `json:"meta,omitempty"`
+
+	// Read-only fields
+	DNSServers   []string `json:"dns_servers,omitempty"`
+	NetworkPools []string `json:"network_pools,omitempty"`
+	Pool         string   `json:"pool,omitempty"` // Deprecated
+
+	ID   string `json:"id,omitempty"`
+	Zone string `json:"zone,omitempty"`
+
+	TTL        int    `json:"ttl,omitempty"`
+	NxTTL      int    `json:"nx_ttl,omitempty"`
+	Retry      int    `json:"retry,omitempty"`
+	Serial     int    `json:"serial,omitempty"`
+	Refresh    int    `json:"refresh,omitempty"`
+	Expiry     int    `json:"expiry,omitempty"`
+	Hostmaster string `json:"hostmaster,omitempty"`
+
+	// If this is a linked zone, Link points to an existing standard zone,
+	// reusing its configuration and records. Link is a zones' domain name.
+	Link *string `json:"link,omitempty"`
+
+	// Networks contains the network ids the zone is available. Most zones
+	// will be in the NSONE Global Network(which is id 0).
+	NetworkIDs []int         `json:"networks,omitempty"`
+	Records    []*ZoneRecord `json:"records,omitempty"`
+
+	// Primary contains info to enable slaving of the zone by third party dns servers.
+	Primary *ZonePrimary `json:"primary,omitempty"`
+	// Secondary contains info for slaving the zone to a primary dns server.
+	Secondary *ZoneSecondary `json:"secondary,omitempty"`
+}
+
+func (z Zone) String() string {
+	return z.Zone
+}
+
+// ZoneRecord wraps Zone's "records" attribute
+type ZoneRecord struct {
+	Domain   string   `json:"Domain,omitempty"`
+	ID       string   `json:"id,omitempty"`
+	Link     string   `json:"link,omitempty"`
+	ShortAns []string `json:"short_answers,omitempty"`
+	Tier     int      `json:"tier,omitempty"`
+	TTL      int      `json:"ttl,omitempty"`
+	Type     string   `json:"type,omitempty"`
+}
+
+// ZonePrimary wraps a Zone's "primary" attribute
+type ZonePrimary struct {
+	// Enabled determines whether AXFR queries (and optionally NOTIFY messages)
+	// will be enabled for the zone.
+	Enabled     bool                  `json:"enabled"`
+	Secondaries []ZoneSecondaryServer `json:"secondaries"`
+}
+
+// ZoneSecondaryServer wraps elements of a Zone's "primary.secondary" attribute
+type ZoneSecondaryServer struct {
+	// Read-Only
+	NetworkIDs []int `json:"networks,omitempty"`
+
+	IP     string `json:"ip"`
+	Port   int    `json:"port,omitempty"`
+	Notify bool   `json:"notify"`
+}
+
+// ZoneSecondary wraps a Zone's "secondary" attribute
+type ZoneSecondary struct {
+	// Read-Only fields
+	Expired bool    `json:"expired,omitempty"`
+	LastXfr int     `json:"last_xfr,omitempty"`
+	Status  string  `json:"status,omitempty"`
+	Error   *string `json:"error"`
+
+	PrimaryIP   string `json:"primary_ip,omitempty"`
+	PrimaryPort int    `json:"primary_port,omitempty"`
+	Enabled     bool   `json:"enabled"`
+
+	TSIG *TSIG `json:"tsig"`
+}
+
+// TSIG is a zones transaction signature.
+type TSIG struct {
+	// Key is the encrypted TSIG key(read-only)
+	Key string `json:"key,omitempty"`
+
+	// Whether TSIG is enabled for a secondary zone.
+	Enabled bool `json:"enabled,omitempty"`
+	// Which hashing algorithm
+	Hash string `json:"hash,omitempty"`
+	// Name of the TSIG key
+	Name string `json:"name,omitempty"`
+}
+
+// NewZone takes a zone domain name and creates a new zone.
+func NewZone(zone string) *Zone {
+	z := Zone{
+		Zone: zone,
+	}
+	return &z
+}
+
+// MakePrimary enables Primary, disables Secondary, and sets primary's
+// Secondaries to all provided ZoneSecondaryServers
+func (z *Zone) MakePrimary(secondaries ...ZoneSecondaryServer) {
+	z.Secondary = nil
+	z.Primary = &ZonePrimary{
+		Enabled:     true,
+		Secondaries: secondaries,
+	}
+	if z.Primary.Secondaries == nil {
+		z.Primary.Secondaries = make([]ZoneSecondaryServer, 0)
+	}
+}
+
+// MakeSecondary enables Secondary, disables Primary, and sets secondary's
+// Primary_ip to provided ip.
+func (z *Zone) MakeSecondary(ip string) {
+	z.Secondary = &ZoneSecondary{
+		Enabled:     true,
+		PrimaryIP:   ip,
+		PrimaryPort: 53,
+	}
+	z.Primary = &ZonePrimary{
+		Enabled:     false,
+		Secondaries: make([]ZoneSecondaryServer, 0),
+	}
+}
+
+// LinkTo sets Link to a target zone domain name and unsets all other configuration properties.
+// No other zone configuration properties (such as refresh, retry, etc) may be specified,
+// since they are all pulled from the target zone. Linked zones, once created, cannot be
+// configured at all and cannot have records added to them. They may only be deleted, which
+// does not affect the target zone at all.
+func (z *Zone) LinkTo(to string) {
+	z.Meta = nil
+	z.TTL = 0
+	z.NxTTL = 0
+	z.Retry = 0
+	z.Refresh = 0
+	z.Expiry = 0
+	z.Primary = nil
+	z.DNSServers = nil
+	z.NetworkIDs = nil
+	z.NetworkPools = nil
+	z.Hostmaster = ""
+	z.Pool = ""
+	z.Secondary = nil
+	z.Link = &to
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/filter/doc.go

@@ -0,0 +1,2 @@
+// Package filter contains definitions for NS1 filter chains.
+package filter

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/filter/filter.go

@@ -0,0 +1,182 @@
+package filter
+
+// Filter wraps the values of a Record's "filters" attribute
+type Filter struct {
+	Type     string `json:"filter"`
+	Disabled bool   `json:"disabled,omitempty"`
+	Config   Config `json:"config"`
+}
+
+// Enable a filter.
+func (f *Filter) Enable() {
+	f.Disabled = false
+}
+
+// Disable a filter.
+func (f *Filter) Disable() {
+	f.Disabled = true
+}
+
+// Config is a flat mapping where values are simple (no slices/maps).
+type Config map[string]interface{}
+
+// NewSelFirstN returns a filter that eliminates all but the
+// first N answers from the list.
+func NewSelFirstN(n int) *Filter {
+	return &Filter{
+		Type:   "select_first_n",
+		Config: Config{"N": n},
+	}
+}
+
+// NewShuffle returns a filter that randomly sorts the answers.
+func NewShuffle() *Filter {
+	return &Filter{Type: "shuffle", Config: Config{}}
+}
+
+// GEOGRAPHICAL FILTERS
+
+// NewSelFirstRegion returns a filter that keeps only the answers
+// that are in the same region as the first answer.
+func NewSelFirstRegion() *Filter {
+	return &Filter{Type: "select_first_n", Config: Config{}}
+}
+
+// NewStickyRegion first sorts regions uniquely depending on the IP
+// address of the requester, and then groups all answers together by
+// region. The same requester always gets the same ordering of regions,
+// but answers within each region may be in any order. byNetwork indicates
+// whether to apply the 'stickyness' by subnet(not individual IP).
+func NewStickyRegion(byNetwork bool) *Filter {
+	return &Filter{
+		Type:   "sticky_region",
+		Config: Config{"sticky_by_network": byNetwork},
+	}
+}
+
+// NewGeofenceCountry returns a filter that fences using "country",
+// "us_state", and "ca_province" metadata fields in answers. Only
+// answers in the same country/state/province as the user (or
+// answers with no specified location) are returned. rmNoLoc determines
+// whether to remove answers without location on any match.
+func NewGeofenceCountry(rmNoLoc bool) *Filter {
+	return &Filter{
+		Type:   "geofence_country",
+		Config: Config{"remove_no_location": rmNoLoc},
+	}
+}
+
+// NewGeofenceRegional returns a filter that restricts to answers in
+// same geographical region as requester. rmNoGeo determines whether
+// to remove answers without georegion on any match.
+func NewGeofenceRegional(rmNoGeo bool) *Filter {
+	return &Filter{
+		Type:   "geofence_regional",
+		Config: Config{"remove_no_georegion": rmNoGeo},
+	}
+}
+
+// NewGeotargetCountry returns a filter that sorts answers by distance
+// to requester by country, US state, and/or Canadian province.
+func NewGeotargetCountry() *Filter {
+	return &Filter{Type: "geofence_country", Config: Config{}}
+}
+
+// NewGeotargetLatLong returns a filter that sorts answers by distance
+// to user using lat/long.
+func NewGeotargetLatLong() *Filter {
+	return &Filter{Type: "geotarget_latlong", Config: Config{}}
+}
+
+// NewGeotargetRegional returns a filter that sorts answers by distance
+// to user by geographical region.
+func NewGeotargetRegional() *Filter {
+	return &Filter{Type: "geotarget_regional", Config: Config{}}
+}
+
+// NETWORK FILTERS
+
+// NewSticky returns a filter that sorts answers uniquely depending
+// on the IP address of the requester. The same requester always
+// gets the same ordering of answers. byNetwork indicates whether
+// to apply the 'stickyness' by subnet(not individual IP).
+func NewSticky(byNetwork bool) *Filter {
+	return &Filter{
+		Type:   "sticky",
+		Config: Config{"sticky_by_network": byNetwork},
+	}
+}
+
+// NewWeightedSticky returns a filter that shuffles answers randomly
+// per-requester based on weight. byNetwork indicates whether to
+// apply the 'stickyness' by subnet(not individual IP).
+func NewWeightedSticky(byNetwork bool) *Filter {
+	return &Filter{
+		Type:   "weighted_sticky",
+		Config: Config{"sticky_by_network": byNetwork},
+	}
+}
+
+// NewIPv4PrefixShuffle returns a filter that randomly selects
+// IPv4 addresses from prefix list. This filter can only be used
+// A records. n is the number of IPs to randomly select per answer.
+func NewIPv4PrefixShuffle(n int) *Filter {
+	return &Filter{
+		Type:   "ipv4_prefix_shuffle",
+		Config: Config{"N": n},
+	}
+}
+
+// NewNetfenceASN returns a filter that restricts to answers where
+// the ASN of requester IP matches ASN list. rmNoASN determines
+// whether to remove answers without asn list on any match.
+func NewNetfenceASN(rmNoASN bool) *Filter {
+	return &Filter{
+		Type:   "netfence_asn",
+		Config: Config{"remove_no_asn": rmNoASN},
+	}
+}
+
+// NewNetfencePrefix returns a filter that restricts to answers where
+// requester IP matches prefix list. rmNoIPPrefix determines
+// whether to remove answers without ip prefixes on any match.
+func NewNetfencePrefix(rmNoIPPrefix bool) *Filter {
+	return &Filter{
+		Type:   "netfence_prefix",
+		Config: Config{"remove_no_ip_prefixes": rmNoIPPrefix},
+	}
+}
+
+// STATUS FILTERS
+
+// NewUp returns a filter that eliminates all answers where
+// the 'up' metadata field is not true.
+func NewUp() *Filter {
+	return &Filter{Type: "up", Config: Config{}}
+}
+
+// NewPriority returns a filter that fails over according to
+// prioritized answer tiers.
+func NewPriority() *Filter {
+	return &Filter{Type: "priority", Config: Config{}}
+}
+
+// NewShedLoad returns a filter that "sheds" traffic to answers
+// based on load, using one of several load metrics. You must set
+// values for low_watermark, high_watermark, and the configured
+// load metric, for each answer you intend to subject to load
+// shedding.
+func NewShedLoad(metric string) *Filter {
+	return &Filter{
+		Type:   "shed_load",
+		Config: Config{"metric": metric},
+	}
+}
+
+// TRAFFIC FILTERS
+
+// NewWeightedShuffle returns a filter that shuffles answers
+// randomly based on their weight.
+func NewWeightedShuffle() *Filter {
+	return &Filter{Type: "weighted_shuffle", Config: Config{}}
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/monitor/config.go

@@ -0,0 +1,4 @@
+package monitor
+
+// Config is a flat mapping where values are simple (no slices/maps).
+type Config map[string]interface{}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/monitor/doc.go

@@ -0,0 +1,2 @@
+// Package monitor contains definitions for NS1 monitoring jobs.
+package monitor

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/monitor/job.go

@@ -0,0 +1,172 @@
+package monitor
+
+// Job wraps an NS1 /monitoring/jobs resource
+type Job struct {
+	ID string `json:"id,omitempty"`
+
+	// The id of the notification list to send notifications to.
+	NotifyListID string `json:"notify_list"`
+
+	// Type of monitor to be run.
+	// Available job types:
+	//  - http: Do an HTTP request against a webserver
+	//  - dns: Do a DNS lookup against a nameserver
+	//  - tcp: Connect to a TCP port on a host
+	//  - ping: Ping a host using ICMP packets
+	Type string `json:"job_type"`
+
+	// Configuration dictionary(key/vals depend on the jobs' type).
+	Config Config `json:"config"`
+
+	// The current status of the monitor.
+	Status map[string]Status `json:"status,omitempty"`
+
+	// Rules for determining failure conditions.
+	Rules []*Rule `json:"rules"`
+
+	// List of regions in which to run the monitor.
+	// eg, ["dal", "sin", "sjc", "lga", "ams"]
+	Regions []string `json:"regions"`
+
+	// Indicates if the job is active or temporarily disabled.
+	Active bool `json:"active"`
+
+	// Frequency(in seconds), at which to run the monitor.
+	Frequency int `json:"frequency"`
+
+	// The policy for determining the monitor's global status based
+	// on the status of the job in all regions.
+	// Available policies:
+	//  - quorum: Status change when majority status
+	//  - all: Status change only when all regions are in agreement
+	//  - one: Status change if any region changes
+	Policy string `json:"policy"`
+
+	// Controls behavior of how the job is assigned to monitoring regions.
+	// Currently this must be fixed — indicating monitoring regions are explicitly chosen.
+	RegionScope string `json:"region_scope"`
+
+	// Freeform notes to be included in any notifications about this job,
+	// e.g., instructions for operators who will receive the notifications.
+	Notes string `json:"notes,omitempty"`
+
+	// A free-form display name for the monitoring job.
+	Name string `json:"name"`
+
+	// Time(in seconds) between repeat notifications of a failed job.
+	// Set to 0 to disable repeating notifications.
+	NotifyRepeat int `json:"notify_repeat"`
+
+	// If true, on any apparent state change, the job is quickly re-run after
+	// one second to confirm the state change before notification.
+	RapidRecheck bool `json:"rapid_recheck"`
+
+	// Time(in seconds) after a failure to wait before sending a notification.
+	NotifyDelay int `json:"notify_delay"`
+
+	// If true, notifications are sent for any regional failure (and failback if desired),
+	// in addition to global state notifications.
+	NotifyRegional bool `json:"notidy_regional"`
+
+	// If true, a notification is sent when a job returns to an "up" state.
+	NotifyFailback bool `json:"notify_failback"`
+}
+
+// Activate a monitoring job.
+func (j *Job) Activate() {
+	j.Active = true
+
+}
+
+// Deactivate a monitoring job.
+func (j *Job) Deactivate() {
+	j.Active = false
+}
+
+// Result wraps an element of a JobType's "results" attribute
+type Result struct {
+	Comparators []string `json:"comparators"`
+	Metric      bool     `json:"metric"`
+	Validator   string   `json:"validator"`
+	ShortDesc   string   `json:"shortdesc"`
+	Type        string   `json:"type"`
+	Desc        string   `json:"desc"`
+}
+
+// Status wraps an value of a Job's "status" attribute
+type Status struct {
+	Since  int    `json:"since"`
+	Status string `json:"status"`
+}
+
+// Rule wraps an element of a Job's "rules" attribute
+type Rule struct {
+	Key        string      `json:"key"`
+	Value      interface{} `json:"value"`
+	Comparison string      `json:"comparison"`
+}
+
+// NewHTTPConfig constructs/returns a job configuration for HTTP type jobs.
+// url is the URL to query. (Required)
+// method is the HTTP method(valid methods are HEAD, GET, and POST).
+// ua is the user agent text in the request header.
+// auth is the authorization header to use in request.
+// connTimeout is the timeout(in sec) to wait for query output.
+func NewHTTPConfig(url, method, ua, auth string, connTimeout int) *Config {
+	return &Config{
+		"url":                url, // Required
+		"method":             method,
+		"user_agent":         ua,
+		"auth":               auth,
+		"connection_timeout": connTimeout,
+	}
+
+}
+
+// NewDNSConfig constructs/returns a job configuration for DNS type jobs.
+// host is the IP address or hostname of the nameserver to query. (Required)
+// domain name to query. (Required)
+// port is the dns port to query on host.
+// t is the type of the DNS record type to query.
+// respTimeout is the timeout(in ms) after sending query to wait for the output.
+func NewDNSConfig(host, domain string, port int, t string, respTimeout int) *Config {
+	return &Config{
+		"host":             host,   // Required
+		"domain":           domain, // Required
+		"port":             port,
+		"type":             t,
+		"response_timeout": respTimeout,
+	}
+}
+
+// NewTCPConfig constructs/returns a job configuration for TCP type jobs.
+// host is the IP address or hostname to connect to. (Required)
+// port is the tcp port to connect to on host. (Required)
+// connTimeout is the timeout(in ms) before giving up on trying to connect.
+// respTimeout is the timeout(in sec) after connecting to wait for output.
+// send is the string to send to the host upon connecting.
+// ssl determines whether to attempt negotiating an SSL connection.
+func NewTCPConfig(host string, port, connTimeout, respTimeout int, send string, ssl bool) *Config {
+	return &Config{
+		"host":               host, // Required
+		"port":               port, // Required
+		"connection_timeout": connTimeout,
+		"response_timeout":   respTimeout,
+		"send":               send,
+		"ssl":                ssl,
+	}
+}
+
+// NewPINGConfig constructs/returns a job configuration for PING type jobs.
+// host is the IP address or hostname to ping. (Required)
+// timeout is the timeout(in ms) before marking the host as failed.
+// count is the number of packets to send.
+// interval is the minimum time(in ms) to wait between sending each packet.
+func NewPINGConfig(host string, timeout, count, interval int) *Config {
+	return &Config{
+		"host":     host, // Required
+		"timeout":  timeout,
+		"count":    count,
+		"interval": interval,
+	}
+}

vendor/gopkg.in/ns1/ns1-go.v2/rest/model/monitor/notify.go

@@ -0,0 +1,72 @@
+package monitor
+
+// NotifyList wraps notifications.
+type NotifyList struct {
+	ID            string          `json:"id,omitempty"`
+	Name          string          `json:"name,omitempty"`
+	Notifications []*Notification `json:"notify_list,omitempty"`
+}
+
+// Notification represents endpoint to alert to.
+type Notification struct {
+	Type   string `json:"type,omitempty"`
+	Config Config `json:"config,omitempty"`
+}
+
+// NewNotifyList returns a notify list that alerts via the given notifications.
+func NewNotifyList(name string, nl ...*Notification) *NotifyList {
+	if nl == nil {
+		nl = []*Notification{}
+	}
+
+	return &NotifyList{Name: name, Notifications: nl}
+}
+
+// NewUserNotification returns a notification that alerts via user.
+func NewUserNotification(username string) *Notification {
+	return &Notification{
+		Type:   "user",
+		Config: Config{"user": username}}
+}
+
+// NewEmailNotification returns a notification that alerts via email.
+func NewEmailNotification(email string) *Notification {
+	return &Notification{
+		Type:   "email",
+		Config: Config{"email": email}}
+}
+
+// NewFeedNotification returns a notification that alerts via datafeed.
+func NewFeedNotification(sourceID string) *Notification {
+	return &Notification{
+		Type:   "datafeed",
+		Config: Config{"sourceid": sourceID}}
+}
+
+// NewWebNotification returns a notification that alerts via webhook.
+func NewWebNotification(url string) *Notification {
+	return &Notification{
+		Type:   "webhook",
+		Config: Config{"url": url}}
+}
+
+// NewPagerDutyNotification returns a notification that alerts via pagerduty.
+func NewPagerDutyNotification(key string) *Notification {
+	return &Notification{
+		Type:   "pagerduty",
+		Config: Config{"service_key": key}}
+}
+
+// NewHipChatNotification returns a notification that alerts via hipchat.
+func NewHipChatNotification(token, room string) *Notification {
+	return &Notification{
+		Type:   "hipchat",
+		Config: Config{"token": token, "room": room}}
+}
+
+// NewSlackNotification returns a notification that alerts via slack.
+func NewSlackNotification(url, username, channel string) *Notification {
+	return &Notification{
+		Type:   "slack",
+		Config: Config{"url": url, "username": username, "channel": channel}}
+}