provisioning

Documentation

Index

• Variables

Variables

var AssetsCliCommand = cli.Command{
	Name:      "asset",
	ShortName: "a",
	Usage:     "Manage node asset fields",
	Category:  "Requisitions",
	Subcommands: []cli.Command{
		{
			Name:         "list",
			Usage:        "List all the assets from a given node",
			ArgsUsage:    "<foreignSource> <foreignId>",
			Action:       listAssets,
			BashComplete: foreignIDBashComplete,
		},
		{
			Name:      "enumerate",
			ShortName: "enum",
			Usage:     "Enumerate the list of available assets",
			Action:    enumerateAssets,
		},
		{
			Name:      "set",
			Usage:     "Adds or update an asset from a given requisition/node",
			ArgsUsage: "<foreignSource> <foreignId> <assetKey> <assetValue>",
			Action:    setAsset,
		},
		{
			Name:      "delete",
			ShortName: "del",
			Usage:     "Deletes an existing asset from a given node",
			ArgsUsage: "<foreignSource> <foreignId> <assetKey>",
			Action:    deleteAsset,
		},
	},
}

AssetsCliCommand the CLI command configuration for managing categories for requisitioned nodes

var CategoriesCliCommand = cli.Command{
	Name:      "category",
	ShortName: "cat",
	Usage:     "Manage Surveillance Categories",
	Category:  "Requisitions",
	Subcommands: []cli.Command{
		{
			Name:         "list",
			Usage:        "List all monitored services from a given node",
			ArgsUsage:    "<foreignSource> <foreignId>",
			Action:       listCategories,
			BashComplete: foreignIDBashComplete,
		},
		{
			Name:      "add",
			Usage:     "Adds a new category to a given node",
			ArgsUsage: "<foreignSource> <foreignId> <categoryName>",
			Action:    addCategory,
		},
		{
			Name:      "delete",
			ShortName: "del",
			Usage:     "Deletes a category from a given node",
			ArgsUsage: "<foreignSource> <foreignId> <categoryName>",
			Action:    deleteCategory,
		},
	},
}

CategoriesCliCommand the CLI command configuration for managing categories for requisitioned nodes

var CliCommand = cli.Command{
	Name:      "provision",
	ShortName: "inv",
	Usage:     "Manage Provisioning / Inventory",
	Subcommands: []cli.Command{
		RequisitionsCliCommand,
		NodesCliCommand,
		InterfacesCliCommand,
		ServicesCliCommand,
		CategoriesCliCommand,
		AssetsCliCommand,
		ForeignSourcesCliCommand,
		DetectorsCliCommand,
		PoliciesCliCommand,
	},
}

CliCommand the CLI command configuration for managing inventory

var DetectorsCliCommand = cli.Command{
	Name:      "detector",
	ShortName: "d",
	Usage:     "Manage foreign source detectors",
	Category:  "Foreign Source Definitions",
	Subcommands: []cli.Command{
		{
			Name:         "list",
			Usage:        "List all the detectors from a given foreign source definition",
			ArgsUsage:    "<foreignSource>",
			Action:       listDetectors,
			BashComplete: requisitionNameBashComplete,
		},
		{
			Name:      "enumerate",
			ShortName: "enum",
			Usage:     "Enumerate the list of available detector classes",
			Action:    enumerateDetectorClasses,
		},
		{
			Name:      "describe",
			ShortName: "desc",
			Usage:     "Describe a given detector class",
			ArgsUsage: "<detectorName|ClassName>",
			Action:    describeDetectorClass,
		},
		{
			Name:         "get",
			Usage:        "Gets a detector from a given foreign source definition",
			ArgsUsage:    "<foreignSource> <detectorName|className>",
			Action:       getDetector,
			BashComplete: detectorBashComplete,
		},
		{
			Name:         "set",
			Usage:        "Adds or update a detector for a given foreign source definition, overriding any existing content",
			ArgsUsage:    "<foreignSource> <className> <detectorName>",
			Action:       setDetector,
			BashComplete: detectorClassBashComplete,
			Flags: []cli.Flag{
				cli.StringSliceFlag{
					Name:  "parameter, p",
					Usage: "A detector parameter (e.x. -p 'retry=2')",
				},
			},
		},
		{
			Name:         "apply",
			Usage:        "Creates or updates a detector from a external YAML file, overriding any existing content",
			Action:       applyDetector,
			BashComplete: requisitionNameBashComplete,
			Flags: []cli.Flag{
				cli.StringFlag{
					Name:  "file, f",
					Usage: "External YAML file (use '-' for STDIN Pipe)",
				},
			},
			ArgsUsage: "<foreignSource> <yaml>",
		},
		{
			Name:         "delete",
			ShortName:    "del",
			Usage:        "Deletes an existing detector from a given foreign source definition",
			ArgsUsage:    "<foreignSource> <detectorName>",
			Action:       deleteDetector,
			BashComplete: detectorBashComplete,
		},
	},
}

