518 lines
15 KiB
PHP
518 lines
15 KiB
PHP
<?php
|
|
|
|
namespace Icinga\Module\Director\Cli;
|
|
|
|
use Icinga\Cli\Params;
|
|
use Icinga\Exception\MissingParameterException;
|
|
use Icinga\Module\Director\Data\Db\DbObject;
|
|
use Icinga\Module\Director\Data\Exporter;
|
|
use Icinga\Module\Director\Data\PropertyMangler;
|
|
use Icinga\Module\Director\IcingaConfig\IcingaConfig;
|
|
use Icinga\Module\Director\Objects\IcingaHost;
|
|
use Icinga\Module\Director\Objects\IcingaObject;
|
|
use InvalidArgumentException;
|
|
|
|
class ObjectCommand extends Command
|
|
{
|
|
protected $type;
|
|
|
|
private $name;
|
|
|
|
private $object;
|
|
|
|
private $experimentalFlags = array();
|
|
|
|
public function init()
|
|
{
|
|
$this->shiftExperimentalFlags();
|
|
}
|
|
|
|
/**
|
|
* Show a specific object
|
|
*
|
|
* Use this command to show single objects rendered as Icinga 2
|
|
* config or in JSON format.
|
|
*
|
|
* USAGE
|
|
*
|
|
* icingacli director <type> show <name> [options]
|
|
*
|
|
* OPTIONS
|
|
*
|
|
* --resolved Resolve all inherited properties and show a flat
|
|
* object
|
|
* --json Use JSON format
|
|
* --no-pretty JSON is pretty-printed per default. Use this flag
|
|
* to enforce un-formatted JSON
|
|
* --no-defaults Per default JSON output ships null or default
|
|
* values. This flag skips those properties
|
|
* --with-services For hosts only, also shows attached services
|
|
* --all-services For hosts only, show applied and inherited services
|
|
* too
|
|
*/
|
|
public function showAction()
|
|
{
|
|
$db = $this->db();
|
|
$object = $this->getObject();
|
|
$exporter = new Exporter($db);
|
|
$resolve = (bool) $this->params->shift('resolved');
|
|
$withServices = (bool) $this->params->get('with-services');
|
|
$allServices = (bool) $this->params->get('all-services');
|
|
if ($withServices) {
|
|
if (!$object instanceof IcingaHost) {
|
|
$this->fail('--with-services is available for Hosts only');
|
|
}
|
|
$exporter->enableHostServices();
|
|
}
|
|
if ($allServices) {
|
|
if (!$object instanceof IcingaHost) {
|
|
$this->fail('--all-services is available for Hosts only');
|
|
}
|
|
$exporter->serviceLoader()->resolveHostServices();
|
|
}
|
|
|
|
$exporter->resolveObjects($resolve);
|
|
$exporter->showDefaults($this->params->shift('no-defaults', false));
|
|
|
|
if ($this->params->shift('json')) {
|
|
echo $this->renderJson($exporter->export($object), !$this->params->shift('no-pretty'));
|
|
} else {
|
|
$config = new IcingaConfig($db);
|
|
if ($resolve) {
|
|
$object = $object::fromPlainObject($object->toPlainObject(true, false, null, false), $db);
|
|
}
|
|
$object->renderToConfig($config);
|
|
if ($withServices) {
|
|
foreach ($exporter->serviceLoader()->fetchServicesForHost($object) as $service) {
|
|
$service->renderToConfig($config);
|
|
}
|
|
}
|
|
foreach ($config->getFiles() as $filename => $content) {
|
|
printf("/** %s **/\n\n", $filename);
|
|
echo $content;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a new object
|
|
*
|
|
* Use this command to create a new Icinga object
|
|
*
|
|
* USAGE
|
|
*
|
|
* icingacli director <type> create [<name>] [options]
|
|
*
|
|
* OPTIONS
|
|
*
|
|
* --<key> <value> Provide all properties as single command line
|
|
* options
|
|
* --json Otherwise provide all options as a JSON string
|
|
*
|
|
* EXAMPLES
|
|
*
|
|
* icingacli director host create localhost \
|
|
* --imports generic-host \
|
|
* --address 127.0.0.1 \
|
|
* --vars.location 'My datacenter'
|
|
*
|
|
* icingacli director host create localhost \
|
|
* --json '{ "address": "127.0.0.1" }'
|
|
*/
|
|
public function createAction()
|
|
{
|
|
$type = $this->getType();
|
|
$props = $this->getObjectProperties();
|
|
$name = $props['object_name'];
|
|
$object = IcingaObject::createByType($type, $props, $this->db());
|
|
|
|
if ($object->store()) {
|
|
printf("%s '%s' has been created\n", $type, $name);
|
|
if ($this->hasExperimental('live-creation')) {
|
|
if ($this->api()->createObjectAtRuntime($object)) {
|
|
echo "Live creation for '$name' succeeded\n";
|
|
} else {
|
|
echo "Live creation for '$name' succeeded\n";
|
|
exit(1);
|
|
}
|
|
|
|
if ($type === 'Host' && $this->hasExperimental('immediate-check')) {
|
|
echo "Waiting for check result...";
|
|
flush();
|
|
if ($res = $this->api()->checkHostAndWaitForResult($name)) {
|
|
echo " done\n" . $res->output . "\n";
|
|
} else {
|
|
echo "TIMEOUT\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
exit(0);
|
|
} else {
|
|
printf("%s '%s' has not been created\n", $type, $name);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Modify an existing objects properties
|
|
*
|
|
* Use this command to modify specific properties of an existing
|
|
* Icinga object
|
|
*
|
|
* USAGE
|
|
*
|
|
* icingacli director <type> set <name> [options]
|
|
*
|
|
* OPTIONS
|
|
*
|
|
* --<key> <value> Provide all properties as single command line
|
|
* options
|
|
* --append-<key> <value> Appends to array values, like `imports`,
|
|
* `groups` or `vars.system_owners`
|
|
* --remove-<key> [<value>] Remove a specific property, eventually only
|
|
* when matching `value`. In case the property is an
|
|
* array it will remove just `value` when given
|
|
* --json Otherwise provide all options as a JSON string
|
|
* --replace Replace all object properties with the given ones
|
|
* --auto-create Create the object in case it does not exist
|
|
*
|
|
* EXAMPLES
|
|
*
|
|
* icingacli director host set localhost \
|
|
* --address 127.0.0.2 \
|
|
* --vars.location 'Somewhere else'
|
|
*
|
|
* icingacli director host set localhost \
|
|
* --json '{ "address": "127.0.0.2" }'
|
|
*/
|
|
public function setAction()
|
|
{
|
|
$name = $this->getName();
|
|
$type = $this->getType();
|
|
|
|
if ($this->params->shift('auto-create') && ! $this->exists($name)) {
|
|
$action = 'created';
|
|
$object = $this->create($type, $name);
|
|
} else {
|
|
$action = 'modified';
|
|
$object = $this->getObject();
|
|
}
|
|
|
|
$appends = self::stripPrefixedProperties($this->params, 'append-');
|
|
$remove = self::stripPrefixedProperties($this->params, 'remove-');
|
|
|
|
if ($this->params->shift('replace')) {
|
|
$object->replaceWith($this->create($type, $name, $this->remainingParams()));
|
|
} else {
|
|
$object->setProperties($this->remainingParams());
|
|
}
|
|
|
|
PropertyMangler::appendToArrayProperties($object, $appends);
|
|
PropertyMangler::removeProperties($object, $remove);
|
|
$this->persistChanges($object, $type, $name, $action);
|
|
}
|
|
|
|
protected function persistChanges(DbObject $object, $type, $name, $action)
|
|
{
|
|
if ($object->hasBeenModified() && $object->store()) {
|
|
printf("%s '%s' has been %s\n", $type, $name, $action);
|
|
exit(0);
|
|
}
|
|
|
|
printf("%s '%s' has not been modified\n", $type, $name);
|
|
exit(0);
|
|
}
|
|
|
|
/**
|
|
* Delete a specific object
|
|
*
|
|
* Use this command to delete a single Icinga object
|
|
*
|
|
* USAGE
|
|
*
|
|
* icingacli director <type> delete <name>
|
|
*
|
|
* EXAMPLES
|
|
*
|
|
* icingacli director host delete localhost2
|
|
*
|
|
* icingacli director host delete localhost{3..8}
|
|
*/
|
|
public function deleteAction()
|
|
{
|
|
$type = $this->getType();
|
|
|
|
foreach ($this->shiftOneOrMoreNames() as $name) {
|
|
if ($this->load($name)->delete()) {
|
|
printf("%s '%s' has been deleted\n", $type, $name);
|
|
} else {
|
|
printf("Something went wrong while deleting %s '%s'\n", $type, $name);
|
|
exit(1);
|
|
}
|
|
|
|
$this->object = null;
|
|
}
|
|
exit(0);
|
|
}
|
|
|
|
/**
|
|
* Whether a specific object exists
|
|
*
|
|
* Use this command to find out whether a single Icinga object exists
|
|
*
|
|
* USAGE
|
|
*
|
|
* icingacli director <type> exists <name>
|
|
*/
|
|
public function existsAction()
|
|
{
|
|
$name = $this->getName();
|
|
$type = $this->getType();
|
|
if ($this->exists($name)) {
|
|
printf("%s '%s' exists\n", $type, $name);
|
|
exit(0);
|
|
} else {
|
|
printf("%s '%s' does not exist\n", $type, $name);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clone an existing object
|
|
*
|
|
* Use this command to clone a specific object
|
|
*
|
|
* USAGE
|
|
*
|
|
* icingacli director <type> clone <name> --from <original> [options]
|
|
*
|
|
* OPTIONS
|
|
* --from <original> The name of the object you want to clone
|
|
* --<key> <value> Override specific properties while cloning
|
|
* --replace In case an object <name> already exists replace
|
|
* it with the clone
|
|
* --flat Do no keep inherited properties but create a flat
|
|
* object with all resolved/inherited properties
|
|
*
|
|
* EXAMPLES
|
|
*
|
|
* icingacli director host clone localhost2 --from localhost
|
|
*
|
|
* icingacli director host clone localhost{3..8} --from localhost2
|
|
*
|
|
* icingacli director host clone localhost3 --from localhost \
|
|
* --address 127.0.0.3
|
|
*/
|
|
public function cloneAction()
|
|
{
|
|
$fromName = $this->params->shiftRequired('from');
|
|
$from = $this->load($fromName);
|
|
|
|
// $name = $this->getName();
|
|
$type = $this->getType();
|
|
|
|
$resolve = $this->params->shift('flat');
|
|
$replace = $this->params->shift('replace');
|
|
|
|
$from->setProperties($this->remainingParams());
|
|
|
|
foreach ($this->shiftOneOrMoreNames() as $name) {
|
|
$object = $from::fromPlainObject(
|
|
$from->toPlainObject($resolve),
|
|
$from->getConnection()
|
|
);
|
|
|
|
$object->set('object_name', $name);
|
|
|
|
if ($replace && $this->exists($name)) {
|
|
$object = $this->load($name)->replaceWith($object);
|
|
}
|
|
|
|
if ($object->hasBeenModified() && $object->store()) {
|
|
printf("%s '%s' has been cloned from %s\n", $type, $name, $fromName);
|
|
} else {
|
|
printf("%s '%s' has not been modified\n", $this->getType(), $name);
|
|
}
|
|
}
|
|
|
|
exit(0);
|
|
}
|
|
|
|
protected static function stripPrefixedProperties(Params $params, $prefix = 'append-')
|
|
{
|
|
$appends = [];
|
|
$len = strlen($prefix);
|
|
|
|
foreach ($params->getParams() as $key => $value) {
|
|
if (substr($key, 0, $len) === $prefix) {
|
|
$appends[substr($key, $len)] = $value;
|
|
}
|
|
}
|
|
|
|
foreach ($appends as $key => $value) {
|
|
$params->shift("$prefix$key");
|
|
}
|
|
|
|
return $appends;
|
|
}
|
|
|
|
protected function getObjectProperties()
|
|
{
|
|
$name = $this->params->shift();
|
|
|
|
$props = $this->remainingParams();
|
|
if (! array_key_exists('object_type', $props)) {
|
|
$props['object_type'] = 'object';
|
|
}
|
|
|
|
// Normalize object_name, compare to given name
|
|
if ($name) {
|
|
if (array_key_exists('object_name', $props)) {
|
|
if ($name !== $props['object_name']) {
|
|
$this->fail(sprintf(
|
|
"Name '%s' conflicts with object_name '%s'\n",
|
|
$name,
|
|
$props['object_name']
|
|
));
|
|
}
|
|
} else {
|
|
$props['object_name'] = $name;
|
|
}
|
|
} else {
|
|
if (! array_key_exists('object_name', $props)) {
|
|
$this->fail('Cannot create an object with at least an object name');
|
|
}
|
|
}
|
|
|
|
return $props;
|
|
}
|
|
|
|
protected function shiftOneOrMoreNames()
|
|
{
|
|
$names = array();
|
|
while ($name = $this->params->shift()) {
|
|
$names[] = $name;
|
|
}
|
|
|
|
if (empty($names)) {
|
|
throw new MissingParameterException('Required object name is missing');
|
|
}
|
|
|
|
return $names;
|
|
}
|
|
|
|
protected function remainingParams()
|
|
{
|
|
if ($json = $this->params->shift('json')) {
|
|
if ($json === true) {
|
|
$json = $this->readFromStdin();
|
|
if ($json === null) {
|
|
$this->fail('Please pass JSON either via STDIN or via --json');
|
|
}
|
|
}
|
|
return (array) $this->parseJson($json);
|
|
} else {
|
|
return $this->params->getParams();
|
|
}
|
|
}
|
|
|
|
protected function readFromStdin()
|
|
{
|
|
if (!defined('STDIN')) {
|
|
define('STDIN', fopen('php://stdin', 'r'));
|
|
}
|
|
$inputIsTty = function_exists('posix_isatty') && posix_isatty(STDIN);
|
|
if ($inputIsTty) {
|
|
return null;
|
|
}
|
|
|
|
$stdin = file_get_contents('php://stdin');
|
|
if (strlen($stdin) === 0) {
|
|
return null;
|
|
}
|
|
|
|
return $stdin;
|
|
}
|
|
|
|
protected function exists($name)
|
|
{
|
|
return IcingaObject::existsByType(
|
|
$this->getType(),
|
|
$name,
|
|
$this->db()
|
|
);
|
|
}
|
|
|
|
protected function load($name)
|
|
{
|
|
return IcingaObject::loadByType(
|
|
$this->getType(),
|
|
$name,
|
|
$this->db()
|
|
);
|
|
}
|
|
|
|
protected function create($type, $name, $properties = [])
|
|
{
|
|
return IcingaObject::createByType($type, $properties + [
|
|
'object_type' => 'object',
|
|
'object_name' => $name
|
|
], $this->db());
|
|
}
|
|
|
|
/**
|
|
* @return IcingaObject
|
|
*/
|
|
protected function getObject()
|
|
{
|
|
if ($this->object === null) {
|
|
$this->object = $this->load($this->getName());
|
|
}
|
|
|
|
return $this->object;
|
|
}
|
|
|
|
protected function getType()
|
|
{
|
|
if ($this->type === null) {
|
|
// Extract the command class name...
|
|
$className = substr(strrchr(get_class($this), '\\'), 1);
|
|
// ...and strip the Command extension
|
|
$this->type = substr($className, 0, -7);
|
|
}
|
|
|
|
return $this->type;
|
|
}
|
|
|
|
protected function getName()
|
|
{
|
|
if ($this->name === null) {
|
|
$name = $this->params->shift();
|
|
if (! $name) {
|
|
throw new InvalidArgumentException('Object name parameter is required');
|
|
}
|
|
|
|
$this->name = $name;
|
|
}
|
|
|
|
return $this->name;
|
|
}
|
|
|
|
protected function hasExperimental($flag)
|
|
{
|
|
return array_key_exists($flag, $this->experimentalFlags);
|
|
}
|
|
|
|
protected function shiftExperimentalFlags()
|
|
{
|
|
if ($flags = $this->params->shift('experimental')) {
|
|
foreach (preg_split('/,/', $flags) as $flag) {
|
|
$this->experimentalFlags[$flag] = true;
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
}
|