DetectorsCliCommand the CLI command configuration for managing foreign source detectors

var ForeignSourcesCliCommand = cli.Command{
	Name:      "foreign-source",
	ShortName: "fs",
	Usage:     "Manage foreign source definitions",
	Category:  "Foreign Source Definitions",
	Subcommands: []cli.Command{
		{
			Name:         "get",
			Usage:        "Gets a specific foreign source definition by name",
			Action:       showForeignSource,
			BashComplete: requisitionNameBashComplete,
			ArgsUsage:    "<name>",
		},
		{
			Name:         "interval",
			ShortName:    "int",
			Usage:        "Sets the scan interval for a given requisition",
			Action:       setScanInterval,
			BashComplete: requisitionNameBashComplete,
			ArgsUsage:    "<name> <interval>",
		},
		{
			Name:   "apply",
			Usage:  "Creates or updates a foreign source definition from a external file, overriding any existing content",
			Action: applyForeignSource,
			Flags: []cli.Flag{
				cli.GenericFlag{
					Name: "format, x",
					Value: &model.EnumValue{
						Enum:    Formats,
						Default: "yaml",
					},
					Usage: "File Format: " + strings.Join(Formats, ", "),
				},
				cli.StringFlag{
					Name:  "file, f",
					Usage: "External file (use '-' for STDIN Pipe)",
				},
			},
			ArgsUsage: "<content>",
		},
		{
			Name:      "validate",
			ShortName: "v",
			Usage:     "Validates a foreign source definition from a external file",
			Action:    validateForeignSource,
			Flags: []cli.Flag{
				cli.GenericFlag{
					Name: "format, x",
					Value: &model.EnumValue{
						Enum:    Formats,
						Default: "xml",
					},
					Usage: "File Format: " + strings.Join(Formats, ", "),
				},
				cli.StringFlag{
					Name:  "file, f",
					Usage: "External YAML file (use '-' for STDIN Pipe)",
				},
			},
			ArgsUsage: "<content>",
		},
		{
			Name:         "delete",
			ShortName:    "del",
			Usage:        "Deletes a foreign source definition (restoring defaults)",
			Action:       deleteForeignSource,
			BashComplete: requisitionNameBashComplete,
			ArgsUsage:    "<name>",
		},
	},
}

ForeignSourcesCliCommand the CLI command configuration for managing foreign source definitions

var Formats = []string{"xml", "json", "yaml"}

Formats the available file formats for requisitions and foreign source definitions

var InterfacesCliCommand = cli.Command{
	Name:      "interface",
	ShortName: "intf",
	Usage:     "Manage IP Interfaces",
	Category:  "Requisitions",
	Subcommands: []cli.Command{
		{
			Name:         "list",
			Usage:        "List all IP interfaces from a given node",
			ArgsUsage:    "<foreignSource> <foreignId>",
			Action:       listInterfaces,
			BashComplete: foreignIDBashComplete,
		},
		{
			Name:         "get",
			Usage:        "Gets a specific IP interface from a given node",
			ArgsUsage:    "<foreignSource> <foreignId> <ipAddress>",
			Action:       showInterface,
			BashComplete: ipAddressBashComplete,
		},
		{
			Name:      "set",
			ShortName: "add",
			Usage:     "Adds or update an IP interface from a given node",
			ArgsUsage: "<foreignSource> <foreignId> <ipAddress|fqdn>",
			Flags: []cli.Flag{
				cli.StringFlag{
					Name:  "description, d",
					Usage: "IP Interface Description",
				},
				cli.GenericFlag{
					Name: "snmpPrimary, p",
					Value: &model.EnumValue{
						Enum:    []string{"P", "N", "S"},
						Default: "N",
					},
					Usage: "Primary Interface Flag: P (primary), S (secondary), N (Not Elegible)",
				},
				cli.IntFlag{
					Name:  "status, s",
					Value: 1,
					Usage: "Interface Status: 1 for managed, 3 for unmanaged (yes, I know)",
				},
				cli.StringSliceFlag{
					Name:  "metadata, m",
					Usage: "A metadata entry (e.x. --metadata 'foo=bar')",
				},
			},
			Action:       setInterface,
			BashComplete: foreignIDBashComplete,
		},
		{
			Name:         "apply",
			Usage:        "Creates or updates an IP interface on a given node from a external YAML file, overriding any existing content",
			ArgsUsage:    "<foreignSource> <foreignId> <yaml>",
			Action:       applyInterface,
			BashComplete: foreignIDBashComplete,
		},
		{
			Name:         "delete",
			ShortName:    "del",
			Usage:        "Deletes an IP interface from a given node",
			ArgsUsage:    "<foreignSource> <foreignId> <ipAddress>",
			Action:       deleteInterface,
			BashComplete: ipAddressBashComplete,
		},
		{
			Name:      "meta",
			ShortName: "m",
			Usage:     "Manage metadata",
			Subcommands: []cli.Command{
				{
					Name:         "list",
					Usage:        "Gets all metadata for a given IP Interface",
					ArgsUsage:    "<foreignSource> <foreignId> <ipAddress>",
					Action:       intfListMetaData,
					BashComplete: ipAddressBashComplete,
				},
				{
					Name:         "set",
					Usage:        "Adds or updates a metadata entry for a given IP Interface",
					ArgsUsage:    "<foreignSource> <foreignId> <ipAddress> <metadata-key> <metadata-value>",
					Action:       intfSetMetaData,
					BashComplete: ipAddressBashComplete,
				},
				{
					Name:         "delete",
					Usage:        "Deletes a metadata entry from a given IP Interface",
					ArgsUsage:    "<foreignSource> <foreignId> <ipAddress> <metadata-key>",
					Action:       intfDeleteMetaData,
					BashComplete: ipAddressBashComplete,
				},
			},
		},
	},
}

InterfacesCliCommand the CLI command configuration for managing IP interfaces on requisitioned nodes

var NodesCliCommand = cli.Command{
	Name:      "node",
	ShortName: "n",
	Usage:     "Manage Nodes",
	Category:  "Requisitions",
	Subcommands: []cli.Command{
		{
			Name:         "list",
			Usage:        "List all nodes from a given requisition",
			ArgsUsage:    "<foreignSource>",
			BashComplete: requisitionNameBashComplete,
			Action:       listNodes,
		},
		{
			Name:         "get",
			Usage:        "Gets a specific node from a given requisition",
			ArgsUsage:    "<foreignSource> <foreignId>",
			Action:       showNode,
			BashComplete: foreignIDBashComplete,
		},
		{
			Name:         "set",
			ShortName:    "add",
			Usage:        "Adds or updates a node from a given requisition",
			ArgsUsage:    "<foreignSource> <foreignId>",
			BashComplete: foreignIDBashComplete,
			Action:       setNode,
			Flags: []cli.Flag{
				cli.StringFlag{
					Name:  "label, l",
					Usage: "Node Label",
				},
				cli.StringFlag{
					Name:  "location, L",
					Usage: "Node Location (when using Minion)",
				},
				cli.StringFlag{
					Name:  "city, c",
					Usage: "City",
				},
				cli.StringFlag{
					Name:  "building, b",
					Usage: "Building",
				},
				cli.StringFlag{
					Name:  "parentForeignSource, pfs",
					Usage: "Parent Foreign Source",
				},
				cli.StringFlag{
					Name:  "parentForeignID, pfid",
					Usage: "Parent Foreign ID",
				},
				cli.StringFlag{
					Name:  "parentNodeLabel, pnl",
					Usage: "Parent Node Label",
				},
				cli.StringSliceFlag{
					Name:  "metadata, m",
					Usage: "A metadata entry (e.x. --metadata 'foo=bar')",
				},
			},
		},
		{
			Name:  "apply",
			Usage: "Creates or updates a node on a given requisition from a external YAML file, overriding any existing content",
			Flags: []cli.Flag{
				cli.StringFlag{
					Name:  "file, f",
					Usage: "External YAML file (use '-' for STDIN Pipe)",
				},
			},
			ArgsUsage:    "<foreignSource> <yaml>",
			Action:       applyNode,
			BashComplete: requisitionNameBashComplete,
		},
		{
			Name:         "delete",
			ShortName:    "del",
			Usage:        "Deletes a node from a given requisition",
			ArgsUsage:    "<foreignSource> <foreignId>",
			Action:       deleteNode,
			BashComplete: foreignIDBashComplete,
		},
		{
			Name:      "meta",
			ShortName: "m",
			Usage:     "Manage metadata",
			Subcommands: []cli.Command{
				{
					Name:         "list",
					Usage:        "Gets all metadata for a given node",
					ArgsUsage:    "<foreignSource> <foreignId>",
					Action:       nodeListMetaData,
					BashComplete: foreignIDBashComplete,
				},
				{
					Name:         "set",
					Usage:        "Adds or updates a metadata entry for a given node",
					ArgsUsage:    "<foreignSource> <foreignId> <metadata-key> <metadata-value>",
					Action:       nodeSetMetaData,
					BashComplete: foreignIDBashComplete,
				},
				{
					Name:         "delete",
					Usage:        "Deletes a metadata entry from a given node",
					ArgsUsage:    "<foreignSource> <foreignId> <metadata-key>",
					Action:       nodeDeleteMetaData,
					BashComplete: foreignIDBashComplete,
				},
			},
		},
	},
}

NodesCliCommand the CLI command configuration for managing requisitioned nodes

var PoliciesCliCommand = cli.Command{
	Name:      "policy",
	ShortName: "p",
	Usage:     "Manage foreign source policies",
	Category:  "Foreign Source Definitions",
	Subcommands: []cli.Command{
		{
			Name:         "list",
			Usage:        "List all the policy from a given foreign source definition",
			ArgsUsage:    "<foreignSource>",
			Action:       listPolicies,
			BashComplete: requisitionNameBashComplete,
		},
		{
			Name:      "enumerate",
			ShortName: "enum",
			Usage:     "Enumerate the list of available policy classes",
			Action:    enumeratePolicyClasses,
		},
		{
			Name:      "describe",
			ShortName: "desc",
			Usage:     "Describe a given policy class",
			ArgsUsage: "<policyName|ClassName>",
			Action:    describePolicyClass,
		},
		{
			Name:         "get",
			Usage:        "Gets a policy from a given foreign source definition",
			ArgsUsage:    "<foreignSource> <policyName|className>",
			Action:       getPolicy,
			BashComplete: policyBashComplete,
		},
		{
			Name:         "set",
			Usage:        "Adds or update a policy for a given foreign source definition, overriding any existing content",
			ArgsUsage:    "<foreignSource> <policyName> <className>",
			Action:       setPolicy,
			BashComplete: policyClassBashComplete,
			Flags: []cli.Flag{
				cli.StringSliceFlag{
					Name:  "parameter, p",
					Usage: "A policy parameter (e.x. -p 'matchBehavior=ALL_PARAMETERS')",
				},
			},
		},
		{
			Name:         "apply",
			Usage:        "Creates or updates a policy from a external YAML file, overriding any existing content",
			Action:       applyPolicy,
			BashComplete: requisitionNameBashComplete,
			Flags: []cli.Flag{
				cli.StringFlag{
					Name:  "file, f",
					Usage: "External YAML file (use '-' for STDIN Pipe)",
				},
			},
			ArgsUsage: "<foreignSource> <yaml>",
		},
		{
			Name:         "delete",
			ShortName:    "del",
			Usage:        "Deletes an existing policy from a given foreign source definition",
			ArgsUsage:    "<foreignSource> <policyName>",
			Action:       deletePolicy,
			BashComplete: policyBashComplete,
		},
	},
}

PoliciesCliCommand the CLI command configuration for managing foreign source detectors

var RequisitionsCliCommand = cli.Command{
	Name:      "requisition",
	ShortName: "req",
	Usage:     "Manage Requisitions",
	Category:  "Requisitions",
	Subcommands: []cli.Command{
		{
			Name:   "list",
			Usage:  "List all requisitions",
			Action: listRequisitions,
		},
		{
			Name:         "get",
			Usage:        "Gets a specific requisition by name",
			Action:       showRequisition,
			BashComplete: requisitionNameBashComplete,
			ArgsUsage:    "<name>",
		},
		{
			Name:      "add",
			Usage:     "Adds a new requisition",
			Action:    addRequisition,
			ArgsUsage: "<name>",
		},
		{
			Name:   "apply",
			Usage:  "Creates or updates a requisition from a external file, overriding any existing content",
			Action: applyRequisition,
			Flags: []cli.Flag{
				cli.GenericFlag{
					Name: "format, x",
					Value: &model.EnumValue{
						Enum:    Formats,
						Default: "yaml",
					},
					Usage: "File Format: " + strings.Join(Formats, ", "),
				},
				cli.StringFlag{
					Name:  "file, f",
					Usage: "External file (use '-' for STDIN Pipe)",
				},
			},
			ArgsUsage: "<content>",
		},
		{
			Name:      "validate",
			ShortName: "v",
			Usage:     "Validates a requisition from a external file",
			Action:    validateRequisition,
			Flags: []cli.Flag{
				cli.GenericFlag{
					Name: "format, x",
					Value: &model.EnumValue{
						Enum:    Formats,
						Default: "xml",
					},
					Usage: "File Format: " + strings.Join(Formats, ", "),
				},
				cli.BoolFlag{
					Name:  "forceParseFQDN, F",
					Usage: "Force parsing FQDN (for XML and JSON)",
				},
				cli.StringFlag{
					Name:  "file, f",
					Usage: "External YAML file (use '-' for STDIN Pipe)",
				},
				cli.BoolFlag{
					Name:  "yaml, y",
					Usage: "To generate the YAML representation on success",
				},
			},
			ArgsUsage: "<content>",
		},
		{
			Name:         "import",
			ShortName:    "sync",
			Usage:        "Import or synchronize a requisition\n   To import all the existing requisitions use the word 'ALL'.",
			Action:       importRequisition,
			BashComplete: requisitionNameBashComplete,
			Flags: []cli.Flag{
				cli.GenericFlag{
					Name: "rescanExisting, r",
					Value: &model.EnumValue{
						Enum:    []string{"true", "false", "dbonly"},
						Default: "true",
					},
					Usage: `
	true, to update the database and execute the scan phase
	false, to add/delete nodes on the DB skipping the scan phase
	dbonly, to add/detete/update nodes on the DB skipping the scan phase
	`,
				},
			},
			ArgsUsage: "<name>|ALL",
		},
		{
			Name:         "delete",
			ShortName:    "del",
			Usage:        "Deletes a requisition",
			Action:       deleteRequisition,
			BashComplete: requisitionNameBashComplete,
			ArgsUsage:    "<name>",
		},
	},
}

RequisitionsCliCommand the CLI command configuration for managing requisitions

var ServicesCliCommand = cli.Command{
	Name:      "service",
	ShortName: "svc",
	Usage:     "Manage Monitored Services",
	Category:  "Requisitions",
	Subcommands: []cli.Command{
		{
			Name:         "list",
			Usage:        "List all monitored services from a given IP interface",
			ArgsUsage:    "<foreignSource> <foreignId> <ipAddress>",
			Action:       listServices,
			BashComplete: ipAddressBashComplete,
		},
		{
			Name:         "set",
			ShortName:    "add",
			Usage:        "Adds or update a monitored service to a given IP interface, overriding any existing content",
			ArgsUsage:    "<foreignSource> <foreignId> <ipAddress> <serviceName>",
			Action:       setService,
			BashComplete: servicesBashComplete,
			Flags: []cli.Flag{
				cli.StringSliceFlag{
					Name:  "metadata, m",
					Usage: "A metadata entry (e.x. --metadata 'foo=bar')",
				},
			},
		},
		{
			Name:         "delete",
			ShortName:    "del",
			Usage:        "Deletes a monitored service from a given IP interface",
			ArgsUsage:    "<foreignSource> <foreignId> <ipAddress> <serviceName>",
			Action:       deleteService,
			BashComplete: servicesBashComplete,
		},
		{
			Name:      "meta",
			ShortName: "m",
			Usage:     "Manage metadata",
			Subcommands: []cli.Command{
				{
					Name:         "list",
					Usage:        "Gets all metadata for a given service",
					ArgsUsage:    "<foreignSource> <foreignId> <ipAddress> <serviceName>",
					Action:       svcListMetaData,
					BashComplete: servicesBashComplete,
				},
				{
					Name:         "set",
					Usage:        "Adds or updates a metadata entry for a given service",
					ArgsUsage:    "<foreignSource> <foreignId> <ipAddress> <serviceName> <metadata-key> <metadata-value>",
					Action:       svcSetMetaData,
					BashComplete: servicesBashComplete,
				},
				{
					Name:         "delete",
					Usage:        "Deletes a metadata entry from a given service",
					ArgsUsage:    "<foreignSource> <foreignId> <ipAddress> <serviceName> <metadata-key>",
					Action:       svcDeleteMetaData,
					BashComplete: servicesBashComplete,
				},
			},
		},
	},
}

ServicesCliCommand the CLI command configuration for managing services on IP interfaces for requisitioned nodes