resources: Use named fields to avoid bothering go vet

This removes an invalid warning which tries to prevent ambiguous changes
I suppose.

.dockerignore

@@ -0,0 +1 @@
+docker

.editorconfig

@@ -0,0 +1,19 @@
+; This file is for unifying the coding style for different editors and IDEs.
+; Plugins are available for notepad++, emacs, vim, gedit,
+; textmate, visual studio, and more.
+;
+; See http://editorconfig.org for details.
+
+# Top-most EditorConfig file.
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.go]
+indent_style = tab
+
+[Makefile]
+indent_style = tab

.gitignore

@@ -1,3 +1,10 @@
+.omv/
+.ssh/
+.vagrant/
 mgmt-documentation.pdf
 old/
 tmp/
+*_stringer.go
+mgmt
+mgmt.static
+rpmbuild/

.gitmodules

@@ -0,0 +1,12 @@
+[submodule "vendor/github.com/coreos/etcd"]
+	path = vendor/github.com/coreos/etcd
+	url = https://github.com/coreos/etcd/
+[submodule "vendor/google.golang.org/grpc"]
+	path = vendor/google.golang.org/grpc
+	url = https://github.com/grpc/grpc-go
+[submodule "vendor/github.com/grpc-ecosystem/grpc-gateway"]
+	path = vendor/github.com/grpc-ecosystem/grpc-gateway
+	url = https://github.com/grpc-ecosystem/grpc-gateway
+[submodule "vendor/gopkg.in/fsnotify.v1"]
+	path = vendor/gopkg.in/fsnotify.v1
+	url = https://gopkg.in/fsnotify.v1

.travis.yml

@@ -0,0 +1,27 @@
+language: go
+go:
+  - 1.6
+  - 1.7
+  - tip
+sudo: false
+before_install: 'git fetch --unshallow'
+install: 'make deps'
+script: 'make test'
+matrix:
+  fast_finish: true
+  allow_failures:
+    - go: tip
+    - go: 1.7
+notifications:
+  irc:
+    channels:
+      - "irc.freenode.net#mgmtconfig"
+    template:
+      - "%{repository} (%{commit}: %{author}): %{message}"
+      - "More info : %{build_url}"
+    on_success: always
+    on_failure: always
+    use_notice: false
+    skip_join: false
+  email:
+    - travis-ci@shubin.ca

AUTHORS

@@ -5,3 +5,4 @@ For a more exhaustive list please run: git log --format='%aN' | sort -u
 This list is sorted alphabetically by first name.
 
 James Shubin
+Paul Morgan

COPYRIGHT

@@ -1,5 +1,5 @@
 Mgmt
-Copyright (C) 2013-2015+ James Shubin and the project contributors
+Copyright (C) 2013-2016+ James Shubin and the project contributors
 Written by James Shubin <james@shubin.ca> and the project contributors
 
 This program is free software: you can redistribute it and/or modify

DOCUMENTATION.md

@@ -2,7 +2,7 @@
 
 <!--
 Mgmt
-Copyright (C) 2013-2015+ James Shubin and the project contributors
+Copyright (C) 2013-2016+ James Shubin and the project contributors
 Written by James Shubin <james@shubin.ca> and the project contributors
 
 This program is free software: you can redistribute it and/or modify
@@ -30,18 +30,26 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 1. [Overview](#overview)
 2. [Project description - What the project does](#project-description)
 3. [Setup - Getting started with mgmt](#setup)
-4. [Usage/FAQ - Notes on usage and frequently asked questions](#usage-and-frequently-asked-questions)
+4. [Features - All things mgmt can do](#features)
-5. [Reference - Detailed reference](#reference)
+	* [Autoedges - Automatic resource relationships](#autoedges)
-	* [graph.yaml](#graph.yaml)
+	* [Autogrouping - Automatic resource grouping](#autogrouping)
+	* [Automatic clustering - Automatic cluster management](#automatic-clustering)
+	* [Remote mode - Remote "agent-less" execution](#remote-agent-less-mode)
+	* [Puppet support - write manifest code for mgmt](#puppet-support)
+5. [Resources - All built-in primitives](#resources)
+6. [Usage/FAQ - Notes on usage and frequently asked questions](#usage-and-frequently-asked-questions)
+7. [Reference - Detailed reference](#reference)
+	* [Meta parameters](#meta-parameters)
+	* [Graph definition file](#graph-definition-file)
 	* [Command line](#command-line)
-6. [Examples - Example configurations](#examples)
+8. [Examples - Example configurations](#examples)
-7. [Development - Background on module development and reporting bugs](#development)
+9. [Development - Background on module development and reporting bugs](#development)
-8. [Authors - Authors and contact information](#authors)
+10. [Authors - Authors and contact information](#authors)
 
 ##Overview
 
-The `mgmt` tool is a research prototype to demonstrate next generation config
+The `mgmt` tool is a next generation config management prototype. It's not yet
-management techniques. Hopefully it will evolve into a useful, robust tool.
+ready for production, but we hope to get there soon. Get involved today!
 
 ##Project Description
 
@@ -49,6 +57,16 @@ The mgmt tool is a distributed, event driven, config management tool, that
 supports parallel execution, and librarification to be used as the management
 foundation in and for, new and existing software.
 
+For more information, you may like to read some blog posts from the author:
+
+* [Next generation config mgmt](https://ttboj.wordpress.com/2016/01/18/next-generation-configuration-mgmt/)
+* [Automatic edges in mgmt](https://ttboj.wordpress.com/2016/03/14/automatic-edges-in-mgmt/)
+* [Automatic grouping in mgmt](https://ttboj.wordpress.com/2016/03/30/automatic-grouping-in-mgmt/)
+* [Automatic clustering in mgmt](https://ttboj.wordpress.com/2016/06/20/automatic-clustering-in-mgmt/)
+
+There is also an [introductory video](http://meetings-archive.debian.net/pub/debian-meetings/2016/debconf16/Next_Generation_Config_Mgmt.webm) available.
+Older videos and other material [is available](https://github.com/purpleidea/mgmt/#on-the-web).
+
 ##Setup
 
 During this prototype phase, the tool can be run out of the source directory.
@@ -57,6 +75,217 @@ get started. Beware that this _can_ cause data loss. Understand what you're
 doing first, or perform these actions in a virtual environment such as the one
 provided by [Oh-My-Vagrant](https://github.com/purpleidea/oh-my-vagrant).
 
+##Features
+
+This section details the numerous features of mgmt and some caveats you might
+need to be aware of.
+
+###Autoedges
+
+Automatic edges, or AutoEdges, is the mechanism in mgmt by which it will
+automatically create dependencies for you between resources. For example,
+since mgmt can discover which files are installed by a package it will
+automatically ensure that any file resource you declare that matches a
+file installed by your package resource will only be processed after the
+package is installed.
+
+####Controlling autoedges
+
+Though autoedges is likely to be very helpful and avoid you having to declare
+all dependencies explicitly, there are cases where this behaviour is
+undesirable.
+
+Some distributions allow package installations to automatically start the
+service they ship. This can be problematic in the case of packages like MySQL
+as there are configuration options that need to be set before MySQL is ever
+started for the first time (or you'll need to wipe the data directory). In
+order to handle this situation you can disable autoedges per resource and
+explicitly declare that you want `my.cnf` to be written to disk before the
+installation of the `mysql-server` package.
+
+You can disable autoedges for a resource by setting the `autoedge` key on
+the meta attributes of that resource to `false`.
+
+####Blog post
+
+You can read the introductory blog post about this topic here:
+[https://ttboj.wordpress.com/2016/03/14/automatic-edges-in-mgmt/](https://ttboj.wordpress.com/2016/03/14/automatic-edges-in-mgmt/)
+
+###Autogrouping
+
+Automatic grouping or AutoGroup is the mechanism in mgmt by which it will
+automatically group multiple resource vertices into a single one. This is
+particularly useful for grouping multiple package resources into a single
+resource, since the multiple installations can happen together in a single
+transaction, which saves a lot of time because package resources typically have
+a large fixed cost to running (downloading and verifying the package repo) and
+if they are grouped they share this fixed cost. This grouping feature can be
+used for other use cases too.
+
+You can disable autogrouping for a resource by setting the `autogroup` key on
+the meta attributes of that resource to `false`.
+
+####Blog post
+
+You can read the introductory blog post about this topic here:
+[https://ttboj.wordpress.com/2016/03/30/automatic-grouping-in-mgmt/](https://ttboj.wordpress.com/2016/03/30/automatic-grouping-in-mgmt/)
+
+###Automatic clustering
+
+Automatic clustering is a feature by which mgmt automatically builds, scales,
+and manages the embedded etcd cluster which is compiled into mgmt itself. It is
+quite helpful for rapidly bootstrapping clusters and avoiding the extra work to
+setup etcd.
+
+If you prefer to avoid this feature. you can always opt to use an existing etcd
+cluster that is managed separately from mgmt by pointing your mgmt agents at it
+with the `--seeds` variable.
+
+####Blog post
+
+You can read the introductory blog post about this topic here:
+[https://ttboj.wordpress.com/2016/06/20/automatic-clustering-in-mgmt/](https://ttboj.wordpress.com/2016/06/20/automatic-clustering-in-mgmt/)
+
+###Remote ("agent-less") mode
+
+Remote mode is a special mode that lets you kick off mgmt runs on one or more
+remote machines which are only accessible via SSH. In this mode the initiating
+host connects over SSH, copies over the `mgmt` binary, opens an SSH tunnel, and
+runs the remote program while simultaneously passing the etcd traffic back
+through the tunnel so that the initiators etcd cluster can be used to exchange
+resource data.
+
+The interesting benefit of this architecture is that multiple hosts which can't
+connect directly use the initiator to pass the important traffic through to each
+other. Once the cluster has converged all the remote programs can shutdown
+leaving no residual agent.
+
+This mode can also be useful for bootstrapping a new host where you'd like to
+have the service run continuously and as part of an mgmt cluster normally.
+
+In particular, when combined with the `--converged-timeout` parameter, the
+entire set of running mgmt agents will need to all simultaneously converge for
+the group to exit. This is particularly useful for bootstrapping new clusters
+which need to exchange information that is only available at run time.
+
+####Blog post
+
+An introductory blog post about this topic will follow soon.
+
+###Puppet support
+
+You can supply a Puppet manifest instead of creating the (YAML) graph manually.
+Puppet must be installed and in `mgmt`'s search path. You also need the
+[ffrank-mgmtgraph Puppet module](https://forge.puppet.com/ffrank/mgmtgraph).
+
+Invoke `mgmt` with the `--puppet` switch, which supports 3 variants:
+
+1. Request the configuration from the Puppet Master (like `puppet agent` does)
+
+        mgmt run --puppet agent
+
+2. Compile a local manifest file (like `puppet apply`)
+
+        mgmt run --puppet /path/to/my/manifest.pp
+
+3. Compile an ad hoc manifest from the commandline (like `puppet apply -e`)
+
+        mgmt run --puppet 'file { "/etc/ntp.conf": ensure => file }'
+
+For more details and caveats see [Puppet.md](Puppet.md).
+
+####Blog post
+
+An introductory post on the Puppet support is on
+[Felix's blog](http://ffrank.github.io/features/2016/06/19/puppet-powered-mgmt/).
+
+##Resources
+
+This section lists all the built-in resources and their properties. The
+resource primitives in `mgmt` are typically more powerful than resources in
+other configuration management systems because they can be event based which
+lets them respond in real-time to converge to the desired state. This property
+allows you to build more complex resources that you probably hadn't considered
+in the past.
+
+In addition to the resource specific properties, there are resource properties
+(otherwise known as parameters) which can apply to every resource. These are
+called [meta parameters](#meta-parameters) and are listed separately. Certain
+meta parameters aren't very useful when combined with certain resources, but
+in general, it should be fairly obvious, such as when combining the `noop` meta
+parameter with the [Noop](#Noop) resource.
+
+* [Exec](#Exec): Execute shell commands on the system.
+* [File](#File): Manage files and directories.
+* [Msg](#Msg): Send log messages.
+* [Noop](#Noop): A simple resource that does nothing.
+* [Pkg](#Pkg):  Manage system packages with PackageKit.
+* [Svc](#Svc): Manage system systemd services.
+* [Timer](#Timer): Manage system systemd services.
+
+###Exec
+
+The exec resource can execute commands on your system.
+
+###File
+
+The file resource manages files and directories. In `mgmt`, directories are
+identified by a trailing slash in their path name. File have no such slash.
+
+####Path
+
+The path property specifies the file or directory that we are managing.
+
+####Content
+
+The content property is a string that specifies the desired file contents.
+
+####Source
+
+The source property points to a source file or directory path that we wish to
+copy over and use as the desired contents for our resource.
+
+####State
+
+The state property describes the action we'd like to apply for the resource. The
+possible values are: `exists` and `absent`.
+
+####Recurse
+
+The recurse property limits whether file resource operations should recurse into
+and monitor directory contents with a depth greater than one.
+
+####Force
+
+The force property is required if we want the file resource to be able to change
+a file into a directory or vice-versa. If such a change is needed, but the force
+property is not set to `true`, then this file resource will error.
+
+###Msg
+
+The msg resource sends messages to the main log, or an external service such
+as systemd's journal.
+
+###Noop
+
+The noop resource does absolutely nothing. It does have some utility in testing
+`mgmt` and also as a placeholder in the resource graph.
+
+###Pkg
+
+The pkg resource is used to manage system packages. This resource works on many
+different distributions because it uses the underlying packagekit facility which
+supports different backends for different environments. This ensures that we
+have great Debian (deb/dpkg) and Fedora (rpm/dnf) support simultaneously.
+
+###Svc
+
+The service resource is still very WIP. Please help us my improving it!
+
+###Timer
+
+This resource needs better documentation. Please help us my improving it!
+
 ##Usage and frequently asked questions
 (Send your questions as a patch to this FAQ! I'll review it, merge it, and
 respond by commit with the answer.)
@@ -67,6 +296,66 @@ I wanted a next generation config management solution that didn't have all of
 the design flaws or limitations that the current generation of tools do, and no
 tool existed!
 
+###Why did you use etcd? What about consul?
+
+Etcd and consul are both written in golang, which made them the top two
+contenders for my prototype. Ultimately a choice had to be made, and etcd was
+chosen, but it was also somewhat arbitrary. If there is available interest,
+good reasoning, *and* patches, then we would consider either switching or
+supporting both, but this is not a high priority at this time.
+
+###Can I use an existing etcd cluster instead of the automatic embedded servers?
+
+Yes, it's possible to use an existing etcd cluster instead of the automatic,
+elastic embedded etcd servers. To do so, simply point to the cluster with the
+`--seeds` variable, the same way you would if you were seeding a new member to
+an existing mgmt cluster.
+
+The downside to this approach is that you won't benefit from the automatic
+elastic nature of the embedded etcd servers, and that you're responsible if you
+accidentally break your etcd cluster, or if you use an unsupported version.
+
+###What does the error message about an inconsistent dataDir mean?
+
+If you get an error message similar to:
+
+```
+Etcd: Connect: CtxError...
+Etcd: CtxError: Reason: CtxDelayErr(5s): No endpoints available yet!
+Etcd: Connect: Endpoints: []
+Etcd: The dataDir (/var/lib/mgmt/etcd) might be inconsistent or corrupt.
+```
+
+This happens when there are a series of fatal connect errors in a row. This can
+happen when you start `mgmt` using a dataDir that doesn't correspond to the
+current cluster view. As a result, the embedded etcd server never finishes
+starting up, and as a result, a default endpoint never gets added. The solution
+is to either reconcile the mistake, and if there is no important data saved, you
+can remove the etcd dataDir. This is typically `/var/lib/mgmt/etcd/member/`.
+
+###Why do resources have both a `Compare` method and an `IFF` (on the UUID) method?
+
+The `Compare()` methods are for determining if two resources are effectively the
+same, which is used to make graph change delta's efficient. This is when we want
+to change from the current running graph to a new graph, but preserve the common
+vertices. Since we want to make this process efficient, we only update the parts
+that are different, and leave everything else alone. This `Compare()` method can
+tell us if two resources are the same.
+
+The `IFF()` method is part of the whole UUID system, which is for discerning if
+a resource meets the requirements another expects for an automatic edge. This is
+because the automatic edge system assumes a unified UUID pattern to test for
+equality. In the future it might be helpful or sane to merge the two similar
+comparison functions although for now they are separate because they are
+actually answer different questions.
+
+###Did you know that there is a band named `MGMT`?
+
+I didn't realize this when naming the project, and it is accidental. After much
+anguishing, I chose the name because it was short and I thought it was
+appropriately descriptive. If you need a less ambiguous search term or phrase,
+you can try using `mgmtconfig` or `mgmt config`.
+
 ###You didn't answer my question, or I have a question!
 
 It's best to ask on [IRC](https://webchat.freenode.net/?channels=#mgmtconfig)
@@ -84,11 +373,42 @@ information on these options, please view the source at:
 If you feel that a well used option needs documenting here, please patch it!
 
 ###Overview of reference
-* [graph.yaml](#graph.yaml): Main graph definition file.
+* [Meta parameters](#meta-parameters): List of available resource meta parameters.
+* [Graph definition file](#graph-definition-file): Main graph definition file.
 * [Command line](#command-line): Command line parameters.
 
-###graph.yaml
+###Meta parameters
-This is the compiled graph definition file. The format is currently
+These meta parameters are special parameters (or properties) which can apply to
+any resource. The usefulness of doing so will depend on the particular meta
+parameter and resource combination.
+
+####AutoEdge
+Boolean. Should we generate auto edges for this resource?
+
+####AutoGroup
+Boolean. Should we attempt to automatically group this resource with others?
+
+####Noop
+Boolean. Should the Apply portion of the CheckApply method of the resource
+make any changes? Noop is a concatenation of no-operation.
+
+####Retry
+Integer. The number of times to retry running the resource on error. Use -1 for
+infinite. This currently applies for both the Watch operation (which can fail)
+and for the CheckApply operation. While they could have separate values, I've
+decided to use the same ones for both until there's a proper reason to want to
+do something differently for the Watch errors.
+
+####Delay
+Integer. Number of milliseconds to wait between retries. The same value is
+shared between the Watch and CheckApply retries. This currently applies for both
+the Watch operation (which can fail) and for the CheckApply operation. While
+they could have separate values, I've decided to use the same ones for both
+until there's a proper reason to want to do something differently for the Watch
+errors.
+
+###Graph definition file
+graph.yaml is the compiled graph definition file. The format is currently
 undocumented, but by looking through the [examples/](https://github.com/purpleidea/mgmt/tree/master/examples)
 you can probably figure out most of it, as it's fairly intuitive.
 
@@ -99,12 +419,86 @@ documentation, please run `mgmt --help`.
 ####`--file <graph.yaml>`
 Point to a graph file to run.
 
+####`--converged-timeout <seconds>`
+Exit if the machine has converged for approximately this many seconds.
+
+####`--max-runtime <seconds>`
+Exit when the agent has run for approximately this many seconds. This is not
+generally recommended, but may be useful for users who know what they're doing.
+
+####`--noop`
+Globally force all resources into no-op mode. This also disables the export to
+etcd functionality, but does not disable resource collection, however all
+resources that are collected will have their individual noop settings set.
+
+####`--remote <graph.yaml>`
+Point to a graph file to run on the remote host specified within. This parameter
+can be used multiple times if you'd like to remotely run on multiple hosts in
+parallel.
+
+####`--allow-interactive`
+Allow interactive prompting for SSH passwords if there is no authentication
+method that works.
+
+####`--ssh-priv-id-rsa`
+Specify the path for finding SSH keys. This defaults to `~/.ssh/id_rsa`. To
+never use this method of authentication, set this to the empty string.
+
+####`--cconns`
+The maximum number of concurrent remote ssh connections to run. This defaults
+to `0`, which means unlimited.
+
+####`--no-caching`
+Don't allow remote caching of the remote execution binary. This will require
+the binary to be copied over for every remote execution, but it limits the
+likelihood that there is leftover information from the configuration process.
+
+####`--prefix <path>`
+Specify a path to a custom working directory prefix. This directory will get
+created if it does not exist. This usually defaults to `/var/lib/mgmt/`. This
+can't be combined with the `--tmp-prefix` option. It can be combined with the
+`--allow-tmp-prefix` option.
+
+####`--tmp-prefix`
+If this option is specified, a temporary prefix will be used instead of the
+default prefix. This can't be combined with the `--prefix` option.
+
+####`--allow-tmp-prefix`
+If this option is specified, we will attempt to fall back to a temporary prefix
+if the primary prefix couldn't be created. This is useful for avoiding failures
+in environments where the primary prefix may or may not be available, but you'd
+like to try. The canonical example is when running `mgmt` with `--remote` there
+might be a cached copy of the binary in the primary prefix, but in case there's
+no binary available continue working in a temporary directory to avoid failure.
+
 ##Examples
 For example configurations, please consult the [examples/](https://github.com/purpleidea/mgmt/tree/master/examples) directory in the git
 source repository. It is available from:
 
 [https://github.com/purpleidea/mgmt/tree/master/examples](https://github.com/purpleidea/mgmt/tree/master/examples)
 
+### Systemd:
+See [`misc/mgmt.service`](misc/mgmt.service) for a sample systemd unit file.
+This unit file is part of the RPM.
+
+To specify your custom options for `mgmt` on a systemd distro:
+
+```bash
+sudo mkdir -p /etc/systemd/system/mgmt.service.d/
+
+cat > /etc/systemd/system/mgmt.service.d/env.conf <<EOF
+# Environment variables:
+MGMT_SEEDS=http://127.0.0.1:2379
+MGMT_CONVERGED_TIMEOUT=-1
+MGMT_MAX_RUNTIME=0
+
+# Other CLI options if necessary.
+#OPTS="--max-runtime=0"
+EOF
+
+sudo systemctl daemon-reload
+```
+
 ##Development
 
 This is a project that I started in my free time in 2013. Development is driven
@@ -117,7 +511,7 @@ To report any bugs, please file a ticket at: [https://github.com/purpleidea/mgmt
 
 ##Authors
 
-Copyright (C) 2013-2015+ James Shubin and the project contributors
+Copyright (C) 2013-2016+ James Shubin and the project contributors
 
 Please see the
 [AUTHORS](https://github.com/purpleidea/mgmt/tree/master/AUTHORS) file

Makefile

@@ -1,45 +1,275 @@
-SHELL = /bin/bash
+# Mgmt
-.PHONY: all version run race build clean test format docs
+# Copyright (C) 2013-2016+ James Shubin and the project contributors
+# Written by James Shubin <james@shubin.ca> and the project contributors
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+SHELL = /usr/bin/env bash
+.PHONY: all art cleanart version program path deps run race generate build clean test gofmt yamlfmt format docs rpmbuild mkdirs rpm srpm spec tar upload upload-sources upload-srpms upload-rpms copr
 .SILENT: clean
 
-VERSION := $(shell git describe --match '[0-9]*\.[0-9]*\.[0-9]*' --tags --dirty)
+SVERSION := $(or $(SVERSION),$(shell git describe --match '[0-9]*\.[0-9]*\.[0-9]*' --tags --dirty --always))
-PROGRAM := $(notdir $(CURDIR))
+VERSION := $(or $(VERSION),$(shell git describe --match '[0-9]*\.[0-9]*\.[0-9]*' --tags --abbrev=0))
+PROGRAM := $(shell echo $(notdir $(CURDIR)) | cut -f1 -d"-")
+OLDGOLANG := $(shell go version | grep -E 'go1.3|go1.4')
+ifeq ($(VERSION),$(SVERSION))
+	RELEASE = 1
+else
+	RELEASE = untagged
+endif
+ARCH = $(uname -m)
+SPEC = rpmbuild/SPECS/$(PROGRAM).spec
+SOURCE = rpmbuild/SOURCES/$(PROGRAM)-$(VERSION).tar.bz2
+SRPM = rpmbuild/SRPMS/$(PROGRAM)-$(VERSION)-$(RELEASE).src.rpm
+SRPM_BASE = $(PROGRAM)-$(VERSION)-$(RELEASE).src.rpm
+RPM = rpmbuild/RPMS/$(PROGRAM)-$(VERSION)-$(RELEASE).$(ARCH).rpm
+USERNAME := $(shell cat ~/.config/copr 2>/dev/null | grep username | awk -F '=' '{print $$2}' | tr -d ' ')
+SERVER = 'dl.fedoraproject.org'
+REMOTE_PATH = 'pub/alt/$(USERNAME)/$(PROGRAM)'
 
-all: docs
+#
+#	art
+#
+art: art/mgmt_logo_default_symbol.png art/mgmt_logo_default_tall.png art/mgmt_logo_default_wide.png art/mgmt_logo_reversed_symbol.png art/mgmt_logo_reversed_tall.png art/mgmt_logo_reversed_wide.png art/mgmt_logo_white_symbol.png art/mgmt_logo_white_tall.png art/mgmt_logo_white_wide.png
+
+cleanart:
+	rm -f art/mgmt_logo_default_symbol.png art/mgmt_logo_default_tall.png art/mgmt_logo_default_wide.png art/mgmt_logo_reversed_symbol.png art/mgmt_logo_reversed_tall.png art/mgmt_logo_reversed_wide.png art/mgmt_logo_white_symbol.png art/mgmt_logo_white_tall.png art/mgmt_logo_white_wide.png
+
+# NOTE: the widths are arbitrary
+art/mgmt_logo_default_symbol.png: art/mgmt_logo_default_symbol.svg
+	inkscape --export-background='#ffffff' --without-gui --export-png "$@" --export-width 300 $(@:png=svg)
+
+art/mgmt_logo_default_tall.png: art/mgmt_logo_default_tall.svg
+	inkscape --export-background='#ffffff' --without-gui --export-png "$@" --export-width 400 $(@:png=svg)
+
+art/mgmt_logo_default_wide.png: art/mgmt_logo_default_wide.svg
+	inkscape --export-background='#ffffff' --without-gui --export-png "$@" --export-width 800 $(@:png=svg)
+
+art/mgmt_logo_reversed_symbol.png: art/mgmt_logo_reversed_symbol.svg
+	inkscape --export-background='#231f20' --without-gui --export-png "$@" --export-width 300 $(@:png=svg)
+
+art/mgmt_logo_reversed_tall.png: art/mgmt_logo_reversed_tall.svg
+	inkscape --export-background='#231f20' --without-gui --export-png "$@" --export-width 400 $(@:png=svg)
+
+art/mgmt_logo_reversed_wide.png: art/mgmt_logo_reversed_wide.svg
+	inkscape --export-background='#231f20' --without-gui --export-png "$@" --export-width 800 $(@:png=svg)
+
+art/mgmt_logo_white_symbol.png: art/mgmt_logo_white_symbol.svg
+	inkscape --export-background='#231f20' --without-gui --export-png "$@" --export-width 300 $(@:png=svg)
+
+art/mgmt_logo_white_tall.png: art/mgmt_logo_white_tall.svg
+	inkscape --export-background='#231f20' --without-gui --export-png "$@" --export-width 400 $(@:png=svg)
+
+art/mgmt_logo_white_wide.png: art/mgmt_logo_white_wide.svg
+	inkscape --export-background='#231f20' --without-gui --export-png "$@" --export-width 800 $(@:png=svg)
+
+all: docs $(PROGRAM).static
 
 # show the current version
 version:
 	@echo $(VERSION)
 
+program:
+	@echo $(PROGRAM)
+
+path:
+	./misc/make-path.sh
+
+deps:
+	./misc/make-deps.sh
+
 run:
-	find -maxdepth 1 -type f -name '*.go' -not -name '*_test.go' | xargs go run -ldflags "-X main.version $(VERSION) -X main.program $(PROGRAM)"
+	find . -maxdepth 1 -type f -name '*.go' -not -name '*_test.go' | xargs go run -ldflags "-X main.program=$(PROGRAM) -X main.version=$(SVERSION)"
 
-# include race test
+# include race flag
 race:
-	find -maxdepth 1 -type f -name '*.go' -not -name '*_test.go' | xargs go run -race -ldflags "-X main.version $(VERSION) -X main.program $(PROGRAM)"
+	find . -maxdepth 1 -type f -name '*.go' -not -name '*_test.go' | xargs go run -race -ldflags "-X main.program=$(PROGRAM) -X main.version=$(SVERSION)"
 
-build: mgmt
+generate:
+	go generate
 
-mgmt: main.go
+build: $(PROGRAM)
-	go build -ldflags "-X main.version $(VERSION) -X main.program $(PROGRAM)"
+
+$(PROGRAM): main.go
+	@echo "Building: $(PROGRAM), version: $(SVERSION)..."
+ifneq ($(OLDGOLANG),)
+	@# avoid equals sign in old golang versions eg in: -X foo=bar
+	time go build -ldflags "-X main.program $(PROGRAM) -X main.version $(SVERSION)" -o $(PROGRAM);
+else
+	time go build -ldflags "-X main.program=$(PROGRAM) -X main.version=$(SVERSION)" -o $(PROGRAM);
+endif
+
+$(PROGRAM).static: main.go
+	@echo "Building: $(PROGRAM).static, version: $(SVERSION)..."
+	go generate
+ifneq ($(OLDGOLANG),)
+	@# avoid equals sign in old golang versions eg in: -X foo=bar
+	go build -a -installsuffix cgo -tags netgo -ldflags '-extldflags "-static" -X main.program $(PROGRAM) -X main.version $(SVERSION)' -o $(PROGRAM).static;
+else
+	go build -a -installsuffix cgo -tags netgo -ldflags '-extldflags "-static" -X main.program=$(PROGRAM) -X main.version=$(SVERSION)' -o $(PROGRAM).static;
+endif
 
 clean:
-	[ ! -e mgmt ] || rm mgmt
+	[ ! -e $(PROGRAM) ] || rm $(PROGRAM)
+	rm -f *_stringer.go	# generated by `go generate`
+	rm -f *_mock.go		# generated by `go generate`
 
 test:
 	./test.sh
-	./test/test-gofmt.sh
-	./test/test-yamlfmt.sh
-	go test
-	#go test ./pgraph
-	go test -race
-	#go test -race ./pgraph
 
-format:
+gofmt:
-	find -type f -name '*.go' -not -path './old/*' -not -path './tmp/*' -exec gofmt -w {} \;
+	find . -maxdepth 3 -type f -name '*.go' -not -path './old/*' -not -path './tmp/*' -exec gofmt -w {} \;
-	find -type f -name '*.yaml' -not -path './old/*' -not -path './tmp/*' -exec ruby -e "require 'yaml'; x=YAML.load_file('{}').to_yaml; File.open('{}', 'w').write x" \;
 
-docs: mgmt-documentation.pdf
+yamlfmt:
+	find . -maxdepth 3 -type f -name '*.yaml' -not -path './old/*' -not -path './tmp/*' -not -path './omv.yaml' -exec ruby -e "require 'yaml'; x=YAML.load_file('{}').to_yaml.each_line.map(&:rstrip).join(10.chr)+10.chr; File.open('{}', 'w').write x" \;
 
-mgmt-documentation.pdf: DOCUMENTATION.md
+format: gofmt yamlfmt
-	pandoc DOCUMENTATION.md -o 'mgmt-documentation.pdf'
+
+docs: $(PROGRAM)-documentation.pdf
+
+$(PROGRAM)-documentation.pdf: DOCUMENTATION.md
+	pandoc DOCUMENTATION.md -o '$(PROGRAM)-documentation.pdf'
+
+#
+#	build aliases
+#
+# TODO: does making an rpm depend on making a .srpm first ?
+rpm: $(SRPM) $(RPM)
+	# do nothing
+
+srpm: $(SRPM)
+	# do nothing
+
+spec: $(SPEC)
+	# do nothing
+
+tar: $(SOURCE)
+	# do nothing
+
+rpmbuild/SOURCES/: tar
+rpmbuild/SRPMS/: srpm
+rpmbuild/RPMS/: rpm
+
+upload: upload-sources upload-srpms upload-rpms
+	# do nothing
+
+#
+#	rpmbuild
+#
+$(RPM): $(SPEC) $(SOURCE)
+	@echo Running rpmbuild -bb...
+	rpmbuild --define '_topdir $(shell pwd)/rpmbuild' -bb $(SPEC) && \
+	mv rpmbuild/RPMS/$(ARCH)/$(PROGRAM)-$(VERSION)-$(RELEASE).*.rpm $(RPM)
+
+$(SRPM): $(SPEC) $(SOURCE)
+	@echo Running rpmbuild -bs...
+	rpmbuild --define '_topdir $(shell pwd)/rpmbuild' -bs $(SPEC)
+	# renaming is not needed because we aren't using the dist variable
+	#mv rpmbuild/SRPMS/$(PROGRAM)-$(VERSION)-$(RELEASE).*.src.rpm $(SRPM)
+
+#
+#	spec
+#
+$(SPEC): rpmbuild/ spec.in
+	@echo Running templater...
+	#cat spec.in > $(SPEC)
+	sed -e s/__PROGRAM__/$(PROGRAM)/ -e s/__VERSION__/$(VERSION)/ -e s/__RELEASE__/$(RELEASE)/ < spec.in > $(SPEC)
+	# append a changelog to the .spec file
+	git log --format="* %cd %aN <%aE>%n- (%h) %s%d%n" --date=local | sed -r 's/[0-9]+:[0-9]+:[0-9]+ //' >> $(SPEC)
+
+#
+#	archive
+#
+$(SOURCE): rpmbuild/
+	@echo Running git archive...
+	# use HEAD if tag doesn't exist yet, so that development is easier...
+	git archive --prefix=$(PROGRAM)-$(VERSION)/ -o $(SOURCE) $(VERSION) 2> /dev/null || (echo 'Warning: $(VERSION) does not exist. Using HEAD instead.' && git archive --prefix=$(PROGRAM)-$(VERSION)/ -o $(SOURCE) HEAD)
+	# TODO: if git archive had a --submodules flag this would easier!
+	@echo Running git archive submodules...
+	# i thought i would need --ignore-zeros, but it doesn't seem necessary!
+	p=`pwd` && (echo .; git submodule foreach) | while read entering path; do \
+		temp="$${path%\'}"; \
+		temp="$${temp#\'}"; \
+		path=$$temp; \
+		[ "$$path" = "" ] && continue; \
+		(cd $$path && git archive --prefix=$(PROGRAM)-$(VERSION)/$$path/ HEAD > $$p/rpmbuild/tmp.tar && tar --concatenate --file=$$p/$(SOURCE) $$p/rpmbuild/tmp.tar && rm $$p/rpmbuild/tmp.tar); \
+	done
+
+# TODO: ensure that each sub directory exists
+rpmbuild/:
+	mkdir -p rpmbuild/{BUILD,BUILDROOT,RPMS,SOURCES,SPECS,SRPMS}
+
+mkdirs:
+	mkdir -p rpmbuild/{BUILD,BUILDROOT,RPMS,SOURCES,SPECS,SRPMS}
+
+#
+#	sha256sum
+#
+rpmbuild/SOURCES/SHA256SUMS: rpmbuild/SOURCES/ $(SOURCE)
+	@echo Running SOURCES sha256sum...
+	cd rpmbuild/SOURCES/ && sha256sum *.tar.bz2 > SHA256SUMS; cd -
+
+rpmbuild/SRPMS/SHA256SUMS: rpmbuild/SRPMS/ $(SRPM)
+	@echo Running SRPMS sha256sum...
+	cd rpmbuild/SRPMS/ && sha256sum *src.rpm > SHA256SUMS; cd -
+
+rpmbuild/RPMS/SHA256SUMS: rpmbuild/RPMS/ $(RPM)
+	@echo Running RPMS sha256sum...
+	cd rpmbuild/RPMS/ && sha256sum *.rpm > SHA256SUMS; cd -
+
+#
+#	gpg
+#
+rpmbuild/SOURCES/SHA256SUMS.asc: rpmbuild/SOURCES/SHA256SUMS
+	@echo Running SOURCES gpg...
+	# the --yes forces an overwrite of the SHA256SUMS.asc if necessary
+	gpg2 --yes --clearsign rpmbuild/SOURCES/SHA256SUMS
+
+rpmbuild/SRPMS/SHA256SUMS.asc: rpmbuild/SRPMS/SHA256SUMS
+	@echo Running SRPMS gpg...
+	gpg2 --yes --clearsign rpmbuild/SRPMS/SHA256SUMS
+
+rpmbuild/RPMS/SHA256SUMS.asc: rpmbuild/RPMS/SHA256SUMS
+	@echo Running RPMS gpg...
+	gpg2 --yes --clearsign rpmbuild/RPMS/SHA256SUMS
+
+#
+#	upload
+#
+# upload to public server
+upload-sources: rpmbuild/SOURCES/ rpmbuild/SOURCES/SHA256SUMS rpmbuild/SOURCES/SHA256SUMS.asc
+	if [ "`cat rpmbuild/SOURCES/SHA256SUMS`" != "`ssh $(SERVER) 'cd $(REMOTE_PATH)/SOURCES/ && cat SHA256SUMS'`" ]; then \
+		echo Running SOURCES upload...; \
+		rsync -avz rpmbuild/SOURCES/ $(SERVER):$(REMOTE_PATH)/SOURCES/; \
+	fi
+
+upload-srpms: rpmbuild/SRPMS/ rpmbuild/SRPMS/SHA256SUMS rpmbuild/SRPMS/SHA256SUMS.asc
+	if [ "`cat rpmbuild/SRPMS/SHA256SUMS`" != "`ssh $(SERVER) 'cd $(REMOTE_PATH)/SRPMS/ && cat SHA256SUMS'`" ]; then \
+		echo Running SRPMS upload...; \
+		rsync -avz rpmbuild/SRPMS/ $(SERVER):$(REMOTE_PATH)/SRPMS/; \
+	fi
+
+upload-rpms: rpmbuild/RPMS/ rpmbuild/RPMS/SHA256SUMS rpmbuild/RPMS/SHA256SUMS.asc
+	if [ "`cat rpmbuild/RPMS/SHA256SUMS`" != "`ssh $(SERVER) 'cd $(REMOTE_PATH)/RPMS/ && cat SHA256SUMS'`" ]; then \
+		echo Running RPMS upload...; \
+		rsync -avz --prune-empty-dirs rpmbuild/RPMS/ $(SERVER):$(REMOTE_PATH)/RPMS/; \
+	fi
+
+#
+#	copr build
+#
+copr: upload-srpms
+	./misc/copr-build.py https://$(SERVER)/$(REMOTE_PATH)/SRPMS/$(SRPM_BASE)
+
+# vim: ts=8

Puppet.md

@@ -0,0 +1,163 @@
+#mgmt Puppet support
+
+1. [Prerequisites](#prerequisites)
+    * [Testing the Puppet side](#testing-the-puppet-side)
+2. [Writing a suitable manifest](#writing-a-suitable-manifest)
+    * [Unsupported attributes](#unsupported-attributes)
+    * [Unsupported resources](#unsupported-resources)
+    * [Avoiding common warnings](#avoiding-common-warnings)
+3. [Configuring Puppet](#configuring-puppet)
+4. [Caveats](#caveats)
+
+`mgmt` can use Puppet as its source for the configuration graph.
+This document goes into detail on how this works, and lists
+some pitfalls and limitations.
+
+For basic instructions on how to use the Puppet support, see
+the [main documentation](DOCUMENTATION.md#puppet-support).
+
+##Prerequisites
+
+You need Puppet installed in your system. It is not important how you
+get it. On the most common Linux distributions, you can use packages
+from the OS maintainer, or upstream Puppet repositories. An alternative
+that will also work on OSX is the `puppet` Ruby gem. It also has the
+advantage that you can install any desired version in your home directory
+or any other location.
+
+Any release of Puppet's 3.x and 4.x series should be suitable for use with
+`mgmt`. Most importantly, make sure to install the `ffrank-mgmtgraph` Puppet
+module (referred to below as "the translator module").
+
+    puppet module install ffrank-mgmtgraph
+
+Please note that the module is not required on your Puppet master (if you
+use a master/agent setup). It's needed on the machine that runs `mgmt`.
+You can install the module on the master anyway, so that it gets distributed
+to your agents through Puppet's `pluginsync` mechanism.
+
+###Testing the Puppet side
+
+The following command should run successfully and print a YAML hash on your
+terminal:
+
+```puppet
+puppet mgmtgraph print --code 'file { "/tmp/mgmt-test": ensure => present }'
+```
+
+You can use this CLI to test any manifests before handing them straight
+to `mgmt`.
+
+##Writing a suitable manifest
+
+###Unsupported attributes
+
+`mgmt` inherited its resource module from Puppet, so by and large, it's quite
+possible to express `mgmt` graphs in terms of Puppet manifests. However,
+there isn't (and likely never will be) full feature parity between the
+respective resource types. In consequence, a manifest can have semantics that
+cannot be transferred to `mgmt`.
+
+For example, at the time of writing this, the `file` type in `mgmt` had no
+notion of permissions (the file `mode`) yet. This lead to the following
+warning (among others that will be discussed below):
+
+    $ puppet mgmtgraph print --code 'file { "/tmp/foo": mode => "0600" }'
+    Warning: cannot translate: File[/tmp/foo] { mode => "600" } (attribute is ignored)
+
+This is a heads-up for the user, because the resulting `mgmt` graph will
+in fact not pass this information to the `/tmp/foo` file resource, and
+`mgmt` will ignore this file's permissions. Including such attributes in
+manifests that are written expressly for `mgmt` is not sensible and should
+be avoided.
+
+###Unsupported resources
+
+Puppet has a fairly large number of
+[built-in types](https://docs.puppet.com/puppet/latest/reference/type.html),
+and countless more are available through
+[modules](https://forge.puppet.com/). It's unlikely that all of them will
+eventually receive native counterparts in `mgmt`.
+
+When encountering an unknown resource, the translator module will replace
+it with an `exec` resource in its output. This resource will run the equivalent
+of a `puppet resource` command to make Puppet apply the original resource
+itself. This has quite abysmal performance, because processing such a
+resource requires the forking of at least one Puppet process (two if it
+is found to be out of sync). This comes with considerable overhead.
+On most systems, starting up any Puppet command takes several seconds.
+Compared to the split second that the actual work usually takes,
+this overhead can amount to several orders of magnitude.
+
+Avoid Puppet types that `mgmt` does not implement (yet).
+
+###Avoiding common warnings
+
+Many resource parameters in Puppet take default values. For the most part,
+the translator module just ignores them. However, there are cases in which
+Puppet will default to convenient behavior that `mgmt` cannot quite replicate.
+For example, translating a plain `file` resource will lead to a warning message:
+
+    $ puppet mgmtgraph print --code 'file { "/tmp/mgmt-test": }'
+    Warning: File[/tmp/mgmt-test] uses the 'puppet' file bucket, which mgmt cannot do. There will be no backup copies!
+
+The reason is that per default, Puppet assumes the following parameter value
+(among others)
+
+```puppet
+file { "/tmp/mgmt-test":
+  backup => 'puppet',
+}
+```
+
+To avoid this, specify the parameter explicitly:
+
+    $ puppet mgmtgraph print --code 'file { "/tmp/mgmt-test": backup => false }'
+
+This is tedious in a more complex manifest. A good simplification is the
+following [resource default](https://docs.puppet.com/puppet/latest/reference/lang_defaults.html)
+anywhere on the top scope of your manifest:
+
+```puppet
+File { backup => false }
+```
+
+If you encounter similar warnings from other types and/or parameters,
+use the same approach to silence them if possible.
+
+##Configuring Puppet
+
+Since `mgmt` uses an actual Puppet CLI behind the scenes, you might
+need to tweak some of Puppet's runtime options in order to make it
+do what you want. Reasons for this could be among the following:
+
+* You use the `--puppet agent` variant and need to configure
+`servername`, `certname` and other master/agent-related options.
+* You don't want runtime information to end up in the `vardir`
+that is used by your regular `puppet agent`.
+* You install specific Puppet modules for `mgmt` in a non-standard
+location.
+
+`mgmt` exposes only one Puppet option in order to allow you to
+control all of them, through its `--puppet-conf` option. It allows
+you to specify which `puppet.conf` file should be used during
+translation.
+
+    mgmt run --puppet /opt/my-manifest.pp --puppet-conf /etc/mgmt/puppet.conf
+
+Within this file, you can just specify any needed options in the
+`[main]` section:
+
+    [main]
+    server=mgmt-master.example.net
+    vardir=/var/lib/mgmt/puppet
+
+##Caveats
+
+Please see the [README](https://github.com/ffrank/puppet-mgmtgraph/blob/master/README.md)
+of the translator module for the current state of supported and unsupported
+language features.
+
+You should probably make sure to always use the latest release of
+both `ffrank-mgmtgraph` and `ffrank-yamlresource` (the latter is
+getting pulled in as a dependency of the former).

README.md

@@ -1,35 +1,95 @@
-# *mgmt*: This is: mgmt!
+# *mgmt*: next generation config management!
 
-[![Build Status](https://secure.travis-ci.org/purpleidea/mgmt.png)](http://travis-ci.org/purpleidea/mgmt)
+[![mgmt!](art/mgmt.png)](art/)
+
+[![Go Report Card](https://goreportcard.com/badge/github.com/purpleidea/mgmt)](https://goreportcard.com/report/github.com/purpleidea/mgmt)
+[![Build Status](https://secure.travis-ci.org/purpleidea/mgmt.png?branch=master)](http://travis-ci.org/purpleidea/mgmt)
+[![Documentation](https://img.shields.io/docs/markdown.png)](DOCUMENTATION.md)
+[![GoDoc](https://godoc.org/github.com/purpleidea/mgmt?status.svg)](https://godoc.org/github.com/purpleidea/mgmt)
+[![IRC](https://img.shields.io/irc/%23mgmtconfig.png)](https://webchat.freenode.net/?channels=#mgmtconfig)
+[![Jenkins](https://img.shields.io/jenkins/status.png)](https://ci.centos.org/job/purpleidea-mgmt/)
+[![COPR](https://img.shields.io/copr/builds.png)](https://copr.fedoraproject.org/coprs/purpleidea/mgmt/)
+[![arch](https://img.shields.io/arch/aur.png)](https://aur.archlinux.org/packages/mgmt/)
+
+## Community:
+Come join us on IRC in [#mgmtconfig](https://webchat.freenode.net/?channels=#mgmtconfig) on Freenode!
+You may like the [#mgmtconfig](https://twitter.com/hashtag/mgmtconfig) hashtag if you're on [Twitter](https://twitter.com/#!/purpleidea).
+
+## Status:
+Mgmt is a fairly new project.
+We're working towards being minimally useful for production environments.
+We aren't feature complete for what we'd consider a 1.x release yet.
+With your help you'll be able to influence our design and get us there sooner!
+
+## Questions:
+Please join the [#mgmtconfig](https://webchat.freenode.net/?channels=#mgmtconfig) IRC community!
+If you have a well phrased question that might benefit others, consider asking it by sending a patch to the documentation [FAQ](https://github.com/purpleidea/mgmt/blob/master/DOCUMENTATION.md#usage-and-frequently-asked-questions) section. I'll merge your question, and a patch with the answer!
+
+## Quick start:
+* Make sure you have golang version 1.6 or greater installed.
+* Clone the repository recursively, eg: `git clone --recursive https://github.com/purpleidea/mgmt/`.
+* Get the remaining golang dependencies on your own, or run `make deps` if you're comfortable with how we install them.
+* Run `make build` to get a freshly built `mgmt` binary.
+* Run `time ./mgmt run --file examples/graph0.yaml --converged-timeout=5 --tmp-prefix` to try out a very simple example!
+* To run continuously in the default mode of operation, omit the `--converged-timeout` option.
+* Have fun hacking on our future technology!
+
+## Examples:
+Please look in the [examples/](examples/) folder for more examples!
 
 ## Documentation:
 Please see: [DOCUMENTATION.md](DOCUMENTATION.md) or [PDF](https://pdfdoc-purpleidea.rhcloud.com/pdf/https://github.com/purpleidea/mgmt/blob/master/DOCUMENTATION.md).
 
-## Questions:
+## Roadmap:
-Come join us in [#mgmtconfig](https://webchat.freenode.net/?channels=#mgmtconfig) on Freenode!
+Please see: [TODO.md](TODO.md) for a list of upcoming work and TODO items.
+Please get involved by working on one of these items or by suggesting something else!
+Feel free to grab one of the straightforward [#mgmtlove](https://github.com/purpleidea/mgmt/labels/mgmtlove) issues if you're a first time contributor to the project or if you're unsure about what to hack on!
 
-## Examples:
+## Bugs:
-Please look in the [examples/](examples/) folder for usage. If none exist, please contribute one!
+Please set the `DEBUG` constant in [main.go](https://github.com/purpleidea/mgmt/blob/master/main.go) to `true`, and post the logs when you report the [issue](https://github.com/purpleidea/mgmt/issues).
-
+Bonus points if you provide a [shell](https://github.com/purpleidea/mgmt/tree/master/test/shell) or [OMV](https://github.com/purpleidea/mgmt/tree/master/test/omv) reproducible test case.
-## Notes:
+Feel free to read my article on [debugging golang programs](https://ttboj.wordpress.com/2016/02/15/debugging-golang-programs/).
-* This is currently a research project into next generation config management technologies!
-* This is my first complex project in golang, please notify me of any issues.
-* I have some well thought out designs for the future of this project, which I'll try and write up clearly and publish as soon as possible.
-* Please don't expect stable interfaces, code, or any data safety.
-* This design is the result of ideas I've had from hacking on advanced config management projects.
-* I first started hacking on this in ~2013, even though I had very little time for it.
-* I couldn't think of a good name for the project, so it's now being called `mgmt` until someone contributes a better one!
-* I've published a number of articles about this tool:
-  * TODO
-* There are some screencasts available:
-  * TODO
 
 ## Dependencies:
-* golang (available in most distros)
+* golang 1.6 or higher (required, available in most distros)
-* pandoc (for building a pdf of the documentation)
+* golang libraries (required, available with `go get`)
+
+        go get github.com/coreos/etcd/client
+        go get gopkg.in/yaml.v2
+        go get gopkg.in/fsnotify.v1
+        go get github.com/urfave/cli
+        go get github.com/coreos/go-systemd/dbus
+        go get github.com/coreos/go-systemd/util
+        go get github.com/coreos/pkg/capnslog
+
+* stringer (required for building), available as a package on some platforms, otherwise via `go get`
+
+        go get golang.org/x/tools/cmd/stringer
+
+* pandoc (optional, for building a pdf of the documentation)
+* graphviz (optional, for building a visual representation of the graph)
 
 ## Patches:
-We'd love to have your patch! Please send it by email, or as a pull request.
+We'd love to have your patches! Please send them by email, or as a pull request.
+
+## On the web:
+* James Shubin; blog: [Next generation configuration mgmt](https://ttboj.wordpress.com/2016/01/18/next-generation-configuration-mgmt/)
+* James Shubin; video: [Introductory recording from DevConf.cz 2016](https://www.youtube.com/watch?v=GVhpPF0j-iE&html5=1)
+* James Shubin; video: [Introductory recording from CfgMgmtCamp.eu 2016](https://www.youtube.com/watch?v=fNeooSiIRnA&html5=1)
+* Julian Dunn; video: [On mgmt at CfgMgmtCamp.eu 2016](https://www.youtube.com/watch?v=kfF9IATUask&t=1949&html5=1)
+* Walter Heck; slides: [On mgmt at CfgMgmtCamp.eu 2016](http://www.slideshare.net/olindata/configuration-management-time-for-a-4th-generation/3)
+* Marco Marongiu; blog: [On mgmt](http://syslog.me/2016/02/15/leap-or-die/)
+* Felix Frank; blog: [From Catalog To Mgmt (on puppet to mgmt "transpiling")](https://ffrank.github.io/features/2016/02/18/from-catalog-to-mgmt/)
+* James Shubin; blog: [Automatic edges in mgmt (...and the pkg resource)](https://ttboj.wordpress.com/2016/03/14/automatic-edges-in-mgmt/)
+* James Shubin; blog: [Automatic grouping in mgmt](https://ttboj.wordpress.com/2016/03/30/automatic-grouping-in-mgmt/)
+* John Arundel; tweet: [“Puppet’s days are numbered.”](https://twitter.com/bitfield/status/732157519142002688)
+* Felix Frank; blog: [Puppet, Meet Mgmt (on puppet to mgmt internals)](https://ffrank.github.io/features/2016/06/12/puppet,-meet-mgmt/)
+* Felix Frank; blog: [Puppet Powered Mgmt (puppet to mgmt tl;dr)](https://ffrank.github.io/features/2016/06/19/puppet-powered-mgmt/)
+* James Shubin; blog: [Automatic clustering in mgmt](https://ttboj.wordpress.com/2016/06/20/automatic-clustering-in-mgmt/)
+* James Shubin; video: [Recording from CoreOSFest 2016](https://www.youtube.com/watch?v=KVmDCUA42wc&html5=1)
+* James Shubin; video: [Recording from DebConf16](http://meetings-archive.debian.net/pub/debian-meetings/2016/debconf16/Next_Generation_Config_Mgmt.webm) ([Slides](https://annex.debconf.org//debconf-share/debconf16/slides/15-next-generation-config-mgmt.pdf))
+* Felix Frank; blog: [Edging It All In (puppet and mgmt edges)](https://ffrank.github.io/features/2016/07/12/edging-it-all-in/)
+* Felix Frank; blog: [Translating All The Things (puppet to mgmt translation warnings)](https://ffrank.github.io/features/2016/08/19/translating-all-the-things/)
 
 ##
 

THANKS

@@ -9,8 +9,16 @@ Chris Wright - For encouraging me to continue work on my prototype.
 
 Daniel Riek - For supporting and sheltering this project from bureaucracy.
 
+Diego Ongaro - For good chats, particularly around distributed systems.
+
+Felix Frank - For taking a difficult problem and building an inspiring solution.
+
+Ira Cooper - For having an algorithmic design discussion with me.
+
 Jeff Darcy - For some algorithm recommendations, and NACKing my TopoSort idea!
 
 Red Hat, inc. - For paying my salary, thus financially supporting my hacking.
 
+Samuel Gélineau - For help with programming language theory and design.
+
 And many others...

TODO.md

@@ -0,0 +1,67 @@
+# TODO
+If you're looking for something to do, look here!
+Let us know if you're working on one of the items.
+
+## Package resource
+- [ ] getfiles support on debian [bug](https://github.com/hughsie/PackageKit/issues/118)
+- [ ] directory info on fedora [bug](https://github.com/hughsie/PackageKit/issues/117)
+- [ ] dnf blocker [bug](https://github.com/hughsie/PackageKit/issues/110)
+- [ ] install signal blocker [bug](https://github.com/hughsie/PackageKit/issues/109)
+
+## File resource [bug](https://github.com/purpleidea/mgmt/issues/13) [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+- [ ] chown/chmod support [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+- [ ] user/group support [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+- [ ] recurse limit support [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+- [ ] fanotify support [bug](https://github.com/go-fsnotify/fsnotify/issues/114)
+
+## Svc resource
+- [ ] base resource improvements
+
+## Exec resource
+- [ ] base resource improvements
+
+## Timer resource
+- [ ] reset on recompile
+- [ ] increment algorithm (linear, exponential, etc...) [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+
+## User/Group resource
+- [ ] base resource [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+- [ ] automatic edges to file resource [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+
+## Virt (libvirt) resource
+- [ ] base resource [bug](https://github.com/purpleidea/mgmt/issues/25)
+
+## Net (systemd-networkd) resource
+- [ ] base resource
+
+## Nspawn (systemd-nspawn) resource
+- [ ] base resource [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+
+## Mount (systemd-mount) resource
+- [ ] base resource [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+
+## Cron (systemd-timer) resource
+- [ ] base resource [:heart:](https://github.com/purpleidea/mgmt/labels/mgmtlove)
+
+## Http resource
+- [ ] base resource
+
+## Etcd improvements
+- [ ] fix embedded etcd master race
+
+## Torrent/dht file transfer
+- [ ] base plumbing
+
+## Language improvements
+- [ ] language design
+- [ ] lexer/parser
+- [ ] automatic language formatter, ala `gofmt`
+- [ ] gedit/gnome-builder/gtksourceview syntax highlighting
+- [ ] vim syntax highlighting
+- [ ] emacs syntax highlighting
+
+## Other
+- [ ] better error/retry handling
+- [ ] deb package target in Makefile
+- [ ] reproducible builds
+- [ ] add your suggestions!

art/.gitignore

@@ -0,0 +1,2 @@
+*.png
+misc/

art/mgmt_logo_default_symbol.svg

@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 120 107.1" style="enable-background:new 0 0 120 107.1;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<line class="st10" x1="29.2" y1="24.1" x2="52.1" y2="42.8"/>
+				<g>
+					<polygon class="st9" points="27.7,27.8 24.9,20.5 32.6,21.8 					"/>
+				</g>
+			</g>
+		</g>
+		<circle class="st5" cx="16.1" cy="12.2" r="12.1"/>
+		<g>
+			<g>
+				<line class="st10" x1="52.1" y1="42.1" x2="74.1" y2="80"/>
+				<g>
+					<polygon class="st9" points="70.1,80.9 76.9,84.8 76.8,77.1 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st10" x1="69.4" y1="46.7" x2="95.8" y2="52.4"/>
+				<g>
+					<polygon class="st9" points="69.7,50.7 63.9,45.6 71.3,43.2 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st10" x1="52.1" y1="42.8" x2="71.9" y2="30.1"/>
+				<g>
+					<polygon class="st9" points="73.1,34 76.6,27.1 68.9,27.5 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st10" x1="16.8" y1="49.6" x2="34.8" y2="46.5"/>
+				<g>
+					<polygon class="st9" points="34.3,50.5 40.3,45.6 33,42.9 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st10" x1="92.3" y1="79.5" x2="107.8" y2="54.2"/>
+				<g>
+					<polygon class="st9" points="96.1,80.6 89.3,84.3 89.5,76.5 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st10" x1="97.3" y1="36.5" x2="107.8" y2="54.2"/>
+				<g>
+					<polygon class="st9" points="94.6,39.4 94.5,31.7 101.2,35.5 					"/>
+				</g>
+			</g>
+		</g>
+		<circle class="st3" cx="52.1" cy="42.8" r="12.1"/>
+		<circle class="st4" cx="12.2" cy="50.8" r="12.1"/>
+		<circle class="st7" cx="87.5" cy="21.7" r="12.1"/>
+		<circle class="st8" cx="83.5" cy="95" r="12.1"/>
+		<circle class="st6" cx="107.8" cy="54.2" r="12.1"/>
+	</g>
+</g>
+</svg>

art/mgmt_logo_default_tall.svg

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 168.3 131.6" style="enable-background:new 0 0 168.3 131.6;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<path class="st3" d="M4.7,105l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9V124h-5v-12.1c0-1.1-0.2-1.9-0.5-2.4c-0.3-0.5-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6V124H9v-12.1
+					c0-1.1-0.1-1.9-0.4-2.4c-0.3-0.5-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4V124H0v-19H4.7z"/>
+				<path class="st3" d="M26.4,113.9c0-3.1,0.6-5.4,1.7-7s2.7-2.3,4.7-2.3c1.7,0,3.1,0.7,4,2L37,105h4.5v19c0,2.4-0.7,4.3-2,5.6
+					c-1.4,1.3-3.3,1.9-5.9,1.9c-1,0-2.1-0.2-3.3-0.6s-2-0.9-2.6-1.6l1.7-3.4c0.5,0.5,1.1,0.9,1.8,1.2c0.7,0.3,1.5,0.5,2.1,0.5
+					c1.1,0,1.9-0.3,2.4-0.8s0.7-1.4,0.7-2.6v-1.6c-0.9,1.2-2.2,1.9-3.7,1.9c-2,0-3.6-0.8-4.7-2.4s-1.7-3.8-1.7-6.7V113.9z
+					 M31.4,115.2c0,1.8,0.2,3,0.7,3.8s1.2,1.2,2.2,1.2c1,0,1.8-0.4,2.3-1.1V110c-0.5-0.8-1.3-1.2-2.2-1.2c-1,0-1.7,0.4-2.2,1.2
+					s-0.7,2.1-0.7,3.9V115.2z"/>
+				<path class="st3" d="M50.1,105l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9V124h-5v-12.1c0-1.1-0.2-1.9-0.5-2.4s-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6V124h-5v-12.1
+					c0-1.1-0.1-1.9-0.4-2.4s-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4V124h-5v-19H50.1z"/>
+				<path class="st3" d="M78.2,100.3v4.7h2.5v3.7h-2.5v9.5c0,0.8,0.1,1.3,0.3,1.5c0.2,0.3,0.6,0.4,1.2,0.4c0.5,0,0.9,0,1.2-0.1
+					l0,3.9c-0.8,0.3-1.8,0.5-2.7,0.5c-3.2,0-4.8-1.8-4.9-5.5v-10.1h-2.2V105h2.2v-4.7H78.2z"/>
+				<path class="st4" d="M90.6,122.6c1.4,0,2.4-0.4,3.1-1.1c0.7-0.8,1.1-1.9,1.2-3.3h1.9c-0.1,1.9-0.7,3.5-1.9,4.6
+					c-1.1,1.1-2.6,1.7-4.3,1.7c-2.3,0-4-0.7-5.1-2.2s-1.7-3.6-1.8-6.4v-2.3c0-2.9,0.6-5.1,1.7-6.6s2.9-2.2,5.1-2.2
+					c1.9,0,3.4,0.6,4.5,1.8s1.7,2.9,1.7,5H95c-0.1-1.6-0.5-2.8-1.2-3.6s-1.8-1.3-3.1-1.3c-1.7,0-2.9,0.6-3.7,1.7s-1.2,2.9-1.2,5.2
+					v2.2c0,2.4,0.4,4.2,1.2,5.3S89,122.6,90.6,122.6z"/>
+				<path class="st4" d="M100.5,113.6c0-2.7,0.6-4.9,1.9-6.5s2.9-2.4,5.1-2.4c2.2,0,3.9,0.8,5.1,2.4s1.9,3.7,1.9,6.5v2
+					c0,2.8-0.6,5-1.9,6.5s-2.9,2.3-5.1,2.3c-2.1,0-3.8-0.8-5-2.3s-1.9-3.6-1.9-6.3V113.6z M102.5,115.5c0,2.2,0.4,3.9,1.3,5.2
+					c0.9,1.3,2.1,1.9,3.7,1.9c1.6,0,2.8-0.6,3.7-1.8s1.3-2.9,1.3-5.2v-2c0-2.2-0.4-3.9-1.3-5.2c-0.9-1.3-2.1-1.9-3.7-1.9
+					c-1.5,0-2.7,0.6-3.6,1.8s-1.3,2.9-1.4,5.1V115.5z"/>
+				<path class="st4" d="M121.1,105l0.1,3c0.6-1,1.3-1.9,2.2-2.5s1.9-0.9,3-0.9c3.3,0,5,2.2,5.1,6.6V124h-1.9v-12.5
+					c0-1.7-0.3-3-0.9-3.8c-0.6-0.8-1.5-1.2-2.8-1.2c-1,0-1.9,0.4-2.8,1.2s-1.4,1.8-1.9,3.2V124h-2v-19H121.1z"/>
+				<path class="st4" d="M138.2,124v-17.3h-2.6V105h2.6v-2.5c0-1.9,0.5-3.3,1.3-4.3s2-1.5,3.5-1.5c0.7,0,1.3,0.1,1.9,0.3l-0.1,1.8
+					c-0.5-0.1-1-0.2-1.6-0.2c-0.9,0-1.7,0.4-2.2,1.1s-0.8,1.7-0.8,3v2.3h3.7v1.8h-3.7V124H138.2z"/>
+				<path class="st4" d="M148,99.5c0-0.4,0.1-0.7,0.3-1s0.5-0.4,0.9-0.4s0.7,0.1,1,0.4s0.3,0.6,0.3,1s-0.1,0.7-0.3,1s-0.5,0.4-1,0.4
+					s-0.7-0.1-0.9-0.4S148,99.9,148,99.5z M150.2,124h-2v-19h2V124z"/>
+				<path class="st4" d="M155.3,113.6c0-3,0.5-5.2,1.5-6.7s2.6-2.2,4.6-2.2c2.2,0,3.8,1,4.9,3l0.1-2.7h1.8v19.6c0,2.3-0.6,4-1.6,5.2
+					c-1.1,1.2-2.7,1.8-4.7,1.8c-1,0-2.1-0.3-3.2-0.8s-1.9-1.1-2.4-1.9l0.9-1.4c1.3,1.5,2.8,2.2,4.5,2.2c1.6,0,2.7-0.4,3.5-1.3
+					c0.7-0.8,1.1-2.1,1.1-3.8v-3c-1.1,1.8-2.7,2.7-4.9,2.7c-2,0-3.5-0.7-4.5-2.2s-1.6-3.6-1.6-6.5V113.6z M157.2,115.4
+					c0,2.4,0.4,4.2,1.1,5.4s1.9,1.7,3.5,1.7c2.1,0,3.6-1,4.5-3v-9.7c-0.9-2.2-2.4-3.3-4.4-3.3c-1.6,0-2.8,0.6-3.5,1.7
+					s-1.1,2.9-1.1,5.3V115.4z"/>
+			</g>
+		</g>
+		<g>
+			<g>
+				<g>
+					<line class="st11" x1="58.9" y1="20.1" x2="77.9" y2="35.6"/>
+					<g>
+						<polygon class="st9" points="57.6,23.2 55.3,17.1 61.7,18.2 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st5" cx="48" cy="10.1" r="10.1"/>
+			<g>
+				<g>
+					<line class="st11" x1="77.9" y1="35.1" x2="96.2" y2="66.7"/>
+					<g>
+						<polygon class="st9" points="93,67.5 98.6,70.7 98.6,64.2 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st11" x1="92.3" y1="38.9" x2="114.4" y2="43.6"/>
+					<g>
+						<polygon class="st9" points="92.6,42.3 87.8,38 93.9,36 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st11" x1="77.9" y1="35.6" x2="94.5" y2="25.1"/>
+					<g>
+						<polygon class="st9" points="95.4,28.3 98.4,22.6 91.9,22.9 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st11" x1="48.5" y1="41.3" x2="63.5" y2="38.7"/>
+					<g>
+						<polygon class="st9" points="63.1,42.1 68.1,38 62,35.7 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st11" x1="111.4" y1="66.3" x2="124.4" y2="45.2"/>
+					<g>
+						<polygon class="st9" points="114.6,67.2 109,70.2 109.1,63.8 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st11" x1="115.6" y1="30.4" x2="124.4" y2="45.2"/>
+					<g>
+						<polygon class="st9" points="113.3,32.8 113.3,26.4 118.9,29.5 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st3" cx="77.9" cy="35.6" r="10.1"/>
+			<circle class="st4" cx="44.6" cy="42.4" r="10.1"/>
+			<circle class="st7" cx="107.4" cy="18.1" r="10.1"/>
+			<circle class="st8" cx="104.1" cy="79.1" r="10.1"/>
+			<circle class="st6" cx="124.4" cy="45.2" r="10.1"/>
+		</g>
+	</g>
+</g>
+</svg>

art/mgmt_logo_default_wide.svg

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 260.4 71.4" style="enable-background:new 0 0 260.4 71.4;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<path class="st3" d="M96.7,25.7l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9v12.5h-5V32.6c0-1.1-0.2-1.9-0.5-2.4s-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6v12.9h-5V32.6
+					c0-1.1-0.1-1.9-0.4-2.4s-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4v13.8h-5v-19H96.7z"/>
+				<path class="st3" d="M118.5,34.6c0-3.1,0.6-5.4,1.7-7s2.7-2.3,4.7-2.3c1.7,0,3.1,0.7,4,2l0.2-1.7h4.5v19c0,2.4-0.7,4.3-2,5.6
+					c-1.4,1.3-3.3,1.9-5.9,1.9c-1,0-2.1-0.2-3.3-0.6s-2-0.9-2.6-1.6l1.7-3.4c0.5,0.5,1.1,0.9,1.8,1.2c0.7,0.3,1.5,0.5,2.1,0.5
+					c1.1,0,1.9-0.3,2.4-0.8s0.7-1.4,0.7-2.6v-1.6c-0.9,1.2-2.2,1.9-3.7,1.9c-2,0-3.6-0.8-4.7-2.4s-1.7-3.8-1.7-6.7V34.6z
+					 M123.5,35.9c0,1.8,0.2,3,0.7,3.8s1.2,1.2,2.2,1.2c1,0,1.8-0.4,2.3-1.1v-9.1c-0.5-0.8-1.3-1.2-2.2-1.2c-1,0-1.7,0.4-2.2,1.2
+					s-0.7,2.1-0.7,3.9V35.9z"/>
+				<path class="st3" d="M142.2,25.7l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9v12.5h-5V32.6c0-1.1-0.2-1.9-0.5-2.4c-0.3-0.5-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6v12.9h-5V32.6
+					c0-1.1-0.1-1.9-0.4-2.4c-0.3-0.5-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4v13.8h-5v-19H142.2z"/>
+				<path class="st3" d="M170.3,21v4.7h2.5v3.7h-2.5v9.5c0,0.8,0.1,1.3,0.3,1.5c0.2,0.3,0.6,0.4,1.2,0.4c0.5,0,0.9,0,1.2-0.1l0,3.9
+					c-0.8,0.3-1.8,0.5-2.7,0.5c-3.2,0-4.8-1.8-4.9-5.5V29.4h-2.2v-3.7h2.2V21H170.3z"/>
+				<path class="st4" d="M182.7,43.2c1.4,0,2.4-0.4,3.1-1.1s1.1-1.8,1.2-3.3h1.9c-0.1,1.9-0.7,3.5-1.9,4.6s-2.6,1.7-4.3,1.7
+					c-2.3,0-4-0.7-5.1-2.2s-1.7-3.6-1.8-6.4v-2.3c0-2.9,0.6-5.1,1.7-6.6s2.9-2.2,5.1-2.2c1.9,0,3.4,0.6,4.5,1.8s1.7,2.9,1.7,5H187
+					c-0.1-1.6-0.5-2.8-1.2-3.6s-1.8-1.3-3.1-1.3c-1.7,0-2.9,0.6-3.7,1.7c-0.8,1.1-1.2,2.9-1.2,5.2v2.2c0,2.4,0.4,4.2,1.2,5.3
+					S181,43.2,182.7,43.2z"/>
+				<path class="st4" d="M192.6,34.2c0-2.7,0.6-4.9,1.9-6.5s2.9-2.4,5.1-2.4c2.2,0,3.9,0.8,5.1,2.4c1.2,1.6,1.9,3.7,1.9,6.5v2
+					c0,2.8-0.6,5-1.9,6.5s-2.9,2.3-5.1,2.3s-3.8-0.8-5-2.3s-1.9-3.6-1.9-6.3V34.2z M194.6,36.2c0,2.2,0.4,3.9,1.3,5.2
+					c0.9,1.3,2.1,1.9,3.7,1.9c1.6,0,2.8-0.6,3.7-1.8c0.8-1.2,1.3-2.9,1.3-5.2v-2c0-2.2-0.4-3.9-1.3-5.2c-0.9-1.3-2.1-1.9-3.7-1.9
+					c-1.5,0-2.7,0.6-3.6,1.8c-0.9,1.2-1.3,2.9-1.4,5.1V36.2z"/>
+				<path class="st4" d="M213.2,25.7l0.1,3c0.6-1,1.3-1.9,2.2-2.5s1.9-0.9,3-0.9c3.3,0,5,2.2,5.1,6.6v12.7h-1.9V32.2
+					c0-1.7-0.3-3-0.9-3.8c-0.6-0.8-1.5-1.2-2.8-1.2c-1,0-1.9,0.4-2.8,1.2s-1.4,1.8-1.9,3.2v13.2h-2v-19H213.2z"/>
+				<path class="st4" d="M230.3,44.7V27.4h-2.6v-1.8h2.6v-2.5c0-1.9,0.5-3.3,1.3-4.3s2-1.5,3.5-1.5c0.7,0,1.3,0.1,1.9,0.3l-0.1,1.8
+					c-0.5-0.1-1-0.2-1.6-0.2c-0.9,0-1.7,0.4-2.2,1.1s-0.8,1.7-0.8,3v2.3h3.7v1.8h-3.7v17.3H230.3z"/>
+				<path class="st4" d="M240.1,20.2c0-0.4,0.1-0.7,0.3-1s0.5-0.4,0.9-0.4s0.7,0.1,1,0.4s0.3,0.6,0.3,1s-0.1,0.7-0.3,1
+					s-0.5,0.4-1,0.4s-0.7-0.1-0.9-0.4S240.1,20.6,240.1,20.2z M242.3,44.7h-2v-19h2V44.7z"/>
+				<path class="st4" d="M247.4,34.3c0-3,0.5-5.2,1.5-6.7s2.6-2.2,4.6-2.2c2.2,0,3.8,1,4.9,3l0.1-2.7h1.8v19.6c0,2.3-0.6,4-1.6,5.2
+					s-2.7,1.8-4.7,1.8c-1,0-2.1-0.3-3.2-0.8s-1.9-1.1-2.4-1.9l0.9-1.4c1.3,1.5,2.8,2.2,4.5,2.2c1.6,0,2.7-0.4,3.5-1.3
+					c0.7-0.8,1.1-2.1,1.1-3.8v-3c-1.1,1.8-2.7,2.7-4.9,2.7c-2,0-3.5-0.7-4.5-2.2s-1.6-3.6-1.6-6.5V34.3z M249.3,36.1
+					c0,2.4,0.4,4.2,1.1,5.4s1.9,1.7,3.5,1.7c2.1,0,3.6-1,4.5-3v-9.7c-0.9-2.2-2.4-3.3-4.4-3.3c-1.6,0-2.8,0.6-3.5,1.7
+					s-1.1,2.9-1.1,5.3V36.1z"/>
+			</g>
+		</g>
+		<g>
+			<g>
+				<g>
+					<line class="st12" x1="19.5" y1="16" x2="34.7" y2="28.5"/>
+					<g>
+						<polygon class="st9" points="18.4,18.5 16.6,13.7 21.7,14.5 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st5" cx="10.8" cy="8.1" r="8.1"/>
+			<g>
+				<g>
+					<line class="st12" x1="34.7" y1="28" x2="49.4" y2="53.3"/>
+					<g>
+						<polygon class="st9" points="46.8,54 51.2,56.5 51.2,51.4 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st12" x1="46.2" y1="31.1" x2="63.9" y2="34.9"/>
+					<g>
+						<polygon class="st9" points="46.4,33.8 42.6,30.4 47.5,28.8 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st12" x1="34.7" y1="28.5" x2="47.9" y2="20.1"/>
+					<g>
+						<polygon class="st9" points="48.7,22.7 51.1,18.1 45.9,18.3 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st12" x1="11.2" y1="33.1" x2="23.2" y2="31"/>
+					<g>
+						<polygon class="st9" points="22.9,33.7 26.8,30.4 22,28.6 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st12" x1="61.5" y1="53" x2="71.9" y2="36.1"/>
+					<g>
+						<polygon class="st9" points="64.1,53.7 59.5,56.2 59.7,51 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st12" x1="64.2" y1="24.2" x2="70.7" y2="33.9"/>
+					<g>
+						<polygon class="st9" points="62.5,26.3 62.2,21.1 66.8,23.4 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st3" cx="34.7" cy="28.5" r="8.1"/>
+			<circle class="st4" cx="8.1" cy="33.9" r="8.1"/>
+			<circle class="st7" cx="58.3" cy="14.5" r="8.1"/>
+			<circle class="st8" cx="55.7" cy="63.3" r="8.1"/>
+			<circle class="st6" cx="71.9" cy="36.1" r="8.1"/>
+		</g>
+	</g>
+</g>
+</svg>

art/mgmt_logo_reversed_symbol.svg

@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 120 107.1" style="enable-background:new 0 0 120 107.1;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<line class="st13" x1="29.2" y1="24.1" x2="52.1" y2="42.8"/>
+				<g>
+					<polygon class="st14" points="27.7,27.8 24.9,20.5 32.6,21.8 					"/>
+				</g>
+			</g>
+		</g>
+		<circle class="st3" cx="16.1" cy="12.2" r="12.1"/>
+		<g>
+			<g>
+				<line class="st13" x1="52.1" y1="42.1" x2="74.1" y2="80"/>
+				<g>
+					<polygon class="st14" points="70.1,80.9 76.9,84.8 76.8,77.1 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st13" x1="69.4" y1="46.7" x2="95.8" y2="52.4"/>
+				<g>
+					<polygon class="st14" points="69.7,50.7 63.9,45.6 71.3,43.2 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st13" x1="52.1" y1="42.8" x2="71.9" y2="30.1"/>
+				<g>
+					<polygon class="st14" points="73.1,34 76.6,27.1 68.9,27.5 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st13" x1="16.8" y1="49.6" x2="34.8" y2="46.5"/>
+				<g>
+					<polygon class="st14" points="34.3,50.5 40.3,45.6 33,42.9 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st13" x1="92.3" y1="79.5" x2="107.8" y2="54.2"/>
+				<g>
+					<polygon class="st14" points="96.1,80.6 89.3,84.3 89.5,76.5 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st13" x1="97.2" y1="36.3" x2="107.8" y2="54.2"/>
+				<g>
+					<polygon class="st14" points="94.4,39.3 94.3,31.5 101.1,35.3 					"/>
+				</g>
+			</g>
+		</g>
+		<circle class="st5" cx="52.1" cy="42.8" r="12.1"/>
+		<circle class="st4" cx="12.2" cy="50.8" r="12.1"/>
+		<circle class="st7" cx="87.5" cy="21.7" r="12.1"/>
+		<circle class="st8" cx="83.5" cy="95" r="12.1"/>
+		<circle class="st6" cx="107.8" cy="54.2" r="12.1"/>
+	</g>
+</g>
+</svg>

art/mgmt_logo_reversed_tall.svg

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 168.3 133" style="enable-background:new 0 0 168.3 133;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<path class="st0" d="M4.7,106.4l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9v12.5h-5v-12.1c0-1.1-0.2-1.9-0.5-2.4c-0.3-0.5-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6v12.9H9v-12.1
+					c0-1.1-0.1-1.9-0.4-2.4c-0.3-0.5-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4v13.8H0v-19H4.7z"/>
+				<path class="st0" d="M26.4,115.3c0-3.1,0.6-5.4,1.7-7s2.7-2.3,4.7-2.3c1.7,0,3.1,0.7,4,2l0.2-1.7h4.5v19c0,2.4-0.7,4.3-2,5.6
+					c-1.4,1.3-3.3,1.9-5.9,1.9c-1,0-2.1-0.2-3.3-0.6s-2-0.9-2.6-1.6l1.7-3.4c0.5,0.5,1.1,0.9,1.8,1.2c0.7,0.3,1.5,0.5,2.1,0.5
+					c1.1,0,1.9-0.3,2.4-0.8c0.5-0.5,0.7-1.4,0.7-2.6v-1.6c-0.9,1.2-2.2,1.9-3.7,1.9c-2,0-3.6-0.8-4.7-2.4s-1.7-3.8-1.7-6.7V115.3z
+					 M31.4,116.6c0,1.8,0.2,3,0.7,3.8s1.2,1.2,2.2,1.2c1,0,1.8-0.4,2.3-1.1v-9.1c-0.5-0.8-1.3-1.2-2.2-1.2c-1,0-1.7,0.4-2.2,1.2
+					s-0.7,2.1-0.7,3.9V116.6z"/>
+				<path class="st0" d="M50.1,106.4l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9v12.5h-5v-12.1c0-1.1-0.2-1.9-0.5-2.4s-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6v12.9h-5v-12.1
+					c0-1.1-0.1-1.9-0.4-2.4s-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4v13.8h-5v-19H50.1z"/>
+				<path class="st0" d="M78.2,101.7v4.7h2.5v3.7h-2.5v9.5c0,0.8,0.1,1.3,0.3,1.5c0.2,0.3,0.6,0.4,1.2,0.4c0.5,0,0.9,0,1.2-0.1
+					l0,3.9c-0.8,0.3-1.8,0.5-2.7,0.5c-3.2,0-4.8-1.8-4.9-5.5v-10.1h-2.2v-3.7h2.2v-4.7H78.2z"/>
+				<path class="st4" d="M90.6,124c1.4,0,2.4-0.4,3.1-1.1c0.7-0.8,1.1-1.9,1.2-3.3h1.9c-0.1,1.9-0.7,3.5-1.9,4.6
+					c-1.1,1.1-2.6,1.7-4.3,1.7c-2.3,0-4-0.7-5.1-2.2s-1.7-3.6-1.8-6.4v-2.3c0-2.9,0.6-5.1,1.7-6.6s2.9-2.2,5.1-2.2
+					c1.9,0,3.4,0.6,4.5,1.8s1.7,2.9,1.7,5H95c-0.1-1.6-0.5-2.8-1.2-3.6s-1.8-1.3-3.1-1.3c-1.7,0-2.9,0.6-3.7,1.7s-1.2,2.9-1.2,5.2
+					v2.2c0,2.4,0.4,4.2,1.2,5.3S89,124,90.6,124z"/>
+				<path class="st4" d="M100.5,115c0-2.7,0.6-4.9,1.9-6.5s2.9-2.4,5.1-2.4c2.2,0,3.9,0.8,5.1,2.4s1.9,3.7,1.9,6.5v2
+					c0,2.8-0.6,5-1.9,6.5s-2.9,2.3-5.1,2.3c-2.1,0-3.8-0.8-5-2.3s-1.9-3.6-1.9-6.3V115z M102.5,116.9c0,2.2,0.4,3.9,1.3,5.2
+					c0.9,1.3,2.1,1.9,3.7,1.9c1.6,0,2.8-0.6,3.7-1.8s1.3-2.9,1.3-5.2v-2c0-2.2-0.4-3.9-1.3-5.2c-0.9-1.3-2.1-1.9-3.7-1.9
+					c-1.5,0-2.7,0.6-3.6,1.8s-1.3,2.9-1.4,5.1V116.9z"/>
+				<path class="st4" d="M121.1,106.4l0.1,3c0.6-1,1.3-1.9,2.2-2.5s1.9-0.9,3-0.9c3.3,0,5,2.2,5.1,6.6v12.7h-1.9v-12.5
+					c0-1.7-0.3-3-0.9-3.8c-0.6-0.8-1.5-1.2-2.8-1.2c-1,0-1.9,0.4-2.8,1.2s-1.4,1.8-1.9,3.2v13.2h-2v-19H121.1z"/>
+				<path class="st4" d="M138.2,125.4v-17.3h-2.6v-1.8h2.6v-2.5c0-1.9,0.5-3.3,1.3-4.3s2-1.5,3.5-1.5c0.7,0,1.3,0.1,1.9,0.3
+					l-0.1,1.8c-0.5-0.1-1-0.2-1.6-0.2c-0.9,0-1.7,0.4-2.2,1.1s-0.8,1.7-0.8,3v2.3h3.7v1.8h-3.7v17.3H138.2z"/>
+				<path class="st4" d="M148,100.9c0-0.4,0.1-0.7,0.3-1s0.5-0.4,0.9-0.4s0.7,0.1,1,0.4s0.3,0.6,0.3,1s-0.1,0.7-0.3,1
+					s-0.5,0.4-1,0.4s-0.7-0.1-0.9-0.4S148,101.3,148,100.9z M150.2,125.4h-2v-19h2V125.4z"/>
+				<path class="st4" d="M155.3,115c0-3,0.5-5.2,1.5-6.7s2.6-2.2,4.6-2.2c2.2,0,3.8,1,4.9,3l0.1-2.7h1.8V126c0,2.3-0.6,4-1.6,5.2
+					c-1.1,1.2-2.7,1.8-4.7,1.8c-1,0-2.1-0.3-3.2-0.8s-1.9-1.1-2.4-1.9l0.9-1.4c1.3,1.5,2.8,2.2,4.5,2.2c1.6,0,2.7-0.4,3.5-1.3
+					c0.7-0.8,1.1-2.1,1.1-3.8v-3c-1.1,1.8-2.7,2.7-4.9,2.7c-2,0-3.5-0.7-4.5-2.2s-1.6-3.6-1.6-6.5V115z M157.2,116.8
+					c0,2.4,0.4,4.2,1.1,5.4s1.9,1.7,3.5,1.7c2.1,0,3.6-1,4.5-3v-9.7c-0.9-2.2-2.4-3.3-4.4-3.3c-1.6,0-2.8,0.6-3.5,1.7
+					s-1.1,2.9-1.1,5.3V116.8z"/>
+			</g>
+		</g>
+		<g>
+			<g>
+				<g>
+					<line class="st16" x1="58.9" y1="20.1" x2="77.9" y2="35.6"/>
+					<g>
+						<polygon class="st14" points="57.6,23.2 55.3,17.1 61.7,18.2 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st3" cx="48" cy="10.1" r="10.1"/>
+			<g>
+				<g>
+					<line class="st16" x1="77.9" y1="35.1" x2="96.2" y2="66.7"/>
+					<g>
+						<polygon class="st14" points="93,67.5 98.6,70.7 98.6,64.2 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st16" x1="92.3" y1="38.9" x2="114.4" y2="43.6"/>
+					<g>
+						<polygon class="st14" points="92.6,42.3 87.8,38 93.9,36 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st16" x1="77.9" y1="35.6" x2="94.5" y2="25.1"/>
+					<g>
+						<polygon class="st14" points="95.4,28.3 98.4,22.6 91.9,22.9 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st16" x1="48.5" y1="41.3" x2="63.5" y2="38.7"/>
+					<g>
+						<polygon class="st14" points="63.1,42.1 68.1,38 62,35.7 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st16" x1="111.4" y1="66.3" x2="124.4" y2="45.2"/>
+					<g>
+						<polygon class="st14" points="114.6,67.2 109,70.2 109.1,63.8 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st16" x1="115.5" y1="30.5" x2="124.4" y2="45.2"/>
+					<g>
+						<polygon class="st14" points="113.2,32.9 113.1,26.5 118.8,29.6 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st5" cx="77.9" cy="35.6" r="10.1"/>
+			<circle class="st4" cx="44.6" cy="42.4" r="10.1"/>
+			<circle class="st7" cx="107.4" cy="18.1" r="10.1"/>
+			<circle class="st8" cx="104.1" cy="79.1" r="10.1"/>
+			<circle class="st6" cx="124.4" cy="45.2" r="10.1"/>
+		</g>
+	</g>
+</g>
+</svg>

art/mgmt_logo_reversed_wide.svg

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 260.4 71.4" style="enable-background:new 0 0 260.4 71.4;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<path class="st0" d="M96.7,27.6l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9v12.5h-5V34.4c0-1.1-0.2-1.9-0.5-2.4c-0.3-0.5-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6v12.9h-5V34.5
+					c0-1.1-0.1-1.9-0.4-2.4c-0.3-0.5-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4v13.8h-5v-19H96.7z"/>
+				<path class="st0" d="M118.5,36.5c0-3.1,0.6-5.4,1.7-7s2.7-2.3,4.7-2.3c1.7,0,3.1,0.7,4,2l0.2-1.7h4.5v19c0,2.4-0.7,4.3-2,5.6
+					c-1.4,1.3-3.3,1.9-5.9,1.9c-1,0-2.1-0.2-3.3-0.6s-2-0.9-2.6-1.6l1.7-3.4c0.5,0.5,1.1,0.9,1.8,1.2c0.7,0.3,1.5,0.5,2.1,0.5
+					c1.1,0,1.9-0.3,2.4-0.8s0.7-1.4,0.7-2.6v-1.6c-0.9,1.2-2.2,1.9-3.7,1.9c-2,0-3.6-0.8-4.7-2.4s-1.7-3.8-1.7-6.7V36.5z
+					 M123.5,37.7c0,1.8,0.2,3,0.7,3.8s1.2,1.2,2.2,1.2c1,0,1.8-0.4,2.3-1.1v-9.1c-0.5-0.8-1.3-1.2-2.2-1.2c-1,0-1.7,0.4-2.2,1.2
+					c-0.5,0.8-0.7,2.1-0.7,3.9V37.7z"/>
+				<path class="st0" d="M142.2,27.6l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9v12.5h-5V34.4c0-1.1-0.2-1.9-0.5-2.4c-0.3-0.5-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6v12.9h-5V34.5
+					c0-1.1-0.1-1.9-0.4-2.4c-0.3-0.5-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4v13.8h-5v-19H142.2z"/>
+				<path class="st0" d="M170.3,22.9v4.7h2.5v3.7h-2.5v9.5c0,0.8,0.1,1.3,0.3,1.5c0.2,0.3,0.6,0.4,1.2,0.4c0.5,0,0.9,0,1.2-0.1
+					l0,3.9c-0.8,0.3-1.8,0.5-2.7,0.5c-3.2,0-4.8-1.8-4.9-5.5V31.3h-2.2v-3.7h2.2v-4.7H170.3z"/>
+				<path class="st4" d="M182.7,45.1c1.4,0,2.4-0.4,3.1-1.1c0.7-0.8,1.1-1.9,1.2-3.3h1.9c-0.1,1.9-0.7,3.5-1.9,4.6s-2.6,1.7-4.3,1.7
+					c-2.3,0-4-0.7-5.1-2.2s-1.7-3.6-1.8-6.4V36c0-2.9,0.6-5.1,1.7-6.6s2.9-2.2,5.1-2.2c1.9,0,3.4,0.6,4.5,1.8s1.7,2.9,1.7,5H187
+					c-0.1-1.6-0.5-2.8-1.2-3.6s-1.8-1.3-3.1-1.3c-1.7,0-2.9,0.6-3.7,1.7s-1.2,2.9-1.2,5.2v2.2c0,2.4,0.4,4.2,1.2,5.3
+					S181,45.1,182.7,45.1z"/>
+				<path class="st4" d="M192.6,36.1c0-2.7,0.6-4.9,1.9-6.5s2.9-2.4,5.1-2.4c2.2,0,3.9,0.8,5.1,2.4c1.2,1.6,1.9,3.7,1.9,6.5v2
+					c0,2.8-0.6,5-1.9,6.5s-2.9,2.3-5.1,2.3s-3.8-0.8-5-2.3s-1.9-3.6-1.9-6.3V36.1z M194.6,38.1c0,2.2,0.4,3.9,1.3,5.2
+					c0.9,1.3,2.1,1.9,3.7,1.9c1.6,0,2.8-0.6,3.7-1.8c0.8-1.2,1.3-2.9,1.3-5.2v-2c0-2.2-0.4-3.9-1.3-5.2c-0.9-1.3-2.1-1.9-3.7-1.9
+					c-1.5,0-2.7,0.6-3.6,1.8c-0.9,1.2-1.3,2.9-1.4,5.1V38.1z"/>
+				<path class="st4" d="M213.2,27.6l0.1,3c0.6-1,1.3-1.9,2.2-2.5s1.9-0.9,3-0.9c3.3,0,5,2.2,5.1,6.6v12.7h-1.9V34.1
+					c0-1.7-0.3-3-0.9-3.8c-0.6-0.8-1.5-1.2-2.8-1.2c-1,0-1.9,0.4-2.8,1.2s-1.4,1.8-1.9,3.2v13.2h-2v-19H213.2z"/>
+				<path class="st4" d="M230.3,46.6V29.3h-2.6v-1.8h2.6v-2.5c0-1.9,0.5-3.3,1.3-4.3s2-1.5,3.5-1.5c0.7,0,1.3,0.1,1.9,0.3l-0.1,1.8
+					c-0.5-0.1-1-0.2-1.6-0.2c-0.9,0-1.7,0.4-2.2,1.1s-0.8,1.7-0.8,3v2.3h3.7v1.8h-3.7v17.3H230.3z"/>
+				<path class="st4" d="M240.1,22.1c0-0.4,0.1-0.7,0.3-1s0.5-0.4,0.9-0.4s0.7,0.1,1,0.4s0.3,0.6,0.3,1s-0.1,0.7-0.3,1
+					s-0.5,0.4-1,0.4s-0.7-0.1-0.9-0.4S240.1,22.5,240.1,22.1z M242.3,46.6h-2v-19h2V46.6z"/>
+				<path class="st4" d="M247.4,36.2c0-3,0.5-5.2,1.5-6.7s2.6-2.2,4.6-2.2c2.2,0,3.8,1,4.9,3l0.1-2.7h1.8v19.6c0,2.3-0.6,4-1.6,5.2
+					s-2.7,1.8-4.7,1.8c-1,0-2.1-0.3-3.2-0.8s-1.9-1.1-2.4-1.9l0.9-1.4c1.3,1.5,2.8,2.2,4.5,2.2c1.6,0,2.7-0.4,3.5-1.3
+					c0.7-0.8,1.1-2.1,1.1-3.8v-3c-1.1,1.8-2.7,2.7-4.9,2.7c-2,0-3.5-0.7-4.5-2.2s-1.6-3.6-1.6-6.5V36.2z M249.3,38
+					c0,2.4,0.4,4.2,1.1,5.4s1.9,1.7,3.5,1.7c2.1,0,3.6-1,4.5-3v-9.7c-0.9-2.2-2.4-3.3-4.4-3.3c-1.6,0-2.8,0.6-3.5,1.7
+					s-1.1,2.9-1.1,5.3V38z"/>
+			</g>
+		</g>
+		<g>
+			<g>
+				<g>
+					<line class="st15" x1="19.5" y1="16" x2="34.7" y2="28.5"/>
+					<g>
+						<polygon class="st14" points="18.4,18.5 16.6,13.7 21.7,14.5 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st3" cx="10.8" cy="8.1" r="8.1"/>
+			<g>
+				<g>
+					<line class="st15" x1="34.7" y1="28" x2="49.4" y2="53.3"/>
+					<g>
+						<polygon class="st14" points="46.8,54 51.2,56.5 51.2,51.4 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st15" x1="46.2" y1="31.1" x2="63.9" y2="34.9"/>
+					<g>
+						<polygon class="st14" points="46.4,33.8 42.6,30.4 47.5,28.8 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st15" x1="34.7" y1="28.5" x2="47.9" y2="20.1"/>
+					<g>
+						<polygon class="st14" points="48.7,22.7 51.1,18.1 45.9,18.3 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st15" x1="11.2" y1="33.1" x2="23.2" y2="31"/>
+					<g>
+						<polygon class="st14" points="22.9,33.7 26.8,30.4 22,28.6 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st15" x1="61.5" y1="53" x2="71.9" y2="36.1"/>
+					<g>
+						<polygon class="st14" points="64.1,53.7 59.5,56.2 59.7,51 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st15" x1="64.8" y1="24.4" x2="71.9" y2="36.1"/>
+					<g>
+						<polygon class="st14" points="63,26.4 62.9,21.2 67.4,23.7 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st5" cx="34.7" cy="28.5" r="8.1"/>
+			<circle class="st4" cx="8.1" cy="33.9" r="8.1"/>
+			<circle class="st7" cx="58.3" cy="14.5" r="8.1"/>
+			<circle class="st8" cx="55.7" cy="63.3" r="8.1"/>
+			<circle class="st6" cx="71.9" cy="36.1" r="8.1"/>
+		</g>
+	</g>
+</g>
+</svg>

art/mgmt_logo_white_symbol.svg

@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 120 107.1" style="enable-background:new 0 0 120 107.1;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<line class="st17" x1="29.2" y1="24.1" x2="52.1" y2="42.8"/>
+				<g>
+					<polygon class="st0" points="27.7,27.8 24.9,20.5 32.6,21.8 					"/>
+				</g>
+			</g>
+		</g>
+		<circle class="st0" cx="16.1" cy="12.2" r="12.1"/>
+		<g>
+			<g>
+				<line class="st17" x1="52.1" y1="42.1" x2="74.1" y2="80"/>
+				<g>
+					<polygon class="st0" points="70.1,80.9 76.9,84.8 76.8,77.1 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st17" x1="69.4" y1="46.7" x2="95.8" y2="52.4"/>
+				<g>
+					<polygon class="st0" points="69.7,50.7 63.9,45.6 71.3,43.2 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st17" x1="52.1" y1="42.8" x2="71.9" y2="30.1"/>
+				<g>
+					<polygon class="st0" points="73.1,34 76.6,27.1 68.9,27.5 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st17" x1="16.8" y1="49.6" x2="34.8" y2="46.5"/>
+				<g>
+					<polygon class="st0" points="34.3,50.5 40.3,45.6 33,42.9 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st17" x1="92.3" y1="79.5" x2="107.8" y2="54.2"/>
+				<g>
+					<polygon class="st0" points="96.1,80.6 89.3,84.3 89.5,76.5 					"/>
+				</g>
+			</g>
+		</g>
+		<g>
+			<g>
+				<line class="st17" x1="97.2" y1="36.6" x2="107.8" y2="54.2"/>
+				<g>
+					<polygon class="st0" points="94.4,39.5 94.3,31.8 101.1,35.5 					"/>
+				</g>
+			</g>
+		</g>
+		<circle class="st0" cx="52.1" cy="42.8" r="12.1"/>
+		<circle class="st0" cx="12.2" cy="50.8" r="12.1"/>
+		<circle class="st0" cx="87.5" cy="21.7" r="12.1"/>
+		<circle class="st0" cx="83.5" cy="95" r="12.1"/>
+		<circle class="st0" cx="107.8" cy="54.2" r="12.1"/>
+	</g>
+</g>
+</svg>

art/mgmt_logo_white_tall.svg

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 168.3 131.4" style="enable-background:new 0 0 168.3 131.4;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<path class="st0" d="M4.7,104.8l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9v12.5h-5v-12.1c0-1.1-0.2-1.9-0.5-2.4c-0.3-0.5-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6v12.9H9v-12.1
+					c0-1.1-0.1-1.9-0.4-2.4c-0.3-0.5-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4v13.8H0v-19H4.7z"/>
+				<path class="st0" d="M26.4,113.8c0-3.1,0.6-5.4,1.7-7s2.7-2.3,4.7-2.3c1.7,0,3.1,0.7,4,2l0.2-1.7h4.5v19c0,2.4-0.7,4.3-2,5.6
+					c-1.4,1.3-3.3,1.9-5.9,1.9c-1,0-2.1-0.2-3.3-0.6s-2-0.9-2.6-1.6l1.7-3.4c0.5,0.5,1.1,0.9,1.8,1.2c0.7,0.3,1.5,0.5,2.1,0.5
+					c1.1,0,1.9-0.3,2.4-0.8s0.7-1.4,0.7-2.6v-1.6c-0.9,1.2-2.2,1.9-3.7,1.9c-2,0-3.6-0.8-4.7-2.4s-1.7-3.8-1.7-6.7V113.8z M31.4,115
+					c0,1.8,0.2,3,0.7,3.8s1.2,1.2,2.2,1.2c1,0,1.8-0.4,2.3-1.1v-9.1c-0.5-0.8-1.3-1.2-2.2-1.2c-1,0-1.7,0.4-2.2,1.2
+					s-0.7,2.1-0.7,3.9V115z"/>
+				<path class="st0" d="M50.1,104.8l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9v12.5h-5v-12.1c0-1.1-0.2-1.9-0.5-2.4s-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6v12.9h-5v-12.1
+					c0-1.1-0.1-1.9-0.4-2.4s-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4v13.8h-5v-19H50.1z"/>
+				<path class="st0" d="M78.2,100.2v4.7h2.5v3.7h-2.5v9.5c0,0.8,0.1,1.3,0.3,1.5c0.2,0.3,0.6,0.4,1.2,0.4c0.5,0,0.9,0,1.2-0.1
+					l0,3.9c-0.8,0.3-1.8,0.5-2.7,0.5c-3.2,0-4.8-1.8-4.9-5.5v-10.1h-2.2v-3.7h2.2v-4.7H78.2z"/>
+				<path class="st0" d="M90.6,122.4c1.4,0,2.4-0.4,3.1-1.1c0.7-0.8,1.1-1.8,1.2-3.3h1.9c-0.1,1.9-0.7,3.5-1.9,4.6
+					c-1.1,1.1-2.6,1.7-4.3,1.7c-2.3,0-4-0.7-5.1-2.2s-1.7-3.6-1.8-6.4v-2.3c0-2.9,0.6-5.1,1.7-6.6s2.9-2.2,5.1-2.2
+					c1.9,0,3.4,0.6,4.5,1.8s1.7,2.9,1.7,5H95c-0.1-1.6-0.5-2.8-1.2-3.6s-1.8-1.3-3.1-1.3c-1.7,0-2.9,0.6-3.7,1.7
+					c-0.8,1.1-1.2,2.9-1.2,5.2v2.2c0,2.4,0.4,4.2,1.2,5.3S89,122.4,90.6,122.4z"/>
+				<path class="st0" d="M100.5,113.4c0-2.7,0.6-4.9,1.9-6.5s2.9-2.4,5.1-2.4c2.2,0,3.9,0.8,5.1,2.4s1.9,3.7,1.9,6.5v2
+					c0,2.8-0.6,5-1.9,6.5s-2.9,2.3-5.1,2.3c-2.1,0-3.8-0.8-5-2.3s-1.9-3.6-1.9-6.3V113.4z M102.5,115.3c0,2.2,0.4,3.9,1.3,5.2
+					c0.9,1.3,2.1,1.9,3.7,1.9c1.6,0,2.8-0.6,3.7-1.8c0.8-1.2,1.3-2.9,1.3-5.2v-2c0-2.2-0.4-3.9-1.3-5.2c-0.9-1.3-2.1-1.9-3.7-1.9
+					c-1.5,0-2.7,0.6-3.6,1.8c-0.9,1.2-1.3,2.9-1.4,5.1V115.3z"/>
+				<path class="st0" d="M121.1,104.8l0.1,3c0.6-1,1.3-1.9,2.2-2.5s1.9-0.9,3-0.9c3.3,0,5,2.2,5.1,6.6v12.7h-1.9v-12.5
+					c0-1.7-0.3-3-0.9-3.8c-0.6-0.8-1.5-1.2-2.8-1.2c-1,0-1.9,0.4-2.8,1.2s-1.4,1.8-1.9,3.2v13.2h-2v-19H121.1z"/>
+				<path class="st0" d="M138.2,123.8v-17.3h-2.6v-1.8h2.6v-2.5c0-1.9,0.5-3.3,1.3-4.3s2-1.5,3.5-1.5c0.7,0,1.3,0.1,1.9,0.3
+					l-0.1,1.8c-0.5-0.1-1-0.2-1.6-0.2c-0.9,0-1.7,0.4-2.2,1.1s-0.8,1.7-0.8,3v2.3h3.7v1.8h-3.7v17.3H138.2z"/>
+				<path class="st0" d="M148,99.3c0-0.4,0.1-0.7,0.3-1s0.5-0.4,0.9-0.4s0.7,0.1,1,0.4s0.3,0.6,0.3,1s-0.1,0.7-0.3,1s-0.5,0.4-1,0.4
+					s-0.7-0.1-0.9-0.4S148,99.7,148,99.3z M150.2,123.8h-2v-19h2V123.8z"/>
+				<path class="st0" d="M155.3,113.5c0-3,0.5-5.2,1.5-6.7s2.6-2.2,4.6-2.2c2.2,0,3.8,1,4.9,3l0.1-2.7h1.8v19.6c0,2.3-0.6,4-1.6,5.2
+					c-1.1,1.2-2.7,1.8-4.7,1.8c-1,0-2.1-0.3-3.2-0.8s-1.9-1.1-2.4-1.9l0.9-1.4c1.3,1.5,2.8,2.2,4.5,2.2c1.6,0,2.7-0.4,3.5-1.3
+					c0.7-0.8,1.1-2.1,1.1-3.8v-3c-1.1,1.8-2.7,2.7-4.9,2.7c-2,0-3.5-0.7-4.5-2.2s-1.6-3.6-1.6-6.5V113.5z M157.2,115.2
+					c0,2.4,0.4,4.2,1.1,5.4s1.9,1.7,3.5,1.7c2.1,0,3.6-1,4.5-3v-9.7c-0.9-2.2-2.4-3.3-4.4-3.3c-1.6,0-2.8,0.6-3.5,1.7
+					s-1.1,2.9-1.1,5.3V115.2z"/>
+			</g>
+		</g>
+		<g>
+			<g>
+				<g>
+					<line class="st19" x1="58.9" y1="20.1" x2="77.9" y2="35.6"/>
+					<g>
+						<polygon class="st0" points="57.6,23.2 55.3,17.1 61.7,18.2 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st0" cx="48" cy="10.1" r="10.1"/>
+			<g>
+				<g>
+					<line class="st19" x1="77.9" y1="35.1" x2="96.2" y2="66.7"/>
+					<g>
+						<polygon class="st0" points="93,67.5 98.6,70.7 98.6,64.2 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st19" x1="92.3" y1="38.9" x2="114.4" y2="43.6"/>
+					<g>
+						<polygon class="st0" points="92.6,42.3 87.8,38 93.9,36 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st19" x1="77.9" y1="35.6" x2="94.5" y2="25.1"/>
+					<g>
+						<polygon class="st0" points="95.4,28.3 98.4,22.6 91.9,22.9 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st19" x1="48.5" y1="41.3" x2="63.5" y2="38.7"/>
+					<g>
+						<polygon class="st0" points="63.1,42.1 68.1,38 62,35.7 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st19" x1="111.4" y1="66.3" x2="124.4" y2="45.2"/>
+					<g>
+						<polygon class="st0" points="114.6,67.2 109,70.2 109.1,63.8 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st19" x1="115.4" y1="30.4" x2="124.4" y2="45.2"/>
+					<g>
+						<polygon class="st0" points="113.2,32.8 113,26.4 118.7,29.5 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st0" cx="77.9" cy="35.6" r="10.1"/>
+			<circle class="st0" cx="44.6" cy="42.4" r="10.1"/>
+			<circle class="st0" cx="107.4" cy="18.1" r="10.1"/>
+			<circle class="st0" cx="104.1" cy="79.1" r="10.1"/>
+			<circle class="st0" cx="124.4" cy="45.2" r="10.1"/>
+		</g>
+	</g>
+</g>
+</svg>

art/mgmt_logo_white_wide.svg

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 260.4 71.4" style="enable-background:new 0 0 260.4 71.4;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#E22434;}
+	.st2{display:none;}
+	.st3{fill:#1B3663;}
+	.st4{fill:#00B1D1;}
+	.st5{fill:#BFE6EF;}
+	.st6{fill:#69CBE0;}
+	.st7{fill:#0080BD;}
+	.st8{fill:#005DAB;}
+	.st9{fill:#183660;}
+	.st10{fill:none;stroke:#183660;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st11{fill:none;stroke:#183660;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st12{fill:none;stroke:#183660;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st13{fill:none;stroke:#C0E6EF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st14{fill:#C0E6EF;}
+	.st15{fill:none;stroke:#C0E6EF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st16{fill:none;stroke:#C0E6EF;stroke-width:1.6201;stroke-miterlimit:10;}
+	.st17{fill:none;stroke:#FFFFFF;stroke-width:1.9441;stroke-miterlimit:10;}
+	.st18{fill:none;stroke:#FFFFFF;stroke-width:1.2961;stroke-miterlimit:10;}
+	.st19{fill:none;stroke:#FFFFFF;stroke-width:1.6201;stroke-miterlimit:10;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<g>
+		<g>
+			<g>
+				<path class="st0" d="M96.7,26l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9V45h-5V32.9c0-1.1-0.2-1.9-0.5-2.4s-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6V45h-5V32.9
+					c0-1.1-0.1-1.9-0.4-2.4s-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4V45h-5V26H96.7z"/>
+				<path class="st0" d="M118.5,34.9c0-3.1,0.6-5.4,1.7-7s2.7-2.3,4.7-2.3c1.7,0,3.1,0.7,4,2l0.2-1.7h4.5v19c0,2.4-0.7,4.3-2,5.6
+					c-1.4,1.3-3.3,1.9-5.9,1.9c-1,0-2.1-0.2-3.3-0.6s-2-0.9-2.6-1.6l1.7-3.4c0.5,0.5,1.1,0.9,1.8,1.2c0.7,0.3,1.5,0.5,2.1,0.5
+					c1.1,0,1.9-0.3,2.4-0.8s0.7-1.4,0.7-2.6v-1.6c-0.9,1.2-2.2,1.9-3.7,1.9c-2,0-3.6-0.8-4.7-2.4s-1.7-3.8-1.7-6.7V34.9z
+					 M123.5,36.2c0,1.8,0.2,3,0.7,3.8s1.2,1.2,2.2,1.2c1,0,1.8-0.4,2.3-1.1V31c-0.5-0.8-1.3-1.2-2.2-1.2c-1,0-1.7,0.4-2.2,1.2
+					s-0.7,2.1-0.7,3.9V36.2z"/>
+				<path class="st0" d="M142.2,26l0.1,1.8c1.1-1.4,2.6-2.1,4.4-2.1c1.9,0,3.2,0.9,4,2.6c1.1-1.7,2.6-2.6,4.7-2.6
+					c3.3,0,5,2.3,5.1,6.9V45h-5V32.9c0-1.1-0.2-1.9-0.5-2.4c-0.3-0.5-0.8-0.7-1.5-0.7c-0.9,0-1.6,0.6-2.1,1.7l0,0.6V45h-5V32.9
+					c0-1.1-0.1-1.9-0.4-2.4c-0.3-0.5-0.8-0.7-1.6-0.7c-0.9,0-1.5,0.5-2,1.4V45h-5V26H142.2z"/>
+				<path class="st0" d="M170.3,21.3V26h2.5v3.7h-2.5v9.5c0,0.8,0.1,1.3,0.3,1.5c0.2,0.3,0.6,0.4,1.2,0.4c0.5,0,0.9,0,1.2-0.1l0,3.9
+					c-0.8,0.3-1.8,0.5-2.7,0.5c-3.2,0-4.8-1.8-4.9-5.5V29.7h-2.2V26h2.2v-4.7H170.3z"/>
+				<path class="st0" d="M182.7,43.5c1.4,0,2.4-0.4,3.1-1.1c0.7-0.8,1.1-1.9,1.2-3.3h1.9c-0.1,1.9-0.7,3.5-1.9,4.6s-2.6,1.7-4.3,1.7
+					c-2.3,0-4-0.7-5.1-2.2s-1.7-3.6-1.8-6.4v-2.3c0-2.9,0.6-5.1,1.7-6.6s2.9-2.2,5.1-2.2c1.9,0,3.4,0.6,4.5,1.8s1.7,2.8,1.7,5H187
+					c-0.1-1.6-0.5-2.8-1.2-3.6s-1.8-1.3-3.1-1.3c-1.7,0-2.9,0.6-3.7,1.7c-0.8,1.1-1.2,2.9-1.2,5.2v2.2c0,2.4,0.4,4.2,1.2,5.3
+					C179.8,43,181,43.5,182.7,43.5z"/>
+				<path class="st0" d="M192.6,34.5c0-2.7,0.6-4.9,1.9-6.5s2.9-2.4,5.1-2.4c2.2,0,3.9,0.8,5.1,2.4c1.2,1.6,1.9,3.7,1.9,6.5v2
+					c0,2.8-0.6,5-1.9,6.5s-2.9,2.3-5.1,2.3s-3.8-0.8-5-2.3s-1.9-3.6-1.9-6.3V34.5z M194.6,36.5c0,2.2,0.4,3.9,1.3,5.2
+					c0.9,1.3,2.1,1.9,3.7,1.9c1.6,0,2.8-0.6,3.7-1.8c0.8-1.2,1.3-2.9,1.3-5.2v-2c0-2.2-0.4-3.9-1.3-5.2c-0.9-1.3-2.1-1.9-3.7-1.9
+					c-1.5,0-2.7,0.6-3.6,1.8c-0.9,1.2-1.3,2.9-1.4,5.1V36.5z"/>
+				<path class="st0" d="M213.2,26l0.1,3c0.6-1,1.3-1.9,2.2-2.5s1.9-0.9,3-0.9c3.3,0,5,2.2,5.1,6.6V45h-1.9V32.5
+					c0-1.7-0.3-3-0.9-3.8c-0.6-0.8-1.5-1.2-2.8-1.2c-1,0-1.9,0.4-2.8,1.2s-1.4,1.8-1.9,3.2V45h-2V26H213.2z"/>
+				<path class="st0" d="M230.3,45V27.7h-2.6V26h2.6v-2.5c0-1.9,0.5-3.3,1.3-4.3s2-1.5,3.5-1.5c0.7,0,1.3,0.1,1.9,0.3l-0.1,1.8
+					c-0.5-0.1-1-0.2-1.6-0.2c-0.9,0-1.7,0.4-2.2,1.1s-0.8,1.7-0.8,3V26h3.7v1.8h-3.7V45H230.3z"/>
+				<path class="st0" d="M240.1,20.5c0-0.4,0.1-0.7,0.3-1s0.5-0.4,0.9-0.4s0.7,0.1,1,0.4s0.3,0.6,0.3,1s-0.1,0.7-0.3,1
+					s-0.5,0.4-1,0.4s-0.7-0.1-0.9-0.4S240.1,20.9,240.1,20.5z M242.3,45h-2V26h2V45z"/>
+				<path class="st0" d="M247.4,34.6c0-3,0.5-5.2,1.5-6.7s2.6-2.2,4.6-2.2c2.2,0,3.8,1,4.9,3l0.1-2.7h1.8v19.6c0,2.3-0.6,4-1.6,5.2
+					s-2.7,1.8-4.7,1.8c-1,0-2.1-0.3-3.2-0.8s-1.9-1.1-2.4-1.9l0.9-1.4c1.3,1.5,2.8,2.2,4.5,2.2c1.6,0,2.7-0.4,3.5-1.3
+					c0.7-0.8,1.1-2.1,1.1-3.8v-3c-1.1,1.8-2.7,2.7-4.9,2.7c-2,0-3.5-0.7-4.5-2.2s-1.6-3.6-1.6-6.5V34.6z M249.3,36.4
+					c0,2.4,0.4,4.2,1.1,5.4s1.9,1.7,3.5,1.7c2.1,0,3.6-1,4.5-3v-9.7c-0.9-2.2-2.4-3.3-4.4-3.3c-1.6,0-2.8,0.6-3.5,1.7
+					s-1.1,2.9-1.1,5.3V36.4z"/>
+			</g>
+		</g>
+		<g>
+			<g>
+				<g>
+					<line class="st18" x1="19.5" y1="16" x2="34.7" y2="28.5"/>
+					<g>
+						<polygon class="st0" points="18.4,18.5 16.6,13.7 21.7,14.5 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st0" cx="10.8" cy="8.1" r="8.1"/>
+			<g>
+				<g>
+					<line class="st18" x1="34.7" y1="28" x2="49.4" y2="53.3"/>
+					<g>
+						<polygon class="st0" points="46.8,54 51.2,56.5 51.2,51.4 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st18" x1="46.2" y1="31.1" x2="63.9" y2="34.9"/>
+					<g>
+						<polygon class="st0" points="46.4,33.8 42.6,30.4 47.5,28.8 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st18" x1="34.7" y1="28.5" x2="47.9" y2="20.1"/>
+					<g>
+						<polygon class="st0" points="48.7,22.7 51.1,18.1 45.9,18.3 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st18" x1="11.2" y1="33.1" x2="23.2" y2="31"/>
+					<g>
+						<polygon class="st0" points="22.9,33.7 26.8,30.4 22,28.6 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st18" x1="61.5" y1="53" x2="71.9" y2="36.1"/>
+					<g>
+						<polygon class="st0" points="64.1,53.7 59.5,56.2 59.7,51 						"/>
+					</g>
+				</g>
+			</g>
+			<g>
+				<g>
+					<line class="st18" x1="64.7" y1="24.4" x2="71.9" y2="36.6"/>
+					<g>
+						<polygon class="st0" points="62.9,26.4 62.9,21.2 67.3,23.7 						"/>
+					</g>
+				</g>
+			</g>
+			<circle class="st0" cx="34.7" cy="28.5" r="8.1"/>
+			<circle class="st0" cx="8.1" cy="33.9" r="8.1"/>
+			<circle class="st0" cx="58.3" cy="14.5" r="8.1"/>
+			<circle class="st0" cx="55.7" cy="63.3" r="8.1"/>
+			<circle class="st0" cx="71.9" cy="36.1" r="8.1"/>
+		</g>
+	</g>
+</g>
+</svg>

config.go

@@ -1,126 +0,0 @@
-// Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
-// Written by James Shubin <james@shubin.ca> and the project contributors
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"errors"
-	"gopkg.in/yaml.v2"
-	"io/ioutil"
-	"log"
-)
-
-type noopTypeConfig struct {
-	Name string `yaml:"name"`
-}
-
-type fileTypeConfig struct {
-	Name    string `yaml:"name"`
-	Path    string `yaml:"path"`
-	Content string `yaml:"content"`
-	State   string `yaml:"state"`
-}
-
-type serviceTypeConfig struct {
-	Name    string `yaml:"name"`
-	State   string `yaml:"state"`
-	Startup string `yaml:"startup"`
-}
-
-type vertexConfig struct {
-	Type string `yaml:"type"`
-	Name string `yaml:"name"`
-}
-
-type edgeConfig struct {
-	Name string       `yaml:"name"`
-	From vertexConfig `yaml:"from"`
-	To   vertexConfig `yaml:"to"`
-}
-
-type graphConfig struct {
-	Graph string `yaml:"graph"`
-	Types struct {
-		Noop    []noopTypeConfig    `yaml:"noop"`
-		File    []fileTypeConfig    `yaml:"file"`
-		Service []serviceTypeConfig `yaml:"service"`
-	} `yaml:"types"`
-	Edges   []edgeConfig `yaml:"edges"`
-	Comment string       `yaml:"comment"`
-}
-
-func (c *graphConfig) Parse(data []byte) error {
-	if err := yaml.Unmarshal(data, c); err != nil {
-		return err
-	}
-	if c.Graph == "" {
-		return errors.New("Graph config: invalid `graph`")
-	}
-	return nil
-}
-
-func GraphFromConfig(filename string) *Graph {
-
-	var NoopMap map[string]*Vertex = make(map[string]*Vertex)
-	var FileMap map[string]*Vertex = make(map[string]*Vertex)
-	var ServiceMap map[string]*Vertex = make(map[string]*Vertex)
-
-	var lookup map[string]map[string]*Vertex = make(map[string]map[string]*Vertex)
-	lookup["noop"] = NoopMap
-	lookup["file"] = FileMap
-	lookup["service"] = ServiceMap
-
-	data, err := ioutil.ReadFile(filename)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	var config graphConfig
-	if err := config.Parse(data); err != nil {
-		log.Fatal(err)
-	}
-	//fmt.Printf("%+v\n", config)	// debug
-
-	g := NewGraph(config.Graph)
-
-	for _, t := range config.Types.Noop {
-		NoopMap[t.Name] = NewVertex(t.Name, "noop")
-		// FIXME: duplicate of name stored twice... where should it go?
-		NoopMap[t.Name].Associate(NewNoopType(t.Name))
-		g.AddVertex(NoopMap[t.Name]) // call standalone in case not part of an edge
-	}
-
-	for _, t := range config.Types.File {
-		FileMap[t.Name] = NewVertex(t.Name, "file")
-		// FIXME: duplicate of name stored twice... where should it go?
-		FileMap[t.Name].Associate(NewFileType(t.Name, t.Path, t.Content, t.State))
-		g.AddVertex(FileMap[t.Name]) // call standalone in case not part of an edge
-	}
-
-	for _, t := range config.Types.Service {
-		ServiceMap[t.Name] = NewVertex(t.Name, "service")
-		// FIXME: duplicate of name stored twice... where should it go?
-		ServiceMap[t.Name].Associate(NewServiceType(t.Name, t.State, t.Startup))
-		g.AddVertex(ServiceMap[t.Name]) // call standalone in case not part of an edge
-	}
-
-	for _, e := range config.Edges {
-		g.AddEdge(lookup[e.From.Type][e.From.Name], lookup[e.To.Type][e.To.Name], NewEdge(e.Name))
-	}
-
-	return g
-}

converger/converger.go

@@ -0,0 +1,382 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Package converger is a facility for reporting the converged state.
+package converger
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/purpleidea/mgmt/util"
+)
+
+// TODO: we could make a new function that masks out the state of certain
+// UUID's, but at the moment the new Timer code has obsoleted the need...
+
+// Converger is the general interface for implementing a convergence watcher
+type Converger interface { // TODO: need a better name
+	Register() ConvergerUUID
+	IsConverged(ConvergerUUID) bool         // is the UUID converged ?
+	SetConverged(ConvergerUUID, bool) error // set the converged state of the UUID
+	Unregister(ConvergerUUID)
+	Start()
+	Pause()
+	Loop(bool)
+	ConvergedTimer(ConvergerUUID) <-chan time.Time
+	Status() map[uint64]bool
+	Timeout() int                // returns the timeout that this was created with
+	SetStateFn(func(bool) error) // sets the stateFn
+}
+
+// ConvergerUUID is the interface resources can use to notify with if converged
+// you'll need to use part of the Converger interface to Register initially too
+type ConvergerUUID interface {
+	ID() uint64   // get Id
+	Name() string // get a friendly name
+	SetName(string)
+	IsValid() bool // has Id been initialized ?
+	InvalidateID() // set Id to nil
+	IsConverged() bool
+	SetConverged(bool) error
+	Unregister()
+	ConvergedTimer() <-chan time.Time
+	StartTimer() (func() error, error) // cancellable is the same as StopTimer()
+	ResetTimer() error                 // resets counter to zero
+	StopTimer() error
+}
+
+// converger is an implementation of the Converger interface
+type converger struct {
+	timeout   int              // must be zero (instant) or greater seconds to run
+	stateFn   func(bool) error // run on converged state changes with state bool
+	converged bool             // did we converge (state changes of this run Fn)
+	channel   chan struct{}    // signal here to run an isConverged check
+	control   chan bool        // control channel for start/pause
+	mutex     sync.RWMutex     // used for controlling access to status and lastid
+	lastid    uint64
+	status    map[uint64]bool
+}
+
+// convergerUUID is an implementation of the ConvergerUUID interface
+type convergerUUID struct {
+	converger Converger
+	id        uint64
+	name      string // user defined, friendly name
+	mutex     sync.Mutex
+	timer     chan struct{}
+	running   bool // is the above timer running?
+}
+
+// NewConverger builds a new converger struct
+func NewConverger(timeout int, stateFn func(bool) error) *converger {
+	return &converger{
+		timeout: timeout,
+		stateFn: stateFn,
+		channel: make(chan struct{}),
+		control: make(chan bool),
+		lastid:  0,
+		status:  make(map[uint64]bool),
+	}
+}
+
+// Register assigns a ConvergerUUID to the caller
+func (obj *converger) Register() ConvergerUUID {
+	obj.mutex.Lock()
+	defer obj.mutex.Unlock()
+	obj.lastid++
+	obj.status[obj.lastid] = false // initialize as not converged
+	return &convergerUUID{
+		converger: obj,
+		id:        obj.lastid,
+		name:      fmt.Sprintf("%d", obj.lastid), // some default
+		timer:     nil,
+		running:   false,
+	}
+}
+
+// IsConverged gets the converged status of a uuid
+func (obj *converger) IsConverged(uuid ConvergerUUID) bool {
+	if !uuid.IsValid() {
+		panic(fmt.Sprintf("Id of ConvergerUUID(%s) is nil!", uuid.Name()))
+	}
+	obj.mutex.RLock()
+	isConverged, found := obj.status[uuid.ID()] // lookup
+	obj.mutex.RUnlock()
+	if !found {
+		panic("Id of ConvergerUUID is unregistered!")
+	}
+	return isConverged
+}
+
+// SetConverged updates the converger with the converged state of the UUID
+func (obj *converger) SetConverged(uuid ConvergerUUID, isConverged bool) error {
+	if !uuid.IsValid() {
+		return fmt.Errorf("Id of ConvergerUUID(%s) is nil!", uuid.Name())
+	}
+	obj.mutex.Lock()
+	if _, found := obj.status[uuid.ID()]; !found {
+		panic("Id of ConvergerUUID is unregistered!")
+	}
+	obj.status[uuid.ID()] = isConverged // set
+	obj.mutex.Unlock()                  // unlock *before* poke or deadlock!
+	if isConverged != obj.converged {   // only poke if it would be helpful
+		// run in a go routine so that we never block... just queue up!
+		// this allows us to send events, even if we haven't started...
+		go func() { obj.channel <- struct{}{} }()
+	}
+	return nil
+}
+
+// isConverged returns true if *every* registered uuid has converged
+func (obj *converger) isConverged() bool {
+	obj.mutex.RLock() // take a read lock
+	defer obj.mutex.RUnlock()
+	for _, v := range obj.status {
+		if !v { // everyone must be converged for this to be true
+			return false
+		}
+	}
+	return true
+}
+
+// Unregister dissociates the ConvergedUUID from the converged checking
+func (obj *converger) Unregister(uuid ConvergerUUID) {
+	if !uuid.IsValid() {
+		panic(fmt.Sprintf("Id of ConvergerUUID(%s) is nil!", uuid.Name()))
+	}
+	obj.mutex.Lock()
+	uuid.StopTimer() // ignore any errors
+	delete(obj.status, uuid.ID())
+	obj.mutex.Unlock()
+	uuid.InvalidateID()
+}
+
+// Start causes a Converger object to start or resume running
+func (obj *converger) Start() {
+	obj.control <- true
+}
+
+// Pause causes a Converger object to stop running temporarily
+func (obj *converger) Pause() { // FIXME: add a sync ACK on pause before return
+	obj.control <- false
+}
+
+// Loop is the main loop for a Converger object; it usually runs in a goroutine
+// TODO: we could eventually have each resource tell us as soon as it converges
+// and then keep track of the time delays here, to avoid callers needing select
+// NOTE: when we have very short timeouts, if we start before all the resources
+// have joined the map, then it might appears as if we converged before we did!
+func (obj *converger) Loop(startPaused bool) {
+	if obj.control == nil {
+		panic("Converger not initialized correctly")
+	}
+	if startPaused { // start paused without racing
+		select {
+		case e := <-obj.control:
+			if !e {
+				panic("Converger expected true!")
+			}
+		}
+	}
+	for {
+		select {
+		case e := <-obj.control: // expecting "false" which means pause!
+			if e {
+				panic("Converger expected false!")
+			}
+			// now i'm paused...
+			select {
+			case e := <-obj.control:
+				if !e {
+					panic("Converger expected true!")
+				}
+				// restart
+				// kick once to refresh the check...
+				go func() { obj.channel <- struct{}{} }()
+				continue
+			}
+
+		case <-obj.channel:
+			if !obj.isConverged() {
+				if obj.converged { // we're doing a state change
+					if obj.stateFn != nil {
+						// call an arbitrary function
+						if err := obj.stateFn(false); err != nil {
+							// FIXME: what to do on error ?
+						}
+					}
+				}
+				obj.converged = false
+				continue
+			}
+
+			// we have converged!
+			if obj.timeout >= 0 { // only run if timeout is valid
+				if !obj.converged { // we're doing a state change
+					if obj.stateFn != nil {
+						// call an arbitrary function
+						if err := obj.stateFn(true); err != nil {
+							// FIXME: what to do on error ?
+						}
+					}
+				}
+			}
+			obj.converged = true
+			// loop and wait again...
+		}
+	}
+}
+
+// ConvergedTimer adds a timeout to a select call and blocks until then
+// TODO: this means we could eventually have per resource converged timeouts
+func (obj *converger) ConvergedTimer(uuid ConvergerUUID) <-chan time.Time {
+	// be clever: if i'm already converged, this timeout should block which
+	// avoids unnecessary new signals being sent! this avoids fast loops if
+	// we have a low timeout, or in particular a timeout == 0
+	if uuid.IsConverged() {
+		// blocks the case statement in select forever!
+		return util.TimeAfterOrBlock(-1)
+	}
+	return util.TimeAfterOrBlock(obj.timeout)
+}
+
+// Status returns a map of the converged status of each UUID.
+func (obj *converger) Status() map[uint64]bool {
+	status := make(map[uint64]bool)
+	obj.mutex.RLock() // take a read lock
+	defer obj.mutex.RUnlock()
+	for k, v := range obj.status { // make a copy to avoid the mutex
+		status[k] = v
+	}
+	return status
+}
+
+// Timeout returns the timeout in seconds that converger was created with. This
+// is useful to avoid passing in the timeout value separately when you're
+// already passing in the Converger struct.
+func (obj *converger) Timeout() int {
+	return obj.timeout
+}
+
+// SetStateFn sets the state function to be run on change of converged state.
+func (obj *converger) SetStateFn(stateFn func(bool) error) {
+	obj.stateFn = stateFn
+}
+
+// Id returns the unique id of this UUID object
+func (obj *convergerUUID) ID() uint64 {
+	return obj.id
+}
+
+// Name returns a user defined name for the specific convergerUUID.
+func (obj *convergerUUID) Name() string {
+	return obj.name
+}
+
+// SetName sets a user defined name for the specific convergerUUID.
+func (obj *convergerUUID) SetName(name string) {
+	obj.name = name
+}
+
+// IsValid tells us if the id is valid or has already been destroyed
+func (obj *convergerUUID) IsValid() bool {
+	return obj.id != 0 // an id of 0 is invalid
+}
+
+// InvalidateID marks the id as no longer valid
+func (obj *convergerUUID) InvalidateID() {
+	obj.id = 0 // an id of 0 is invalid
+}
+
+// IsConverged is a helper function to the regular IsConverged method
+func (obj *convergerUUID) IsConverged() bool {
+	return obj.converger.IsConverged(obj)
+}
+
+// SetConverged is a helper function to the regular SetConverged notification
+func (obj *convergerUUID) SetConverged(isConverged bool) error {
+	return obj.converger.SetConverged(obj, isConverged)
+}
+
+// Unregister is a helper function to unregister myself
+func (obj *convergerUUID) Unregister() {
+	obj.converger.Unregister(obj)
+}
+
+// ConvergedTimer is a helper around the regular ConvergedTimer method
+func (obj *convergerUUID) ConvergedTimer() <-chan time.Time {
+	return obj.converger.ConvergedTimer(obj)
+}
+
+// StartTimer runs an invisible timer that automatically converges on timeout.
+func (obj *convergerUUID) StartTimer() (func() error, error) {
+	obj.mutex.Lock()
+	if !obj.running {
+		obj.timer = make(chan struct{})
+		obj.running = true
+	} else {
+		obj.mutex.Unlock()
+		return obj.StopTimer, fmt.Errorf("Timer already started!")
+	}
+	obj.mutex.Unlock()
+	go func() {
+		for {
+			select {
+			case _, ok := <-obj.timer: // reset signal channel
+				if !ok { // channel is closed
+					return // false to exit
+				}
+				obj.SetConverged(false)
+
+			case <-obj.ConvergedTimer():
+				obj.SetConverged(true) // converged!
+				select {
+				case _, ok := <-obj.timer: // reset signal channel
+					if !ok { // channel is closed
+						return // false to exit
+					}
+				}
+			}
+		}
+	}()
+	return obj.StopTimer, nil
+}
+
+// ResetTimer resets the counter to zero if using a StartTimer internally.
+func (obj *convergerUUID) ResetTimer() error {
+	obj.mutex.Lock()
+	defer obj.mutex.Unlock()
+	if obj.running {
+		obj.timer <- struct{}{} // send the reset message
+		return nil
+	}
+	return fmt.Errorf("Timer hasn't been started!")
+}
+
+// StopTimer stops the running timer permanently until a StartTimer is run.
+func (obj *convergerUUID) StopTimer() error {
+	obj.mutex.Lock()
+	defer obj.mutex.Unlock()
+	if !obj.running {
+		return fmt.Errorf("Timer isn't running!")
+	}
+	close(obj.timer)
+	obj.running = false
+	return nil
+}

doc.go

@@ -1,5 +1,5 @@
 // Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
 // Written by James Shubin <james@shubin.ca> and the project contributors
 //
 // This program is free software: you can redistribute it and/or modify
@@ -15,22 +15,5 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+// Package main provides the main entrypoint for using the `mgmt` software.
 package main
-
-import (
-	"code.google.com/p/go-uuid/uuid"
-)
-
-type Event struct {
-	uuid string
-	Name string
-	Type string
-}
-
-func NewEvent(name, t string) *Event {
-	return &Event{
-		uuid: uuid.New(),
-		Name: name,
-		Type: t,
-	}
-}

docker/Dockerfile

@@ -0,0 +1,22 @@
+FROM golang:1.6.2
+
+MAINTAINER Michał Czeraszkiewicz <contact@czerasz.com>
+
+# Set the reset cache variable
+# Read more here: http://czerasz.com/2014/11/13/docker-tip-and-tricks/#use-refreshedat-variable-for-better-cache-control
+ENV REFRESHED_AT 2016-05-10
+
+# Update the package list to be able to use required packages
+RUN apt-get update
+
+# Change the working directory
+WORKDIR /go/src/mgmt
+
+# Copy all the files to the working directory
+COPY . /go/src/mgmt
+
+# Install dependencies
+RUN make deps
+
+# Build the binary
+RUN make build

docker/Dockerfile.development

@@ -0,0 +1,31 @@
+FROM golang:1.6.2
+
+MAINTAINER Michał Czeraszkiewicz <contact@czerasz.com>
+
+# Set the reset cache variable
+# Read more here: http://czerasz.com/2014/11/13/docker-tip-and-tricks/#use-refreshedat-variable-for-better-cache-control
+ENV REFRESHED_AT 2016-05-14
+
+RUN apt-get update
+
+# Setup User to match Host User
+# Give the nre user superuser permissions
+ARG USER_ID=1000
+ARG GROUP_ID=1000
+ARG USER_NAME=mgmt
+ARG GROUP_NAME=$USER_NAME
+RUN groupadd --gid $GROUP_ID $GROUP_NAME && \
+	useradd --create-home --home /home/$USER_NAME --uid ${USER_ID} --gid $GROUP_NAME --groups sudo $USER_NAME && \
+	echo "$USER_NAME ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
+
+# Copy all the files to the working directory
+COPY . /home/$USER_NAME/mgmt
+
+# Change working directory
+WORKDIR /home/$USER_NAME/mgmt
+
+# Install dependencies
+RUN make deps
+
+# Change user
+USER ${USER_NAME}

docker/scripts/build

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+script_directory="$( cd "$( dirname "$0" )" && pwd )"
+project_directory=$script_directory/../..
+
+# Specify the Docker image name
+image_name='purpleidea/mgmt'
+
+# Build the image which contains the compiled binary
+docker build -t $image_name \
+	--file=$project_directory/docker/Dockerfile $project_directory
+
+# Remove the container if it already exists
+docker rm -f mgmt-export 2> /dev/null
+
+# Start the container in background so we can "copy out" the binary
+docker run -d --name=mgmt-export $image_name bash -c 'while true; sleep 1000; done'
+
+# Remove the current binary
+rm $project_directory/mgmt 2> /dev/null
+
+# Get the binary from the container
+docker cp mgmt-export:/go/src/mgmt/mgmt $project_directory/mgmt
+
+# Remove the container
+docker rm -f mgmt-export 2> /dev/null

docker/scripts/build-development

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# Stop on any error
+set -e
+
+script_directory="$( cd "$( dirname "$0" )" && pwd )"
+project_directory=$script_directory/../..
+
+# Specify the Docker image name
+image_name='purpleidea/mgmt:development'
+
+# Build the image
+docker build -t $image_name \
+	--file=$project_directory/docker/Dockerfile.development $project_directory

docker/scripts/run-development

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# Stop on any error
+set -e
+
+script_directory="$( cd "$( dirname "$0" )" && pwd )"
+project_directory=$script_directory/../..
+
+# Specify the Docker image name
+image_name='purpleidea/mgmt:development'
+
+# Run container in development mode
+docker run --rm --name=mgm_development --user=mgmt \
+	-v $project_directory:/home/mgmt/mgmt \
+	-it $image_name bash

event/event.go

@@ -0,0 +1,120 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Package event provides some primitives that are used for message passing.
+package event
+
+import (
+	"fmt"
+)
+
+//go:generate stringer -type=EventName -output=eventname_stringer.go
+
+// EventName represents the type of event being passed.
+type EventName int
+
+// The different event names are used in different contexts.
+const (
+	EventNil EventName = iota
+	EventExit
+	EventStart
+	EventPause
+	EventPoke
+	EventBackPoke
+)
+
+// Resp is a channel to be used for boolean responses. A nil represents an ACK,
+// and a non-nil represents a NACK (false). This also lets us use custom errors.
+type Resp chan error
+
+// Event is the main struct that stores event information and responses.
+type Event struct {
+	Name EventName
+	Resp Resp // channel to send an ack response on, nil to skip
+	//Wg   *sync.WaitGroup // receiver barrier to Wait() for everyone else on
+	Msg      string // some words for fun
+	Activity bool   // did something interesting happen?
+}
+
+// ACK sends a single acknowledgement on the channel if one was requested.
+func (event *Event) ACK() {
+	if event.Resp != nil { // if they've requested an ACK
+		event.Resp.ACK()
+	}
+}
+
+// NACK sends a negative acknowledgement message on the channel if one was requested.
+func (event *Event) NACK() {
+	if event.Resp != nil { // if they've requested a NACK
+		event.Resp.NACK()
+	}
+}
+
+// ACKNACK sends a custom ACK or NACK message on the channel if one was requested.
+func (event *Event) ACKNACK(err error) {
+	if event.Resp != nil { // if they've requested a NACK
+		event.Resp.ACKNACK(err)
+	}
+}
+
+// NewResp is just a helper to return the right type of response channel.
+func NewResp() Resp {
+	resp := make(chan error)
+	return resp
+}
+
+// ACK sends a true value to resp.
+func (resp Resp) ACK() {
+	if resp != nil {
+		resp <- nil
+	}
+}
+
+// NACK sends a false value to resp.
+func (resp Resp) NACK() {
+	if resp != nil {
+		resp <- fmt.Errorf("NACK")
+	}
+}
+
+// ACKNACK sends a custom ACK or NACK. The ACK value is always nil, the NACK can
+// be any non-nil error value.
+func (resp Resp) ACKNACK(err error) {
+	if resp != nil {
+		resp <- err
+	}
+}
+
+// Wait waits for any response from a Resp channel and returns it.
+func (resp Resp) Wait() error {
+	return <-resp
+}
+
+// ACKWait waits for a +ive Ack from a Resp channel.
+func (resp Resp) ACKWait() {
+	for {
+		// wait until true value
+		if resp.Wait() == nil {
+			return
+		}
+	}
+}
+
+// GetActivity returns the activity value.
+func (event *Event) GetActivity() bool {
+	return event.Activity
+}

examples/autoedges1.yaml

@@ -0,0 +1,19 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1
+    meta:
+      autoedge: true
+    path: "/tmp/foo/bar/f1"
+    content: |
+      i am f1
+    state: exists
+  - name: file2
+    meta:
+      autoedge: true
+    path: "/tmp/foo/"
+    content: |
+      i am f2
+    state: exists
+edges: []

examples/autoedges2.yaml

@@ -0,0 +1,24 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1
+    meta:
+      autoedge: true
+    path: "/etc/drbd.conf"
+    content: |
+      # this is an mgmt test
+    state: exists
+  - name: file2
+    meta:
+      autoedge: true
+    path: "/tmp/foo/"
+    content: |
+      i am f2
+    state: exists
+  pkg:
+  - name: drbd-utils
+    meta:
+      autoedge: true
+    state: installed
+edges: []

examples/autoedges3.yaml

@@ -0,0 +1,29 @@
+---
+graph: mygraph
+resources:
+  pkg:
+  - name: drbd-utils
+    meta:
+      autoedge: true
+    state: installed
+  file:
+  - name: file1
+    meta:
+      autoedge: true
+    path: "/etc/drbd.conf"
+    content: |
+      # this is an mgmt test
+    state: exists
+  - name: file2
+    meta:
+      autoedge: true
+    path: "/etc/drbd.d/"
+    content: |
+      i am a directory
+    state: exists
+  svc:
+  - name: drbd
+    meta:
+      autoedge: true
+    state: stopped
+edges: []

examples/autogroup1.yaml

@@ -0,0 +1,21 @@
+---
+graph: mygraph
+resources:
+  pkg:
+  - name: drbd-utils
+    meta:
+      autogroup: false
+    state: installed
+  - name: powertop
+    meta:
+      autogroup: true
+    state: installed
+  - name: sl
+    meta:
+      autogroup: true
+    state: installed
+  - name: cowsay
+    meta:
+      autogroup: true
+    state: installed
+edges: []

examples/autogroup2.yaml

@@ -0,0 +1,17 @@
+---
+graph: mygraph
+resources:
+  pkg:
+  - name: powertop
+    meta:
+      autogroup: true
+    state: installed
+  - name: sl
+    meta:
+      autogroup: true
+    state: installed
+  - name: cowsay
+    meta:
+      autogroup: true
+    state: installed
+edges: []

examples/etcd1a.yaml

@@ -0,0 +1,18 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1a
+    path: "/tmp/mgmtA/f1a"
+    content: |
+      i am f1
+    state: exists
+  - name: "@@file2a"
+    path: "/tmp/mgmtA/f2a"
+    content: |
+      i am f2, exported from host A
+    state: exists
+collect:
+- kind: file
+  pattern: "/tmp/mgmtA/"
+edges: []

examples/etcd1b.yaml

@@ -0,0 +1,18 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1b
+    path: "/tmp/mgmtB/f1b"
+    content: |
+      i am f1
+    state: exists
+  - name: "@@file2b"
+    path: "/tmp/mgmtB/f2b"
+    content: |
+      i am f2, exported from host B
+    state: exists
+collect:
+- kind: file
+  pattern: "/tmp/mgmtB/"
+edges: []

examples/etcd1c.yaml

@@ -0,0 +1,18 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1c
+    path: "/tmp/mgmtC/f1c"
+    content: |
+      i am f1
+    state: exists
+  - name: "@@file2c"
+    path: "/tmp/mgmtC/f2c"
+    content: |
+      i am f2, exported from host C
+    state: exists
+collect:
+- kind: file
+  pattern: "/tmp/mgmtC/"
+edges: []

examples/etcd1d.yaml

@@ -0,0 +1,18 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1d
+    path: "/tmp/mgmtD/f1d"
+    content: |
+      i am f1
+    state: exists
+  - name: "@@file2d"
+    path: "/tmp/mgmtD/f2d"
+    content: |
+      i am f2, exported from host D
+    state: exists
+collect:
+- kind: file
+  pattern: "/tmp/mgmtD/"
+edges: []

examples/exec1.yaml

@@ -0,0 +1,59 @@
+---
+graph: mygraph
+resources:
+  exec:
+  - name: exec1
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec2
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec3
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec4
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: exec
+    name: exec1
+  to:
+    kind: exec
+    name: exec2
+- name: e2
+  from:
+    kind: exec
+    name: exec2
+  to:
+    kind: exec
+    name: exec3

examples/exec1a.yaml

@@ -0,0 +1,32 @@
+---
+graph: mygraph
+resources:
+  exec:
+  - name: exec1
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec2
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: exec
+    name: exec1
+  to:
+    kind: exec
+    name: exec2

examples/exec1b.yaml

@@ -0,0 +1,32 @@
+---
+graph: mygraph
+resources:
+  exec:
+  - name: exec1
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: 'true'
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec2
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: 'true'
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: exec
+    name: exec1
+  to:
+    kind: exec
+    name: exec2

examples/exec1c.yaml

@@ -0,0 +1,32 @@
+---
+graph: mygraph
+resources:
+  exec:
+  - name: exec1
+    cmd: echo hello from exec1
+    shell: ''
+    timeout: 0
+    watchcmd: sleep 10s
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec2
+    cmd: echo hello from exec2
+    shell: ''
+    timeout: 0
+    watchcmd: sleep 10s
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: exec
+    name: exec1
+  to:
+    kind: exec
+    name: exec2

examples/exec1d.yaml

@@ -0,0 +1,15 @@
+---
+graph: mygraph
+resources:
+  exec:
+  - name: exec1
+    cmd: echo hello from exec1
+    shell: ''
+    timeout: 0
+    watchcmd: sleep 5s
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges: []

examples/exec2.yaml

@@ -0,0 +1,83 @@
+---
+graph: mygraph
+resources:
+  exec:
+  - name: exec1
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec2
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec3
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec4
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec5
+    cmd: sleep 15s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: exec
+    name: exec1
+  to:
+    kind: exec
+    name: exec2
+- name: e2
+  from:
+    kind: exec
+    name: exec1
+  to:
+    kind: exec
+    name: exec3
+- name: e3
+  from:
+    kind: exec
+    name: exec2
+  to:
+    kind: exec
+    name: exec4
+- name: e4
+  from:
+    kind: exec
+    name: exec3
+  to:
+    kind: exec
+    name: exec4

examples/exec3.yaml

@@ -0,0 +1,59 @@
+---
+graph: parallel
+resources:
+  exec:
+  - name: pkg10
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: svc10
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec10
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: pkg15
+    cmd: sleep 15s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: exec
+    name: pkg10
+  to:
+    kind: exec
+    name: svc10
+- name: e2
+  from:
+    kind: exec
+    name: svc10
+  to:
+    kind: exec
+    name: exec10

examples/file1.yaml

@@ -1,41 +1,41 @@
 ---
 graph: mygraph
-types:
+resources:
   noop:
   - name: noop1
   file:
   - name: file1
-    path: /tmp/mgmt/f1
+    path: "/tmp/mgmt/f1"
     content: |
       i am f1
     state: exists
   - name: file2
-    path: /tmp/mgmt/f2
+    path: "/tmp/mgmt/f2"
     content: |
       i am f2
     state: exists
   - name: file3
-    path: /tmp/mgmt/f3
+    path: "/tmp/mgmt/f3"
     content: |
       i am f3
     state: exists
   - name: file4
-    path: /tmp/mgmt/f4
+    path: "/tmp/mgmt/f4"
     content: |
       i am f4 and i should not be here
     state: absent
 edges:
 - name: e1
   from:
-    type: file
+    kind: file
     name: file1
   to:
-    type: file
+    kind: file
     name: file2
 - name: e2
   from:
-    type: file
+    kind: file
     name: file2
   to:
-    type: file
+    kind: file
     name: file3

examples/file2.yaml

@@ -0,0 +1,13 @@
+---
+graph: mygraph
+resources:
+  noop:
+  - name: noop1
+  file:
+  - name: file1
+    path: "/tmp/mgmt/hello/"
+    source: "/var/lib/mgmt/files/some_dir/"
+    recurse: true
+    force: true
+    state: exists
+edges: []

examples/file3.yaml

@@ -0,0 +1,14 @@
+---
+graph: mygraph
+comment: You can test Watch and CheckApply failures with chmod ugo-r and chmod ugo-w.
+resources:
+  file:
+  - name: file1
+    path: "/tmp/mgmt/f1"
+    meta:
+      retry: 3
+      delay: 5000
+    content: |
+      i am f1
+    state: exists
+edges: []

examples/graph0.yaml

@@ -0,0 +1,20 @@
+---
+graph: mygraph
+comment: hello world example
+resources:
+  noop:
+  - name: noop1
+  file:
+  - name: file1
+    path: "/tmp/mgmt-hello-world"
+    content: |
+      hello world from @purpleidea
+    state: exists
+edges:
+- name: e1
+  from:
+    kind: noop
+    name: noop1
+  to:
+    kind: file
+    name: file1

examples/graph10.yaml

@@ -0,0 +1,128 @@
+---
+graph: mygraph
+comment: simple exec fan in to fan out example to demonstrate optimization
+resources:
+  exec:
+  - name: exec1
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec2
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec3
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec4
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec5
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec6
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec7
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec8
+    cmd: sleep 15s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: exec
+    name: exec1
+  to:
+    kind: exec
+    name: exec4
+- name: e2
+  from:
+    kind: exec
+    name: exec2
+  to:
+    kind: exec
+    name: exec4
+- name: e3
+  from:
+    kind: exec
+    name: exec3
+  to:
+    kind: exec
+    name: exec4
+- name: e4
+  from:
+    kind: exec
+    name: exec4
+  to:
+    kind: exec
+    name: exec5
+- name: e5
+  from:
+    kind: exec
+    name: exec4
+  to:
+    kind: exec
+    name: exec6
+- name: e6
+  from:
+    kind: exec
+    name: exec4
+  to:
+    kind: exec
+    name: exec7

examples/graph1a.yaml

@@ -0,0 +1,22 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1
+    path: "/tmp/mgmt/f1"
+    content: |
+      i am f1
+    state: exists
+  - name: file2
+    path: "/tmp/mgmt/f2"
+    content: |
+      i am f2
+    state: exists
+edges:
+- name: e1
+  from:
+    kind: file
+    name: file1
+  to:
+    kind: file
+    name: file2

examples/graph1b.yaml

@@ -0,0 +1,22 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file2
+    path: "/tmp/mgmt/f2"
+    content: |
+      i am f2
+    state: exists
+  - name: file3
+    path: "/tmp/mgmt/f3"
+    content: |
+      i am f3
+    state: exists
+edges:
+- name: e2
+  from:
+    kind: file
+    name: file2
+  to:
+    kind: file
+    name: file3

examples/graph3a.yaml

@@ -0,0 +1,28 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1a
+    path: "/tmp/mgmtA/f1a"
+    content: |
+      i am f1
+    state: exists
+  - name: file2a
+    path: "/tmp/mgmtA/f2a"
+    content: |
+      i am f2
+    state: exists
+  - name: "@@file3a"
+    path: "/tmp/mgmtA/f3a"
+    content: |
+      i am f3, exported from host A
+    state: exists
+  - name: "@@file4a"
+    path: "/tmp/mgmtA/f4a"
+    content: |
+      i am f4, exported from host A
+    state: exists
+collect:
+- kind: file
+  pattern: "/tmp/mgmtA/"
+edges: []

examples/graph3b.yaml

@@ -0,0 +1,28 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1b
+    path: "/tmp/mgmtB/f1b"
+    content: |
+      i am f1
+    state: exists
+  - name: file2b
+    path: "/tmp/mgmtB/f2b"
+    content: |
+      i am f2
+    state: exists
+  - name: "@@file3b"
+    path: "/tmp/mgmtB/f3b"
+    content: |
+      i am f3, exported from host B
+    state: exists
+  - name: "@@file4b"
+    path: "/tmp/mgmtB/f4b"
+    content: |
+      i am f4, exported from host B
+    state: exists
+collect:
+- kind: file
+  pattern: "/tmp/mgmtB/"
+edges: []

examples/graph3c.yaml

@@ -0,0 +1,28 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1c
+    path: "/tmp/mgmtC/f1c"
+    content: |
+      i am f1
+    state: exists
+  - name: file2c
+    path: "/tmp/mgmtC/f2c"
+    content: |
+      i am f2
+    state: exists
+  - name: "@@file3c"
+    path: "/tmp/mgmtC/f3c"
+    content: |
+      i am f3, exported from host C
+    state: exists
+  - name: "@@file4c"
+    path: "/tmp/mgmtC/f4c"
+    content: |
+      i am f4, exported from host C
+    state: exists
+collect:
+- kind: file
+  pattern: "/tmp/mgmtC/"
+edges: []

examples/graph4.yaml

@@ -0,0 +1,18 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1
+    path: "/tmp/mgmt/f1"
+    content: |
+      i am f1
+    state: exists
+  - name: "@@file3"
+    path: "/tmp/mgmt/f3"
+    content: |
+      i am f3, exported from host A
+    state: exists
+collect:
+- kind: file
+  pattern: ''
+edges:

examples/graph5.yaml

@@ -0,0 +1,13 @@
+---
+graph: mygraph
+resources:
+  file:
+  - name: file1
+    path: "/tmp/mgmt/f1"
+    content: |
+      i am f1
+    state: exists
+collect:
+- kind: file
+  pattern: ''
+edges:

examples/graph6.yaml

@@ -0,0 +1,6 @@
+---
+graph: mygraph
+resources:
+  noop:
+  - name: noop1
+edges:

examples/graph7.yaml

@@ -0,0 +1,17 @@
+---
+graph: mygraph
+resources:
+  noop:
+  - name: noop1
+  exec:
+  - name: exec1
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:

examples/graph9.yaml

@@ -0,0 +1,77 @@
+---
+graph: mygraph
+comment: simple exec fan in example to demonstrate optimization
+resources:
+  exec:
+  - name: exec1
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec2
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec3
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec4
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec5
+    cmd: sleep 10s
+    shell: ''
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: exec
+    name: exec1
+  to:
+    kind: exec
+    name: exec5
+- name: e2
+  from:
+    kind: exec
+    name: exec2
+  to:
+    kind: exec
+    name: exec5
+- name: e3
+  from:
+    kind: exec
+    name: exec3
+  to:
+    kind: exec
+    name: exec5

examples/msg1.yaml

@@ -0,0 +1,19 @@
+---
+graph: mygraph
+comment: timer example
+resources:
+  timer:
+  - name: timer1
+    interval: 30
+  msg:
+  - name: msg1
+    body: mgmt logged this message
+    journal: true
+edges:
+- name: e1
+  from:
+    kind: timer
+    name: timer1
+  to:
+    kind: msg
+    name: msg1

examples/noop1.yaml

@@ -0,0 +1,24 @@
+---
+graph: mygraph
+comment: noop example
+resources:
+  noop:
+  - name: noop1
+    meta:
+      noop: true
+  file:
+  - name: file1
+    path: "/tmp/mgmt-hello-noop"
+    content: |
+      hello world from @purpleidea
+    state: exists
+    meta:
+      noop: true
+edges:
+- name: e1
+  from:
+    kind: noop
+    name: noop1
+  to:
+    kind: file
+    name: file1

examples/pkg1.yaml

@@ -0,0 +1,7 @@
+---
+graph: mygraph
+resources:
+  pkg:
+  - name: powertop
+    state: installed
+edges: []

examples/pkg2.yaml

@@ -0,0 +1,7 @@
+---
+graph: mygraph
+resources:
+  pkg:
+  - name: powertop
+    state: uninstalled
+edges: []

examples/purpleidea.service

@@ -0,0 +1,8 @@
+[Unit]
+Description=Fake service for testing
+
+[Service]
+ExecStart=/usr/bin/sleep 8h
+
+[Install]
+WantedBy=multi-user.target

examples/remote1.yaml

@@ -0,0 +1,23 @@
+---
+graph: mygraph
+comment: remote noop example
+resources:
+  noop:
+  - name: noop1
+    meta:
+      noop: true
+  file:
+  - name: file1
+    path: "/tmp/mgmt-remote-hello"
+    content: |
+      hello world from @purpleidea
+    state: exists
+edges:
+- name: e1
+  from:
+    kind: noop
+    name: noop1
+  to:
+    kind: file
+    name: file1
+remote: "ssh://root:password@hostname:22"

examples/svc1.yaml

@@ -1,30 +1,30 @@
 ---
 graph: mygraph
-types:
+resources:
   noop:
   - name: noop1
   file:
   - name: file1
-    path: /tmp/mgmt/f1
+    path: "/tmp/mgmt/f1"
     content: |
       i am f1
     state: exists
-  service:
+  svc:
   - name: purpleidea
     state: running
     startup: enabled
 edges:
 - name: e1
   from:
-    type: noop
+    kind: noop
     name: noop1
   to:
-    type: file
+    kind: file
     name: file1
 - name: e2
   from:
-    type: file
+    kind: file
     name: file1
   to:
-    type: service
+    kind: svc
     name: purpleidea

examples/timer1.yaml

@@ -0,0 +1,25 @@
+---
+graph: mygraph
+comment: timer example
+resources:
+  timer:
+  - name: timer1
+    interval: 30
+  exec:
+  - name: exec1
+    cmd: echo hello world
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: timer
+    name: timer1
+  to:
+    kind: exec
+    name: exec1

examples/timer2.yaml

@@ -0,0 +1,43 @@
+---
+graph: mygraph
+comment: example of multiple timers
+resources:
+  timer:
+  - name: timer1
+    interval: 30
+  - name: timer2
+    interval: 60
+  exec:
+  - name: exec1
+    cmd: echo hello world 30
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+  - name: exec2
+    cmd: echo hello world 60
+    timeout: 0
+    watchcmd: ''
+    watchshell: ''
+    ifcmd: ''
+    ifshell: ''
+    pollint: 0
+    state: present
+edges:
+- name: e1
+  from:
+    kind: timer
+    name: timer1
+  to:
+    kind: exec
+    name: exec1
+- name: e2
+  from:
+    kind: timer
+    name: timer2
+  to:
+    kind: exec
+    name: exec2

file.go

@@ -1,339 +0,0 @@
-// Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
-// Written by James Shubin <james@shubin.ca> and the project contributors
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"code.google.com/p/go-uuid/uuid"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"gopkg.in/fsnotify.v1"
-	//"github.com/go-fsnotify/fsnotify" // git master of "gopkg.in/fsnotify.v1"
-	"io"
-	"log"
-	"math"
-	"os"
-	"path"
-	"strings"
-	"syscall"
-)
-
-type FileType struct {
-	uuid      string
-	Type      string      // always "file"
-	Name      string      // name variable
-	Events    chan string // FIXME: eventually a struct for the event?
-	Path      string      // path variable (should default to name)
-	Content   string
-	State     string // state: exists/present?, absent, (undefined?)
-	sha256sum string
-}
-
-func NewFileType(name, path, content, state string) *FileType {
-	// FIXME if path = nil, path = name ...
-	return &FileType{
-		uuid:      uuid.New(),
-		Type:      "file",
-		Name:      name,
-		Events:    make(chan string, 1), // XXX: chan size?
-		Path:      path,
-		Content:   content,
-		State:     state,
-		sha256sum: "",
-	}
-}
-
-// File watcher for files and directories
-// Modify with caution, probably important to write some test cases first!
-func (obj FileType) Watch(v *Vertex) {
-	// obj.Path: file or directory
-	//var recursive bool = false
-	//var isdir = (obj.Path[len(obj.Path)-1:] == "/") // dirs have trailing slashes
-	//fmt.Printf("IsDirectory: %v\n", isdir)
-
-	var safename = path.Clean(obj.Path) // no trailing slash
-
-	watcher, err := fsnotify.NewWatcher()
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer watcher.Close()
-
-	patharray := PathSplit(safename) // tokenize the path
-	var index = len(patharray)       // starting index
-	var current string               // current "watcher" location
-	var delta_depth int              // depth delta between watcher and event
-	var send = false                 // send event?
-	var extraCheck = false
-
-	for {
-		current = strings.Join(patharray[0:index], "/")
-		if current == "" { // the empty string top is the root dir ("/")
-			current = "/"
-		}
-		log.Printf("Watching: %v\n", current) // attempting to watch...
-
-		// initialize in the loop so that we can reset on rm-ed handles
-		err = watcher.Add(current)
-		if err != nil {
-			if err == syscall.ENOENT {
-				index-- // usually not found, move up one dir
-			} else if err == syscall.ENOSPC {
-				// XXX: i sometimes see: no space left on device
-				// XXX: why causes this to happen ?
-				log.Printf("Strange file[%v] error: %+v\n", obj.Name, err.Error) // 0x408da0
-				log.Fatal(err)
-			} else {
-				log.Printf("Unknown file[%v] error:\n", obj.Name)
-				log.Fatal(err)
-			}
-			index = int(math.Max(1, float64(index)))
-			continue
-		}
-
-		// XXX: check state after inotify started
-		// SMALL RACE: after we terminate watch, till when it's started
-		// something could have gotten created/changed/etc... right?
-		if extraCheck {
-			extraCheck = false
-			// XXX
-			//if exists ... {
-			//	send signal
-			//	continue
-			//	change index? i don't think so. be thorough and check
-			//}
-		}
-
-		select {
-		case event := <-watcher.Events:
-			// the deeper you go, the bigger the delta_depth is...
-			// this is the difference between what we're watching,
-			// and the event... doesn't mean we can't watch deeper
-			if current == event.Name {
-				delta_depth = 0 // i was watching what i was looking for
-
-			} else if HasPathPrefix(event.Name, current) {
-				delta_depth = len(PathSplit(current)) - len(PathSplit(event.Name)) // -1 or less
-
-			} else if HasPathPrefix(current, event.Name) {
-				delta_depth = len(PathSplit(event.Name)) - len(PathSplit(current)) // +1 or more
-
-			} else {
-				// XXX multiple watchers receive each others events
-				// https://github.com/go-fsnotify/fsnotify/issues/95
-				// this happened with two values such as:
-				// event.Name: /tmp/mgmt/f3 and current: /tmp/mgmt/f2
-				// are the different watchers getting each others events??
-				//log.Printf("The delta depth is NaN...\n")
-				//log.Printf("Value of event.Name is: %v\n", event.Name)
-				//log.Printf("........    current is: %v\n", current)
-				//log.Fatal("The delta depth is NaN!")
-				continue
-			}
-			//log.Printf("The delta depth is: %v\n", delta_depth)
-
-			// if we have what we wanted, awesome, send an event...
-			if event.Name == safename {
-				//log.Println("Event!")
-				send = true
-
-				// file removed, move the watch upwards
-				if delta_depth >= 0 && (event.Op&fsnotify.Remove == fsnotify.Remove) {
-					//log.Println("Removal!")
-					watcher.Remove(current)
-					index--
-				}
-
-				// we must be a parent watcher, so descend in
-				if delta_depth < 0 {
-					watcher.Remove(current)
-					index++
-				}
-
-				// if safename starts with event.Name, we're above, and no event should be sent
-			} else if HasPathPrefix(safename, event.Name) {
-				//log.Println("Above!")
-
-				if delta_depth >= 0 && (event.Op&fsnotify.Remove == fsnotify.Remove) {
-					log.Println("Removal!")
-					watcher.Remove(current)
-					index--
-				}
-
-				if delta_depth < 0 {
-					watcher.Remove(current)
-					index++
-				}
-
-				// if event.Name startswith safename, send event, we're already deeper
-			} else if HasPathPrefix(event.Name, safename) {
-				//log.Println("Event2!")
-				send = true
-			}
-
-		case err := <-watcher.Errors:
-			log.Println("error:", err)
-			log.Fatal(err)
-			v.Events <- fmt.Sprintf("file: %v", "error")
-
-		case exit := <-obj.Events:
-			if exit == "exit" {
-				return
-			} else {
-				log.Fatal("Unknown event: %v\n", exit)
-			}
-		}
-
-		// do all our event sending all together to avoid duplicate msgs
-		if send {
-			send = false
-			//log.Println("Sending event!")
-			//v.Events <- fmt.Sprintf("file(%v): %v", obj.Path, event.Op)
-			v.Events <- fmt.Sprintf("file(%v): %v", obj.Path, "event!") // FIXME: use struct
-		}
-	}
-}
-
-func (obj FileType) Exit() bool {
-	obj.Events <- "exit"
-	return true
-}
-
-func (obj FileType) HashSHA256fromContent() string {
-	if obj.sha256sum != "" { // return if already computed
-		return obj.sha256sum
-	}
-
-	hash := sha256.New()
-	hash.Write([]byte(obj.Content))
-	obj.sha256sum = hex.EncodeToString(hash.Sum(nil))
-	return obj.sha256sum
-}
-
-func (obj FileType) StateOK() bool {
-	if _, err := os.Stat(obj.Path); os.IsNotExist(err) {
-		// no such file or directory
-		if obj.State == "absent" {
-			return true // missing file should be missing, phew :)
-		} else {
-			// state invalid, skip expensive checksums
-			return false
-		}
-	}
-
-	// TODO: add file mode check here...
-
-	if PathIsDir(obj.Path) {
-		return obj.StateOKDir()
-	} else {
-		return obj.StateOKFile()
-	}
-}
-
-func (obj FileType) StateOKFile() bool {
-	if PathIsDir(obj.Path) {
-		log.Fatal("This should only be called on a File type.")
-	}
-
-	// run a diff, and return true if needs changing
-
-	hash := sha256.New()
-
-	f, err := os.Open(obj.Path)
-	if err != nil {
-		//log.Fatal(err)
-		return false
-	}
-	defer f.Close()
-
-	if _, err := io.Copy(hash, f); err != nil {
-		//log.Fatal(err)
-		return false
-	}
-
-	sha256sum := hex.EncodeToString(hash.Sum(nil))
-	//fmt.Printf("sha256sum: %v\n", sha256sum)
-
-	if obj.HashSHA256fromContent() == sha256sum {
-		return true
-	}
-
-	return false
-}
-
-func (obj FileType) StateOKDir() bool {
-	if !PathIsDir(obj.Path) {
-		log.Fatal("This should only be called on a Dir type.")
-	}
-
-	// XXX: not implemented
-	log.Fatal("Not implemented!")
-	return false
-}
-
-func (obj FileType) Apply() bool {
-	fmt.Printf("Apply->%v[%v]\n", obj.Type, obj.Name)
-
-	if PathIsDir(obj.Path) {
-		return obj.ApplyDir()
-	} else {
-		return obj.ApplyFile()
-	}
-}
-
-func (obj FileType) ApplyFile() bool {
-
-	if PathIsDir(obj.Path) {
-		log.Fatal("This should only be called on a File type.")
-	}
-
-	if obj.State == "absent" {
-		log.Printf("About to remove: %v\n", obj.Path)
-		err := os.Remove(obj.Path)
-		if err != nil {
-			return false
-		}
-		return true
-	}
-
-	//fmt.Println("writing: " + filename)
-	f, err := os.Create(obj.Path)
-	if err != nil {
-		log.Println("error:", err)
-		return false
-	}
-	defer f.Close()
-
-	_, err = io.WriteString(f, obj.Content)
-	if err != nil {
-		log.Println("error:", err)
-		return false
-	}
-
-	return true
-}
-
-func (obj FileType) ApplyDir() bool {
-	if !PathIsDir(obj.Path) {
-		log.Fatal("This should only be called on a Dir type.")
-	}
-
-	// XXX: not implemented
-	log.Fatal("Not implemented!")
-	return true
-}

gconfig/gconfig.go

@@ -0,0 +1,269 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Package gconfig provides the facilities for loading a graph from a yaml file.
+package gconfig
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"reflect"
+	"strings"
+
+	"github.com/purpleidea/mgmt/etcd"
+	"github.com/purpleidea/mgmt/event"
+	"github.com/purpleidea/mgmt/global"
+	"github.com/purpleidea/mgmt/pgraph"
+	"github.com/purpleidea/mgmt/resources"
+	"github.com/purpleidea/mgmt/util"
+
+	"gopkg.in/yaml.v2"
+)
+
+type collectorResConfig struct {
+	Kind    string `yaml:"kind"`
+	Pattern string `yaml:"pattern"` // XXX: Not Implemented
+}
+
+type vertexConfig struct {
+	Kind string `yaml:"kind"`
+	Name string `yaml:"name"`
+}
+
+type edgeConfig struct {
+	Name string       `yaml:"name"`
+	From vertexConfig `yaml:"from"`
+	To   vertexConfig `yaml:"to"`
+}
+
+// GraphConfig is the data structure that describes a single graph to run.
+type GraphConfig struct {
+	Graph     string `yaml:"graph"`
+	Resources struct {
+		Noop  []*resources.NoopRes  `yaml:"noop"`
+		Pkg   []*resources.PkgRes   `yaml:"pkg"`
+		File  []*resources.FileRes  `yaml:"file"`
+		Svc   []*resources.SvcRes   `yaml:"svc"`
+		Exec  []*resources.ExecRes  `yaml:"exec"`
+		Timer []*resources.TimerRes `yaml:"timer"`
+		Msg   []*resources.MsgRes   `yaml:"msg"`
+	} `yaml:"resources"`
+	Collector []collectorResConfig `yaml:"collect"`
+	Edges     []edgeConfig         `yaml:"edges"`
+	Comment   string               `yaml:"comment"`
+	Hostname  string               `yaml:"hostname"` // uuid for the host
+	Remote    string               `yaml:"remote"`
+}
+
+// Parse parses a data stream into the graph structure.
+func (c *GraphConfig) Parse(data []byte) error {
+	if err := yaml.Unmarshal(data, c); err != nil {
+		return err
+	}
+	if c.Graph == "" {
+		return errors.New("Graph config: invalid `graph`")
+	}
+	return nil
+}
+
+// ParseConfigFromFile takes a filename and returns the graph config structure.
+func ParseConfigFromFile(filename string) *GraphConfig {
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		log.Printf("Config: Error: ParseConfigFromFile: File: %v", err)
+		return nil
+	}
+
+	var config GraphConfig
+	if err := config.Parse(data); err != nil {
+		log.Printf("Config: Error: ParseConfigFromFile: Parse: %v", err)
+		return nil
+	}
+
+	return &config
+}
+
+// NewGraphFromConfig returns a new graph from existing input, such as from the
+// existing graph, and a GraphConfig struct.
+func (c *GraphConfig) NewGraphFromConfig(g *pgraph.Graph, embdEtcd *etcd.EmbdEtcd, noop bool) (*pgraph.Graph, error) {
+	if c.Hostname == "" {
+		return nil, fmt.Errorf("Config: Error: Hostname can't be empty!")
+	}
+
+	var graph *pgraph.Graph // new graph to return
+	if g == nil {           // FIXME: how can we check for an empty graph?
+		graph = pgraph.NewGraph("Graph") // give graph a default name
+	} else {
+		graph = g.Copy() // same vertices, since they're pointers!
+	}
+
+	var lookup = make(map[string]map[string]*pgraph.Vertex)
+
+	//log.Printf("%+v", config) // debug
+
+	// TODO: if defined (somehow)...
+	graph.SetName(c.Graph) // set graph name
+
+	var keep []*pgraph.Vertex        // list of vertex which are the same in new graph
+	var resourceList []resources.Res // list of resources to export
+	// use reflection to avoid duplicating code... better options welcome!
+	value := reflect.Indirect(reflect.ValueOf(c.Resources))
+	vtype := value.Type()
+	for i := 0; i < vtype.NumField(); i++ { // number of fields in struct
+		name := vtype.Field(i).Name // string of field name
+		field := value.FieldByName(name)
+		iface := field.Interface() // interface type of value
+		slice := reflect.ValueOf(iface)
+		// XXX: should we just drop these everywhere and have the kind strings be all lowercase?
+		kind := util.FirstToUpper(name)
+		if global.DEBUG {
+			log.Printf("Config: Processing: %v...", kind)
+		}
+		for j := 0; j < slice.Len(); j++ { // loop through resources of same kind
+			x := slice.Index(j).Interface()
+			res, ok := x.(resources.Res) // convert to Res type
+			if !ok {
+				return nil, fmt.Errorf("Config: Error: Can't convert: %v of type: %T to Res.", x, x)
+			}
+			if noop {
+				res.Meta().Noop = noop
+			}
+			if _, exists := lookup[kind]; !exists {
+				lookup[kind] = make(map[string]*pgraph.Vertex)
+			}
+			// XXX: should we export based on a @@ prefix, or a metaparam
+			// like exported => true || exported => (host pattern)||(other pattern?)
+			if !strings.HasPrefix(res.GetName(), "@@") { // not exported resource
+				// XXX: we don't have a way of knowing if any of the
+				// metaparams are undefined, and as a result to set the
+				// defaults that we want! I hate the go yaml parser!!!
+				v := graph.GetVertexMatch(res)
+				if v == nil { // no match found
+					res.Init()
+					v = pgraph.NewVertex(res)
+					graph.AddVertex(v) // call standalone in case not part of an edge
+				}
+				lookup[kind][res.GetName()] = v // used for constructing edges
+				keep = append(keep, v)          // append
+
+			} else if !noop { // do not export any resources if noop
+				// store for addition to etcd storage...
+				res.SetName(res.GetName()[2:]) //slice off @@
+				res.SetKind(kind)              // cheap init
+				resourceList = append(resourceList, res)
+			}
+		}
+	}
+	// store in etcd
+	if err := etcd.EtcdSetResources(embdEtcd, c.Hostname, resourceList); err != nil {
+		return nil, fmt.Errorf("Config: Could not export resources: %v", err)
+	}
+
+	// lookup from etcd
+	var hostnameFilter []string // empty to get from everyone
+	kindFilter := []string{}
+	for _, t := range c.Collector {
+		// XXX: should we just drop these everywhere and have the kind strings be all lowercase?
+		kind := util.FirstToUpper(t.Kind)
+		kindFilter = append(kindFilter, kind)
+	}
+	// do all the graph look ups in one single step, so that if the etcd
+	// database changes, we don't have a partial state of affairs...
+	if len(kindFilter) > 0 { // if kindFilter is empty, don't need to do lookups!
+		var err error
+		resourceList, err = etcd.EtcdGetResources(embdEtcd, hostnameFilter, kindFilter)
+		if err != nil {
+			return nil, fmt.Errorf("Config: Could not collect resources: %v", err)
+		}
+	}
+	for _, res := range resourceList {
+		matched := false
+		// see if we find a collect pattern that matches
+		for _, t := range c.Collector {
+			// XXX: should we just drop these everywhere and have the kind strings be all lowercase?
+			kind := util.FirstToUpper(t.Kind)
+			// use t.Kind and optionally t.Pattern to collect from etcd storage
+			log.Printf("Collect: %v; Pattern: %v", kind, t.Pattern)
+
+			// XXX: expand to more complex pattern matching here...
+			if res.Kind() != kind {
+				continue
+			}
+
+			if matched {
+				// we've already matched this resource, should we match again?
+				log.Printf("Config: Warning: Matching %v[%v] again!", kind, res.GetName())
+			}
+			matched = true
+
+			// collect resources but add the noop metaparam
+			if noop {
+				res.Meta().Noop = noop
+			}
+
+			if t.Pattern != "" { // XXX: simplistic for now
+				res.CollectPattern(t.Pattern) // res.Dirname = t.Pattern
+			}
+
+			log.Printf("Collect: %v[%v]: collected!", kind, res.GetName())
+
+			// XXX: similar to other resource add code:
+			if _, exists := lookup[kind]; !exists {
+				lookup[kind] = make(map[string]*pgraph.Vertex)
+			}
+			v := graph.GetVertexMatch(res)
+			if v == nil { // no match found
+				res.Init() // initialize go channels or things won't work!!!
+				v = pgraph.NewVertex(res)
+				graph.AddVertex(v) // call standalone in case not part of an edge
+			}
+			lookup[kind][res.GetName()] = v // used for constructing edges
+			keep = append(keep, v)          // append
+
+			//break // let's see if another resource even matches
+		}
+	}
+
+	// get rid of any vertices we shouldn't "keep" (that aren't in new graph)
+	for _, v := range graph.GetVertices() {
+		if !pgraph.VertexContains(v, keep) {
+			// wait for exit before starting new graph!
+			v.SendEvent(event.EventExit, true, false)
+			graph.DeleteVertex(v)
+		}
+	}
+
+	for _, e := range c.Edges {
+		if _, ok := lookup[util.FirstToUpper(e.From.Kind)]; !ok {
+			return nil, fmt.Errorf("Can't find 'from' resource!")
+		}
+		if _, ok := lookup[util.FirstToUpper(e.To.Kind)]; !ok {
+			return nil, fmt.Errorf("Can't find 'to' resource!")
+		}
+		if _, ok := lookup[util.FirstToUpper(e.From.Kind)][e.From.Name]; !ok {
+			return nil, fmt.Errorf("Can't find 'from' name!")
+		}
+		if _, ok := lookup[util.FirstToUpper(e.To.Kind)][e.To.Name]; !ok {
+			return nil, fmt.Errorf("Can't find 'to' name!")
+		}
+		graph.AddEdge(lookup[util.FirstToUpper(e.From.Kind)][e.From.Name], lookup[util.FirstToUpper(e.To.Kind)][e.To.Name], pgraph.NewEdge(e.Name))
+	}
+
+	return graph, nil
+}

global/global.go

@@ -0,0 +1,26 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Package global holds some global variables that are used throughout the code.
+package global
+
+// These constants are used throughout the program.
+const (
+	DEBUG   = false // add additional log messages
+	TRACE   = false // add execution flow log messages
+	VERBOSE = false // add extra log message output
+)

gopath/.gitignore

@@ -0,0 +1,2 @@
+bin/
+pkg/

gopath/src

@@ -0,0 +1 @@
+../vendor

main.go

@@ -1,5 +1,5 @@
 // Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
 // Written by James Shubin <james@shubin.ca> and the project contributors
 //
 // This program is free software: you can redistribute it and/or modify
@@ -19,103 +19,428 @@ package main
 
 import (
 	"fmt"
-	"github.com/codegangsta/cli"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/signal"
 	"sync"
 	"syscall"
 	"time"
+
+	"github.com/purpleidea/mgmt/converger"
+	"github.com/purpleidea/mgmt/etcd"
+	"github.com/purpleidea/mgmt/gconfig"
+	"github.com/purpleidea/mgmt/global"
+	"github.com/purpleidea/mgmt/pgraph"
+	"github.com/purpleidea/mgmt/puppet"
+	"github.com/purpleidea/mgmt/recwatch"
+	"github.com/purpleidea/mgmt/remote"
+	"github.com/purpleidea/mgmt/util"
+
+	etcdtypes "github.com/coreos/etcd/pkg/types"
+	"github.com/coreos/pkg/capnslog"
+	"github.com/urfave/cli"
 )
 
 // set at compile time
 var (
-	version string
 	program string
-)
+	version string
-
+	prefix  = fmt.Sprintf("/var/lib/%s/", program)
-const (
-	DEBUG = false
 )
 
 // signal handler
-func waitForSignal(exit chan bool) {
+func waitForSignal(exit chan error) error {
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals, os.Interrupt) // catch ^C
 	//signal.Notify(signals, os.Kill) // catch signals
 	signal.Notify(signals, syscall.SIGTERM)
 
 	select {
-	case e := <-signals: // any signal will do
+	case sig := <-signals: // any signal will do
-		if e == os.Interrupt {
+		if sig == os.Interrupt {
-			fmt.Println() // put ^C char from terminal on its own line
 			log.Println("Interrupted by ^C")
+			return nil
 		} else {
 			log.Println("Interrupted by signal")
+			return fmt.Errorf("Killed by %v", sig)
 		}
-	case <-exit: // or a manual signal
+	case err := <-exit: // or a manual signal
 		log.Println("Interrupted by exit signal")
+		return err
 	}
 }
 
-func run(c *cli.Context) {
+// run is the main run target.
-	var start int64 = time.Now().UnixNano()
+func run(c *cli.Context) error {
-	var wg sync.WaitGroup
+	var start = time.Now().UnixNano()
-	exit := make(chan bool) // exit signal
+	log.Printf("This is: %v, version: %v", program, version)
-	log.Printf("This is: %v, version: %v\n", program, version)
+	log.Printf("Main: Start: %v", start)
 
-	// exit after `exittime` seconds for no reason at all...
+	hostname, _ := os.Hostname()
-	if i := c.Int("exittime"); i > 0 {
+	// allow passing in the hostname, instead of using --hostname
+	if c.IsSet("file") {
+		if config := gconfig.ParseConfigFromFile(c.String("file")); config != nil {
+			if h := config.Hostname; h != "" {
+				hostname = h
+			}
+		}
+	}
+	if c.IsSet("hostname") { // override by cli
+		if h := c.String("hostname"); h != "" {
+			hostname = h
+		}
+	}
+	noop := c.Bool("noop")
+
+	seeds, err := etcdtypes.NewURLs(
+		util.FlattenListWithSplit(c.StringSlice("seeds"), []string{",", ";", " "}),
+	)
+	if err != nil && len(c.StringSlice("seeds")) > 0 {
+		log.Printf("Main: Error: seeds didn't parse correctly!")
+		return cli.NewExitError("", 1)
+	}
+	clientURLs, err := etcdtypes.NewURLs(
+		util.FlattenListWithSplit(c.StringSlice("client-urls"), []string{",", ";", " "}),
+	)
+	if err != nil && len(c.StringSlice("client-urls")) > 0 {
+		log.Printf("Main: Error: clientURLs didn't parse correctly!")
+		return cli.NewExitError("", 1)
+	}
+	serverURLs, err := etcdtypes.NewURLs(
+		util.FlattenListWithSplit(c.StringSlice("server-urls"), []string{",", ";", " "}),
+	)
+	if err != nil && len(c.StringSlice("server-urls")) > 0 {
+		log.Printf("Main: Error: serverURLs didn't parse correctly!")
+		return cli.NewExitError("", 1)
+	}
+
+	idealClusterSize := uint16(c.Int("ideal-cluster-size"))
+	if idealClusterSize < 1 {
+		log.Printf("Main: Error: idealClusterSize should be at least one!")
+		return cli.NewExitError("", 1)
+	}
+
+	if c.IsSet("file") && c.IsSet("puppet") {
+		log.Println("Main: Error: the --file and --puppet parameters cannot be used together!")
+		return cli.NewExitError("", 1)
+	}
+
+	if c.Bool("no-server") && len(c.StringSlice("remote")) > 0 {
+		// TODO: in this case, we won't be able to tunnel stuff back to
+		// here, so if we're okay with every remote graph running in an
+		// isolated mode, then this is okay. Improve on this if there's
+		// someone who really wants to be able to do this.
+		log.Println("Main: Error: the --no-server and --remote parameters cannot be used together!")
+		return cli.NewExitError("", 1)
+	}
+
+	cConns := uint16(c.Int("cconns"))
+	if cConns < 0 {
+		log.Printf("Main: Error: --cconns should be at least zero!")
+		return cli.NewExitError("", 1)
+	}
+
+	if c.IsSet("converged-timeout") && cConns > 0 && len(c.StringSlice("remote")) > c.Int("cconns") {
+		log.Printf("Main: Error: combining --converged-timeout with more remotes than available connections will never converge!")
+		return cli.NewExitError("", 1)
+	}
+
+	depth := uint16(c.Int("depth"))
+	if depth < 0 { // user should not be using this argument manually
+		log.Printf("Main: Error: negative values for --depth are not permitted!")
+		return cli.NewExitError("", 1)
+	}
+
+	if c.IsSet("prefix") && c.Bool("tmp-prefix") {
+		log.Println("Main: Error: combining --prefix and the request for a tmp prefix is illogical!")
+		return cli.NewExitError("", 1)
+	}
+	if s := c.String("prefix"); c.IsSet("prefix") && s != "" {
+		prefix = s
+	}
+
+	// make sure the working directory prefix exists
+	if c.Bool("tmp-prefix") || os.MkdirAll(prefix, 0770) != nil {
+		if c.Bool("tmp-prefix") || c.Bool("allow-tmp-prefix") {
+			if prefix, err = ioutil.TempDir("", program+"-"); err != nil {
+				log.Printf("Main: Error: Can't create temporary prefix!")
+				return cli.NewExitError("", 1)
+			}
+			log.Println("Main: Warning: Working prefix directory is temporary!")
+
+		} else {
+			log.Printf("Main: Error: Can't create prefix!")
+			return cli.NewExitError("", 1)
+		}
+	}
+	log.Printf("Main: Working prefix is: %s", prefix)
+
+	var wg sync.WaitGroup
+	exit := make(chan error) // exit signal
+	var G, fullGraph *pgraph.Graph
+
+	// exit after `max-runtime` seconds for no reason at all...
+	if i := c.Int("max-runtime"); i > 0 {
 		go func() {
 			time.Sleep(time.Duration(i) * time.Second)
-			exit <- true
+			exit <- nil
 		}()
 	}
 
-	// build the graph from a config file
+	// setup converger
-	G := GraphFromConfig(c.String("file"))
+	converger := converger.NewConverger(
-	log.Printf("Graph: %v\n", G) // show graph
+		c.Int("converged-timeout"),
+		nil, // stateFn gets added in by EmbdEtcd
+	)
+	go converger.Loop(true) // main loop for converger, true to start paused
 
-	log.Printf("Start: %v\n", start)
+	// embedded etcd
-
+	if len(seeds) == 0 {
-	for x := range G.GetVerticesChan() { // XXX ?
+		log.Printf("Main: Seeds: No seeds specified!")
-		log.Printf("Main->Starting[%v]\n", x.Name)
+	} else {
-
+		log.Printf("Main: Seeds(%v): %v", len(seeds), seeds)
-		wg.Add(1)
+	}
-		// must pass in value to avoid races...
+	EmbdEtcd := etcd.NewEmbdEtcd(
-		// see: https://ttboj.wordpress.com/2015/07/27/golang-parallelism-issues-causing-too-many-open-files-error/
+		hostname,
-		go func(v *Vertex) {
+		seeds,
-			defer wg.Done()
+		clientURLs,
-			v.Start()
+		serverURLs,
-			log.Printf("Main->Finish[%v]\n", v.Name)
+		c.Bool("no-server"),
-		}(x)
+		idealClusterSize,
-
+		prefix,
-		// generate a startup "poke" so that an initial check happens
+		converger,
-		go func(v *Vertex) {
+	)
-			v.Events <- fmt.Sprintf("Startup(%v)", v.Name)
+	if EmbdEtcd == nil {
-		}(x)
+		// TODO: verify EmbdEtcd is not nil below...
+		exit <- fmt.Errorf("Main: Etcd: Creation failed!")
+	} else if err := EmbdEtcd.Startup(); err != nil { // startup (returns when etcd main loop is running)
+		exit <- fmt.Errorf("Main: Etcd: Startup failed: %v", err)
+	}
+	convergerStateFn := func(b bool) error {
+		// exit if we are using the converged-timeout and we are the
+		// root node. otherwise, if we are a child node in a remote
+		// execution hierarchy, we should only notify our converged
+		// state and wait for the parent to trigger the exit.
+		if depth == 0 && c.Int("converged-timeout") >= 0 {
+			if b {
+				log.Printf("Converged for %d seconds, exiting!", c.Int("converged-timeout"))
+				exit <- nil // trigger an exit!
+			}
+			return nil
+		}
+		// send our individual state into etcd for others to see
+		return etcd.EtcdSetHostnameConverged(EmbdEtcd, hostname, b) // TODO: what should happen on error?
+	}
+	if EmbdEtcd != nil {
+		converger.SetStateFn(convergerStateFn)
 	}
 
-	log.Println("Running...")
+	exitchan := make(chan struct{}) // exit on close
+	go func() {
+		startchan := make(chan struct{}) // start signal
+		go func() { startchan <- struct{}{} }()
+		file := c.String("file")
+		var configchan chan error
+		var puppetchan <-chan time.Time
+		if !c.Bool("no-watch") && c.IsSet("file") {
+			configchan = recwatch.ConfigWatch(file)
+		} else if c.IsSet("puppet") {
+			interval := puppet.PuppetInterval(c.String("puppet-conf"))
+			puppetchan = time.Tick(time.Duration(interval) * time.Second)
+		}
+		log.Println("Etcd: Starting...")
+		etcdchan := etcd.EtcdWatch(EmbdEtcd)
+		first := true // first loop or not
+		for {
+			log.Println("Main: Waiting...")
+			select {
+			case <-startchan: // kick the loop once at start
+				// pass
 
-	waitForSignal(exit) // pass in exit channel to watch
+			case b := <-etcdchan:
+				if !b { // ignore the message
+					continue
+				}
+				// everything else passes through to cause a compile!
+
+			case <-puppetchan:
+				// nothing, just go on
+
+			case e := <-configchan:
+				if c.Bool("no-watch") {
+					continue // not ready to read config
+				}
+				if e != nil {
+					exit <- e // trigger exit
+					continue
+					//return // TODO: return or wait for exitchan?
+				}
+			// XXX: case compile_event: ...
+			// ...
+			case <-exitchan:
+				return
+			}
+
+			var config *gconfig.GraphConfig
+			if c.IsSet("file") {
+				config = gconfig.ParseConfigFromFile(file)
+			} else if c.IsSet("puppet") {
+				config = puppet.ParseConfigFromPuppet(c.String("puppet"), c.String("puppet-conf"))
+			}
+			if config == nil {
+				log.Printf("Config: Parse failure")
+				continue
+			}
+
+			if config.Hostname != "" && config.Hostname != hostname {
+				log.Printf("Config: Hostname changed, ignoring config!")
+				continue
+			}
+			config.Hostname = hostname // set it in case it was ""
+
+			// run graph vertex LOCK...
+			if !first { // TODO: we can flatten this check out I think
+				converger.Pause() // FIXME: add sync wait?
+				G.Pause()         // sync
+			}
+
+			// build graph from yaml file on events (eg: from etcd)
+			// we need the vertices to be paused to work on them
+			if newFullgraph, err := config.NewGraphFromConfig(fullGraph, EmbdEtcd, noop); err == nil { // keep references to all original elements
+				fullGraph = newFullgraph
+			} else {
+				log.Printf("Config: Error making new graph from config: %v", err)
+				// unpause!
+				if !first {
+					G.Start(&wg, first) // sync
+					converger.Start()   // after G.Start()
+				}
+				continue
+			}
+
+			G = fullGraph.Copy() // copy to active graph
+			// XXX: do etcd transaction out here...
+			G.AutoEdges() // add autoedges; modifies the graph
+			G.AutoGroup() // run autogroup; modifies the graph
+			// TODO: do we want to do a transitive reduction?
+
+			log.Printf("Graph: %v", G) // show graph
+			err := G.ExecGraphviz(c.String("graphviz-filter"), c.String("graphviz"))
+			if err != nil {
+				log.Printf("Graphviz: %v", err)
+			} else {
+				log.Printf("Graphviz: Successfully generated graph!")
+			}
+			G.AssociateData(converger)
+			// G.Start(...) needs to be synchronous or wait,
+			// because if half of the nodes are started and
+			// some are not ready yet and the EtcdWatch
+			// loops, we'll cause G.Pause(...) before we
+			// even got going, thus causing nil pointer errors
+			G.Start(&wg, first) // sync
+			converger.Start()   // after G.Start()
+			first = false
+		}
+	}()
+
+	configWatcher := recwatch.NewConfigWatcher()
+	events := configWatcher.Events()
+	if !c.Bool("no-watch") {
+		configWatcher.Add(c.StringSlice("remote")...) // add all the files...
+	} else {
+		events = nil // signal that no-watch is true
+	}
+	go func() {
+		select {
+		case err := <-configWatcher.Error():
+			exit <- err // trigger an exit!
+
+		case <-exitchan:
+			return
+		}
+	}()
+
+	// initialize the add watcher, which calls the f callback on map changes
+	convergerCb := func(f func(map[string]bool) error) (func(), error) {
+		return etcd.EtcdAddHostnameConvergedWatcher(EmbdEtcd, f)
+	}
+
+	// build remotes struct for remote ssh
+	remotes := remote.NewRemotes(
+		EmbdEtcd.LocalhostClientURLs().StringSlice(),
+		[]string{etcd.DefaultClientURL},
+		noop,
+		c.StringSlice("remote"), // list of files
+		events,                  // watch for file changes
+		cConns,
+		c.Bool("allow-interactive"),
+		c.String("ssh-priv-id-rsa"),
+		!c.Bool("no-caching"),
+		depth,
+		prefix,
+		converger,
+		convergerCb,
+		program,
+	)
+
+	// TODO: is there any benefit to running the remotes above in the loop?
+	// wait for etcd to be running before we remote in, which we do above!
+	go remotes.Run()
+
+	if !c.IsSet("file") && !c.IsSet("puppet") {
+		converger.Start() // better start this for empty graphs
+	}
+	log.Println("Main: Running...")
+
+	err = waitForSignal(exit) // pass in exit channel to watch
+
+	log.Println("Destroy...")
+
+	configWatcher.Close() // stop sending file changes to remotes
+	remotes.Exit()        // tell all the remote connections to shutdown; waits!
 
 	G.Exit() // tell all the children to exit
 
-	if DEBUG {
+	// tell inner main loop to exit
-		for i := range G.GetVerticesChan() {
+	close(exitchan)
-			fmt.Printf("Vertex: %v\n", i)
+
-		}
+	// cleanup etcd main loop last so it can process everything first
-		fmt.Printf("Graph: %v\n", G)
+	if err := EmbdEtcd.Destroy(); err != nil { // shutdown and cleanup etcd
+		log.Printf("Etcd exited poorly with: %v", err)
+	}
+
+	if global.DEBUG {
+		log.Printf("Graph: %v", G)
 	}
 
 	wg.Wait() // wait for primary go routines to exit
 
 	// TODO: wait for each vertex to exit...
 	log.Println("Goodbye!")
+	return err
 }
 
 func main() {
+	var flags int
+	if global.DEBUG || true { // TODO: remove || true
+		flags = log.LstdFlags | log.Lshortfile
+	}
+	flags = (flags - log.Ldate) // remove the date for now
+	log.SetFlags(flags)
+
+	// un-hijack from capnslog...
+	log.SetOutput(os.Stderr)
+	if global.VERBOSE {
+		capnslog.SetFormatter(capnslog.NewLogFormatter(os.Stderr, "(etcd) ", flags))
+	} else {
+		capnslog.SetFormatter(capnslog.NewNilFormatter())
+	}
+
+	// test for sanity
+	if program == "" || version == "" {
+		log.Fatal("Program was not compiled correctly. Please see Makefile.")
+	}
 	app := cli.NewApp()
 	app.Name = program
 	app.Usage = "next generation config management"
@@ -130,14 +455,136 @@ func main() {
 			Action:  run,
 			Flags: []cli.Flag{
 				cli.StringFlag{
-					Name:  "file, f",
+					Name:   "file, f",
+					Value:  "",
+					Usage:  "graph definition to run",
+					EnvVar: "MGMT_FILE",
+				},
+				cli.BoolFlag{
+					Name:  "no-watch",
+					Usage: "do not update graph on watched graph definition file changes",
+				},
+				cli.StringFlag{
+					Name:  "code, c",
 					Value: "",
-					Usage: "graph definition to run",
+					Usage: "code definition to run",
+				},
+				cli.StringFlag{
+					Name:  "graphviz, g",
+					Value: "",
+					Usage: "output file for graphviz data",
+				},
+				cli.StringFlag{
+					Name:  "graphviz-filter, gf",
+					Value: "dot", // directed graph default
+					Usage: "graphviz filter to use",
+				},
+				// useful for testing multiple instances on same machine
+				cli.StringFlag{
+					Name:  "hostname",
+					Value: "",
+					Usage: "hostname to use",
+				},
+				// if empty, it will startup a new server
+				cli.StringSliceFlag{
+					Name:   "seeds, s",
+					Value:  &cli.StringSlice{}, // empty slice
+					Usage:  "default etc client endpoint",
+					EnvVar: "MGMT_SEEDS",
+				},
+				// port 2379 and 4001 are common
+				cli.StringSliceFlag{
+					Name:   "client-urls",
+					Value:  &cli.StringSlice{},
+					Usage:  "list of URLs to listen on for client traffic",
+					EnvVar: "MGMT_CLIENT_URLS",
+				},
+				// port 2380 and 7001 are common
+				cli.StringSliceFlag{
+					Name:   "server-urls, peer-urls",
+					Value:  &cli.StringSlice{},
+					Usage:  "list of URLs to listen on for server (peer) traffic",
+					EnvVar: "MGMT_SERVER_URLS",
+				},
+				cli.BoolFlag{
+					Name:  "no-server",
+					Usage: "do not let other servers peer with me",
 				},
 				cli.IntFlag{
-					Name:  "exittime",
+					Name:   "ideal-cluster-size",
-					Value: 0,
+					Value:  etcd.DefaultIdealClusterSize,
-					Usage: "exit after a maximum of approximately this many seconds",
+					Usage:  "ideal number of server peers in cluster, only read by initial server",
+					EnvVar: "MGMT_IDEAL_CLUSTER_SIZE",
+				},
+				cli.IntFlag{
+					Name:   "converged-timeout, t",
+					Value:  -1,
+					Usage:  "exit after approximately this many seconds in a converged state",
+					EnvVar: "MGMT_CONVERGED_TIMEOUT",
+				},
+				cli.IntFlag{
+					Name:   "max-runtime",
+					Value:  0,
+					Usage:  "exit after a maximum of approximately this many seconds",
+					EnvVar: "MGMT_MAX_RUNTIME",
+				},
+				cli.BoolFlag{
+					Name:  "noop",
+					Usage: "globally force all resources into no-op mode",
+				},
+				cli.StringFlag{
+					Name:  "puppet, p",
+					Value: "",
+					Usage: "load graph from puppet, optionally takes a manifest or path to manifest file",
+				},
+				cli.StringFlag{
+					Name:  "puppet-conf",
+					Value: "",
+					Usage: "supply the path to an alternate puppet.conf file to use",
+				},
+				cli.StringSliceFlag{
+					Name:  "remote",
+					Value: &cli.StringSlice{},
+					Usage: "list of remote graph definitions to run",
+				},
+				cli.BoolFlag{
+					Name:  "allow-interactive",
+					Usage: "allow interactive prompting, such as for remote passwords",
+				},
+				cli.StringFlag{
+					Name:   "ssh-priv-id-rsa",
+					Value:  "~/.ssh/id_rsa",
+					Usage:  "default path to ssh key file, set empty to never touch",
+					EnvVar: "MGMT_SSH_PRIV_ID_RSA",
+				},
+				cli.IntFlag{
+					Name:   "cconns",
+					Value:  0,
+					Usage:  "number of maximum concurrent remote ssh connections to run, 0 for unlimited",
+					EnvVar: "MGMT_CCONNS",
+				},
+				cli.BoolFlag{
+					Name:  "no-caching",
+					Usage: "don't allow remote caching of remote execution binary",
+				},
+				cli.IntFlag{
+					Name:   "depth",
+					Hidden: true, // internal use only
+					Value:  0,
+					Usage:  "specify depth in remote hierarchy",
+				},
+				cli.StringFlag{
+					Name:   "prefix",
+					Usage:  "specify a path to the working prefix directory",
+					EnvVar: "MGMT_PREFIX",
+				},
+				cli.BoolFlag{
+					Name:  "tmp-prefix",
+					Usage: "request a pseudo-random, temporary prefix to be used",
+				},
+				cli.BoolFlag{
+					Name:  "allow-tmp-prefix",
+					Usage: "allow creation of a new temporary prefix if main prefix is unavailable",
 				},
 			},
 		},

main_test.go

@@ -1,5 +1,5 @@
 // Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
 // Written by James Shubin <james@shubin.ca> and the project contributors
 //
 // This program is free software: you can redistribute it and/or modify

misc.go

@@ -1,57 +0,0 @@
-// Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
-// Written by James Shubin <james@shubin.ca> and the project contributors
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"path"
-	"strings"
-)
-
-// Similar to the GNU dirname command
-func Dirname(p string) string {
-	d, _ := path.Split(path.Clean(p))
-	return d
-}
-
-// Split a path into an array of tokens excluding any trailing empty tokens
-func PathSplit(p string) []string {
-	return strings.Split(path.Clean(p), "/")
-}
-
-// Does path string contain the given path prefix in it?
-func HasPathPrefix(p, prefix string) bool {
-
-	patharray := PathSplit(p)
-	prefixarray := PathSplit(prefix)
-
-	if len(prefixarray) > len(patharray) {
-		return false
-	}
-
-	for i := 0; i < len(prefixarray); i++ {
-		if prefixarray[i] != patharray[i] {
-			return false
-		}
-	}
-
-	return true
-}
-
-func PathIsDir(p string) bool {
-	return p[len(p)-1:] == "/" // a dir has a trailing slash in this context
-}

misc/bashrc.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+_cli_bash_autocomplete_mgmt() {
+	local cur prev opts base
+	COMPREPLY=()
+	cur="${COMP_WORDS[COMP_CWORD]}"
+	prev="${COMP_WORDS[COMP_CWORD-1]}"
+	opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
+	COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+	return 0
+}
+
+complete -F _cli_bash_autocomplete_mgmt mgmt

misc/centos-ci.py

@@ -0,0 +1,72 @@
+#!/usr/bin/python
+
+# modified from:
+# https://github.com/kbsingh/centos-ci-scripts/blob/master/build_python_script.py
+# usage: centos-ci.py giturl [branch [commands]]
+
+import os
+import sys
+import json
+import urllib
+import subprocess
+
+# static argv to be used if running script inline
+argv = [
+	#'https://github.com/purpleidea/mgmt', # giturl
+	#'master',
+	#'make test',
+]
+argv.insert(0, '') # add a fake argv[0]
+url_base = 'http://admin.ci.centos.org:8080'
+apikey = '' # put api key here if running inline
+if apikey == '':
+	apikey = os.environ.get('DUFFY_API_KEY')
+if apikey is None or apikey == '':
+	apikey = open('duffy.key', 'r').read().strip()
+ver = '7'
+arch = 'x86_64'
+count = 1
+
+if len(argv) <= 1: argv = sys.argv # use system argv because ours is empty
+if len(argv) <= 1:
+	print 'Not enough arguments supplied!'
+	sys.exit(1)
+
+git_url = argv[1]
+branch = 'master'
+if len(argv) > 2: branch = argv[2]
+folder = os.path.basename(git_url)	# should be project name
+run = 'make vtest' # the omv vtest cmd is a good option to run from this target
+if len(argv) > 3: run = ' '.join(argv[3:])
+
+get_nodes_url = "%s/Node/get?key=%s&ver=%s&arch=%s&i_count=%s" % (url_base, apikey, ver, arch, count)
+data = json.loads(urllib.urlopen(get_nodes_url).read()) # request host(s)
+hosts = data['hosts']
+ssid = data['ssid']
+done_nodes_url = "%s/Node/done?key=%s&ssid=%s" % (url_base, apikey, ssid)
+
+host = hosts[0]
+ssh = "ssh -tt -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o SendEnv=JENKINS_URL root@%s" % host
+yum = 'yum -y install git wget tree psmisc'
+omv = 'wget https://github.com/purpleidea/oh-my-vagrant/raw/master/extras/install-omv.sh && chmod u+x install-omv.sh && ./install-omv.sh && wget https://github.com/purpleidea/mgmt/raw/master/misc/make-path.sh && chmod u+x make-path.sh && ./make-path.sh'
+cmd = "%s '%s && %s'" % (ssh, yum, omv) # setup
+print cmd
+r = subprocess.call(cmd, shell=True)
+if r != 0:
+	# NOTE: we don't clean up the host here, so that it can be inspected!
+	print "Error configuring omv on: %s" % host
+	sys.exit(r)
+
+# the second ssh call will run with the omv /etc/profile.d/ script loaded
+git = "git clone --recursive %s %s && cd %s && git checkout %s" % (git_url, folder, folder, branch)
+cmd = "%s 'export JENKINS_URL=%s && %s && %s'" % (ssh, os.getenv('JENKINS_URL', ''), git, run) # run
+print cmd
+r = subprocess.call(cmd, shell=True)
+if r != 0:
+	print "Error running job on: %s" % host
+
+output = urllib.urlopen(done_nodes_url).read() # free host(s)
+if output != 'Done':
+	print "Error freeing host: %s" % host
+
+sys.exit(r)

misc/copr-build.py

@@ -0,0 +1,66 @@
+#!/usr/bin/python
+
+# README:
+# for initial setup, browse to: https://copr.fedoraproject.org/api/
+# and it will have a ~/.config/copr config that you can download.
+# happy hacking!
+
+import os
+import sys
+import copr
+import time
+
+COPR = 'mgmt'
+
+if len(sys.argv) != 2:
+	print("Usage: %s <srpm url>" % sys.argv[0])
+	sys.exit(1)
+
+url = sys.argv[1]
+
+client = copr.CoprClient.create_from_file_config(os.path.expanduser("~/.config/copr"))
+
+result = client.create_new_build(COPR, [url])
+if result.output != 'ok':
+	print(result.error)
+	sys.exit(1)
+print(result.message)
+
+# modified from: https://python-copr.readthedocs.org/en/latest/Examples.html#work-with-builds
+for bw in result.builds_list:
+	print("Build #{}: {}".format(bw.build_id, bw.handle.get_build_details().status))
+
+# cancel all created build
+#for bw in result.builds_list:
+#	bw.handle.cancel_build()
+
+# get build status for each chroot
+#for bw in result.builds_list:
+#	print("build: {}".format(bw.build_id))
+#	for ch, status in bw.handle.get_build_details().data["chroots"].items():
+#		print("\t chroot {}:\t {}".format(ch, status))
+
+# simple build progress:
+
+watched = set(result.builds_list)
+done = set()
+state = {}
+for bw in watched:	# store initial states
+	state[bw.build_id] = bw.handle.get_build_details().status
+
+while watched != done:
+	for bw in watched:
+		if bw in done:
+			continue
+		status = bw.handle.get_build_details().status
+		if status != state.get(bw.build_id):
+			print("Build #{}: {}".format(bw.build_id, status))
+			state[bw.build_id] = status	# update status
+
+		if status in ['skipped', 'failed', 'succeeded']:
+			done.add(bw)
+
+	if watched == done: break	# avoid long while sleep
+	else: time.sleep(10)
+
+print 'Done!'

misc/example.conf

@@ -0,0 +1 @@
+# example mgmt configuration file, currently has no options at the moment!

misc/go

@@ -0,0 +1,15 @@
+#!/bin/bash
+# hack around stupid $GOPATH semantics, with ~/bin/go helper
+# thanks to Nilium in #go-nuts for 1/3 of the idea
+[ -z "$GOPATH" ] && echo '$GOPATH is not set!' && exit 1
+GO="$(which -a go | sed -e '2q;d')"	# TODO: pick /usr/bin/go in a better way
+if [ "$1" = "generate" ]; then
+	exec $GO "$@"	# go generate is stupid and gets confused by $GOPATH
+fi
+# the idea is to have $project/gopath/src/ be a symlink to ../vendor but you put
+# all of your vendored things in vendor/ but with this gopath can be per project
+if [ -d "$PWD/vendor/" ] && [ -d "$PWD/gopath/" ] && [ "`readlink $PWD/gopath/src`" = "../vendor" ] ; then
+	GOPATH="$PWD/gopath/:$GOPATH" $GO "$@"
+else
+	$GO "$@"
+fi

misc/make-deps.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# setup a simple go environment
+XPWD=`pwd`
+ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && cd .. && pwd )"	# dir!
+cd "${ROOT}" >/dev/null
+
+travis=0
+if env | grep -q '^TRAVIS=true$'; then
+	travis=1
+fi
+
+sudo_command=$(which sudo)
+
+if [ $travis -eq 0 ]; then
+	YUM=`which yum 2>/dev/null`
+	APT=`which apt-get 2>/dev/null`
+	if [ -z "$YUM" -a -z "$APT" ]; then
+		echo "The package managers can't be found."
+		exit 1
+	fi
+	if [ ! -z "$YUM" ]; then
+		# some go dependencies are stored in mercurial
+		$sudo_command $YUM install -y golang golang-googlecode-tools-stringer hg
+
+	fi
+	if [ ! -z "$APT" ]; then
+		$sudo_command $APT update
+		$sudo_command $APT install -y golang make gcc packagekit mercurial
+		# one of these two golang tools packages should work on debian
+		$sudo_command $APT install -y golang-golang-x-tools || true
+		$sudo_command $APT install -y golang-go.tools || true
+		$sudo_command $APT install -y libpcap0.8-dev || true
+	fi
+fi
+
+# if golang is too old, we don't want to fail with an obscure error later
+if go version | grep 'go1\.[0123]\.'; then
+	echo "mgmt requires go1.4 or higher."
+	exit 1
+fi
+
+go get ./...	# get all the go dependencies
+[ -e "$GOBIN/mgmt" ] && rm -f "$GOBIN/mgmt"	# the `go get` version has no -X
+# vet is built-in in go 1.6 - we check for go vet command
+go vet 1> /dev/null 2>&1
+ret=$?
+if [[ $ret != 0 ]]; then
+	go get golang.org/x/tools/cmd/vet      # add in `go vet` for travis
+fi
+go get golang.org/x/tools/cmd/stringer	# for automatic stringer-ing
+go get github.com/golang/lint/golint	# for `golint`-ing
+cd "$XPWD" >/dev/null

misc/make-path.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# setup a few environment path values
+
+if ! env | grep -q '^GOPATH='; then
+	export GOPATH="$HOME/gopath/"
+	mkdir "$GOPATH"
+	if ! grep -q '^export GOPATH=' ~/.bashrc; then
+	        echo "export GOPATH=~/gopath/" >> ~/.bashrc
+	fi
+	echo "setting go path to: $GOPATH"
+fi
+
+echo "gopath is: $GOPATH"
+
+# some versions of golang apparently require this to run go get :(
+if ! env | grep -q '^GOBIN='; then
+	export GOBIN="${GOPATH}bin/"
+	mkdir "$GOBIN"
+	if ! grep -q '^export GOBIN=' ~/.bashrc; then
+	        echo 'export GOBIN="${GOPATH}bin/"' >> ~/.bashrc
+	fi
+	echo "setting go bin to: $GOBIN"
+fi
+
+echo "gobin is: $GOBIN"
+
+# add gobin to $PATH
+if ! env | grep '^PATH=' | grep -q "$GOBIN"; then
+	if ! grep -q '^export PATH="'"${GOBIN}"':${PATH}"' ~/.bashrc; then
+	        echo 'export PATH="'"${GOBIN}"':${PATH}"' >> ~/.bashrc
+	fi
+	export PATH="${GOBIN}:${PATH}"
+	echo "setting path to: $PATH"
+fi
+
+echo "path is: $PATH"
+
+# add ~/bin/ to $PATH
+if ! env | grep '^PATH=' | grep -q "$HOME/bin"; then
+	mkdir -p "${HOME}/bin"
+	if ! grep -q '^export PATH="'"${HOME}/bin"':${PATH}"' ~/.bashrc; then
+	        echo 'export PATH="'"${HOME}/bin"':${PATH}"' >> ~/.bashrc
+	fi
+	export PATH="${HOME}/bin:${PATH}"
+	echo "setting path to: $PATH"
+fi
+
+echo "path is: $PATH"

misc/mgmt.service

@@ -0,0 +1,13 @@
+[Unit]
+Description=Run mgmt configuration management
+Documentation=https://github.com/purpleidea/mgmt/
+After=systemd-networkd.service
+Requires=systemd-networkd.service
+
+[Service]
+ExecStart=/usr/bin/mgmt run ${OPTS}
+RestartSec=5s
+Restart=always
+
+[Install]
+WantedBy=multi-user.target

misc_test.go

@@ -1,101 +0,0 @@
-// Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
-// Written by James Shubin <james@shubin.ca> and the project contributors
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"testing"
-)
-
-func TestMiscT1(t *testing.T) {
-
-	if Dirname("/foo/bar/baz") != "/foo/bar/" {
-		t.Errorf("Result is incorrect.")
-	}
-
-	if Dirname("/foo/bar/baz/") != "/foo/bar/" {
-		t.Errorf("Result is incorrect.")
-	}
-
-	if Dirname("/") != "/" {
-		t.Errorf("Result is incorrect.")
-	}
-}
-
-func TestMiscT2(t *testing.T) {
-
-	// TODO: compare the output with the actual list
-	p1 := "/foo/bar/baz"
-	r1 := []string{"", "foo", "bar", "baz"}
-	if len(PathSplit(p1)) != len(r1) {
-		//t.Errorf("Result should be: %q.", r1)
-		t.Errorf("Result should have a length of: %v.", len(r1))
-	}
-
-	p2 := "/foo/bar/baz/"
-	r2 := []string{"", "foo", "bar", "baz"}
-	if len(PathSplit(p2)) != len(r2) {
-		t.Errorf("Result should have a length of: %v.", len(r2))
-	}
-}
-
-func TestMiscT3(t *testing.T) {
-
-	if HasPathPrefix("/foo/bar/baz", "/foo/ba") != false {
-		t.Errorf("Result should be false.")
-	}
-
-	if HasPathPrefix("/foo/bar/baz", "/foo/bar") != true {
-		t.Errorf("Result should be true.")
-	}
-
-	if HasPathPrefix("/foo/bar/baz", "/foo/bar/") != true {
-		t.Errorf("Result should be true.")
-	}
-
-	if HasPathPrefix("/foo/bar/baz/", "/foo/bar") != true {
-		t.Errorf("Result should be true.")
-	}
-
-	if HasPathPrefix("/foo/bar/baz/", "/foo/bar/") != true {
-		t.Errorf("Result should be true.")
-	}
-
-	if HasPathPrefix("/foo/bar/baz/", "/foo/bar/baz/dude") != false {
-		t.Errorf("Result should be false.")
-	}
-}
-
-func TestMiscT4(t *testing.T) {
-
-	if PathIsDir("/foo/bar/baz/") != true {
-		t.Errorf("Result should be false.")
-	}
-
-	if PathIsDir("/foo/bar/baz") != false {
-		t.Errorf("Result should be false.")
-	}
-
-	if PathIsDir("/foo/") != true {
-		t.Errorf("Result should be true.")
-	}
-
-	if PathIsDir("/") != true {
-		t.Errorf("Result should be true.")
-	}
-
-}

omv.yaml

@@ -0,0 +1,39 @@
+---
+:domain: example.com
+:network: 192.168.123.0/24
+:image: fedora-23
+:cpus: ''
+:memory: ''
+:disks: 0
+:disksize: 40G
+:boxurlprefix: ''
+:sync: rsync
+:syncdir: mgmt/
+:syncsrc: "../"
+:folder: ".omv"
+:extern: []
+:cd: "-"
+:puppet: false
+:classes: []
+:shell:
+- cd /vagrant/mgmt/ && make deps
+:docker: false
+:kubernetes: false
+:ansible: []
+:playbook: []
+:ansible_extras: {}
+:cachier: false
+:vms: []
+:namespace: omv
+:count: 1
+:username: ''
+:password: ''
+:poolid: true
+:repos: []
+:update: false
+:reboot: false
+:unsafe: false
+:nested: false
+:tests: []
+:comment: ''
+:reallyrm: false

pgraph.go

@@ -1,414 +0,0 @@
-// Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
-// Written by James Shubin <james@shubin.ca> and the project contributors
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-// Pgraph (Pointer Graph)
-package main
-
-import (
-	"code.google.com/p/go-uuid/uuid"
-	//"container/list" // doubly linked list
-	"fmt"
-	"log"
-	"sync"
-	"time"
-)
-
-// The graph abstract data type (ADT) is defined as follows:
-// NOTE: the directed graph arrows point from left to right ( --> )
-// NOTE: the arrows point towards their dependencies (eg: arrows mean requires)
-type Graph struct {
-	uuid      string
-	Name      string
-	Adjacency map[*Vertex]map[*Vertex]*Edge
-	//Directed  bool
-	startcount int
-}
-
-type Vertex struct {
-	uuid      string
-	graph     *Graph // store a pointer to the graph it's on
-	Name      string
-	Type      string
-	Timestamp int64       // last updated timestamp ?
-	Events    chan string // FIXME: eventually a struct for the event?
-	Typedata  Type
-	data      map[string]string
-}
-
-type Edge struct {
-	uuid string
-	Name string
-}
-
-func NewGraph(name string) *Graph {
-	return &Graph{
-		uuid:      uuid.New(),
-		Name:      name,
-		Adjacency: make(map[*Vertex]map[*Vertex]*Edge),
-	}
-}
-
-func NewVertex(name, t string) *Vertex {
-	return &Vertex{
-		uuid:      uuid.New(),
-		Name:      name,
-		Type:      t,
-		Timestamp: -1,
-		Events:    make(chan string, 1), // XXX: chan size?
-		data:      make(map[string]string),
-	}
-}
-
-func NewEdge(name string) *Edge {
-	return &Edge{
-		uuid: uuid.New(),
-		Name: name,
-	}
-}
-
-// Graph() creates a new, empty graph.
-// addVertex(vert) adds an instance of Vertex to the graph.
-func (g *Graph) AddVertex(v *Vertex) {
-	if _, exists := g.Adjacency[v]; !exists {
-		g.Adjacency[v] = make(map[*Vertex]*Edge)
-
-		// store a pointer to the graph it's on for convenience and readability
-		v.graph = g
-	}
-}
-
-// addEdge(fromVert, toVert) Adds a new, directed edge to the graph that connects two vertices.
-func (g *Graph) AddEdge(v1, v2 *Vertex, e *Edge) {
-	// NOTE: this doesn't allow more than one edge between two vertexes...
-	// TODO: is this a problem?
-	g.AddVertex(v1)
-	g.AddVertex(v2)
-	g.Adjacency[v1][v2] = e
-}
-
-// addEdge(fromVert, toVert, weight) Adds a new, weighted, directed edge to the graph that connects two vertices.
-// getVertex(vertKey) finds the vertex in the graph named vertKey.
-func (g *Graph) GetVertex(uuid string) chan *Vertex {
-	ch := make(chan *Vertex, 1)
-	go func(uuid string) {
-		for k := range g.Adjacency {
-			v := *k
-			if v.uuid == uuid {
-				ch <- k
-				break
-			}
-		}
-		close(ch)
-	}(uuid)
-	return ch
-}
-
-func (g *Graph) NumVertices() int {
-	return len(g.Adjacency)
-}
-
-func (g *Graph) NumEdges() int {
-	// XXX: not implemented
-	return -1
-}
-
-// get an array (slice) of all vertices in the graph
-func (g *Graph) GetVertices() []*Vertex {
-	vertices := make([]*Vertex, 0)
-	for k := range g.Adjacency {
-		vertices = append(vertices, k)
-	}
-	return vertices
-}
-
-// returns a channel of all vertices in the graph
-func (g *Graph) GetVerticesChan() chan *Vertex {
-	ch := make(chan *Vertex)
-	// TODO: do you need to pass this through into the go routine?
-	go func(ch chan *Vertex) {
-		for k := range g.Adjacency {
-			ch <- k
-		}
-		close(ch)
-	}(ch)
-	return ch
-}
-
-// make the graph pretty print
-func (g *Graph) String() string {
-	return fmt.Sprintf("Vertices(%d), Edges(%d)", g.NumVertices(), g.NumEdges())
-}
-
-//func (s []*Vertex) contains(element *Vertex) bool {
-// google/golang hackers apparently do not think contains should be a built-in!
-func Contains(s []*Vertex, element *Vertex) bool {
-	for _, v := range s {
-		if element == v {
-			return true
-		}
-	}
-	return false
-}
-
-// return an array (slice) of all vertices that connect to vertex v
-func (g *Graph) GraphEdges(vertex *Vertex) []*Vertex {
-	// TODO: we might be able to implement this differently by reversing
-	// the Adjacency graph and then looping through it again...
-	s := make([]*Vertex, 0)                 // stack
-	for w, _ := range g.Adjacency[vertex] { // forward paths
-		//fmt.Printf("forward: %v -> %v\n", v.Name, w.Name)
-		s = append(s, w)
-	}
-
-	for k, x := range g.Adjacency { // reverse paths
-		for w, _ := range x {
-			if w == vertex {
-				//fmt.Printf("reverse: %v -> %v\n", v.Name, k.Name)
-				s = append(s, k)
-			}
-		}
-	}
-	return s
-}
-
-// return an array (slice) of all directed vertices to vertex v
-func (g *Graph) DirectedGraphEdges(vertex *Vertex) []*Vertex {
-	// TODO: we might be able to implement this differently by reversing
-	// the Adjacency graph and then looping through it again...
-	s := make([]*Vertex, 0)                 // stack
-	for w, _ := range g.Adjacency[vertex] { // forward paths
-		//fmt.Printf("forward: %v -> %v\n", v.Name, w.Name)
-		s = append(s, w)
-	}
-	return s
-}
-
-// get timestamp of a vertex
-func (v *Vertex) GetTimestamp() int64 {
-	return v.Timestamp
-}
-
-// update timestamp of a vertex
-func (v *Vertex) UpdateTimestamp() int64 {
-	v.Timestamp = time.Now().UnixNano() // update
-	return v.Timestamp
-}
-
-func (g *Graph) DFS(start *Vertex) []*Vertex {
-	d := make([]*Vertex, 0) // discovered
-	s := make([]*Vertex, 0) // stack
-	if _, exists := g.Adjacency[start]; !exists {
-		return nil // TODO: error
-	}
-	v := start
-	s = append(s, v)
-	for len(s) > 0 {
-
-		v, s = s[len(s)-1], s[:len(s)-1] // s.pop()
-
-		if !Contains(d, v) { // if not discovered
-			d = append(d, v) // label as discovered
-
-			for _, w := range g.GraphEdges(v) {
-				s = append(s, w)
-			}
-		}
-	}
-	return d
-}
-
-// build a new graph containing only vertices from the list...
-func (g *Graph) FilterGraph(name string, vertices []*Vertex) *Graph {
-	newgraph := NewGraph(name)
-
-	for k1, x := range g.Adjacency {
-		for k2, e := range x {
-
-			//fmt.Printf("Filter: %v -> %v # %v\n", k1.Name, k2.Name, e.Name)
-			if Contains(vertices, k1) || Contains(vertices, k2) {
-				newgraph.AddEdge(k1, k2, e)
-			}
-		}
-	}
-
-	return newgraph
-}
-
-// return a channel containing the N disconnected graphs in our main graph
-// we can then process each of these in parallel
-func (g *Graph) GetDisconnectedGraphs() chan *Graph {
-	ch := make(chan *Graph)
-	go func() {
-		var start *Vertex
-		d := make([]*Vertex, 0) // discovered
-		c := g.NumVertices()
-		for len(d) < c {
-
-			// get an undiscovered vertex to start from
-			for _, s := range g.GetVertices() {
-				if !Contains(d, s) {
-					start = s
-				}
-			}
-
-			// dfs through the graph
-			dfs := g.DFS(start)
-			// filter all the collected elements into a new graph
-			newgraph := g.FilterGraph(g.Name, dfs)
-
-			// add number of elements found to found variable
-			d = append(d, dfs...) // extend
-
-			// return this new graph to the channel
-			ch <- newgraph
-
-			// if we've found all the elements, then we're done
-			// otherwise loop through to continue...
-		}
-
-		close(ch)
-	}()
-	return ch
-}
-
-func (v *Vertex) Value(key string) (string, bool) {
-	if value, exists := v.data[key]; exists {
-		return value, true
-	}
-	return "", false
-}
-
-func (v *Vertex) SetValue(key, value string) bool {
-	v.data[key] = value
-	return true
-}
-
-func (g *Graph) GetVerticesKeyValue(key, value string) chan *Vertex {
-	ch := make(chan *Vertex)
-	go func() {
-		for vertex := range g.GetVerticesChan() {
-			if v, exists := vertex.Value(key); exists && v == value {
-				ch <- vertex
-			}
-		}
-		close(ch)
-	}()
-	return ch
-}
-
-// return a pointer to the graph a vertex is on
-func (v *Vertex) GetGraph() *Graph {
-	return v.graph
-}
-
-func HeisenbergCount(ch chan *Vertex) int {
-	c := 0
-	for x := range ch {
-		_ = x
-		c++
-	}
-	return c
-}
-
-func (v *Vertex) Associate(t Type) {
-	v.Typedata = t
-}
-
-func (v *Vertex) OKTimestamp() bool {
-	g := v.GetGraph()
-	for _, n := range g.DirectedGraphEdges(v) {
-		if v.GetTimestamp() > n.GetTimestamp() {
-			return false
-		}
-	}
-
-	return true
-}
-
-// poke the XXX children?
-func (v *Vertex) Poke() {
-	g := v.GetGraph()
-
-	for _, n := range g.DirectedGraphEdges(v) { // XXX: do we want the reverse order?
-		// poke!
-		n.Events <- fmt.Sprintf("poke(%v)", v.Name)
-	}
-}
-
-func (g *Graph) Exit() {
-	// tell all the vertices to exit...
-	for v := range g.GetVerticesChan() {
-		v.Exit()
-	}
-}
-
-func (v *Vertex) Exit() {
-	v.Events <- "exit"
-}
-
-// main loop for each vertex
-// warning: this logic might be subtle and tricky.
-// be careful as it might not even be correct now!
-func (v *Vertex) Start() {
-	log.Printf("Main->Vertex[%v]->Start()\n", v.Name)
-
-	//g := v.GetGraph()
-	var t = v.Typedata
-
-	// this whole wg2 wait group is only necessary if we need to wait for
-	// the go routine to exit...
-	var wg2 sync.WaitGroup
-
-	wg2.Add(1)
-	go func(v *Vertex, t Type) {
-		defer wg2.Done()
-		//fmt.Printf("About to watch [%v].\n", v.Name)
-		t.Watch(v)
-	}(v, t)
-
-	var ok bool
-	//XXX make sure dependencies run and become more current first...
-	for {
-		select {
-		case event := <-v.Events:
-
-			log.Printf("Event[%v]: %v\n", v.Name, event)
-
-			if event == "exit" {
-				t.Exit()   // type exit
-				wg2.Wait() // wait for worker to exit
-				return
-			}
-
-			ok = true
-			if v.OKTimestamp() {
-				if !t.StateOK() { // TODO: can we rename this to something better?
-					// throw an error if apply fails...
-					// if this fails, don't UpdateTimestamp()
-					if !t.Apply() { // check for error
-						ok = false
-					}
-				}
-
-				if ok {
-					v.UpdateTimestamp() // this was touched...
-					v.Poke()            // XXX
-				}
-			}
-		}
-	}
-}

pgraph/autoedge.go

@@ -0,0 +1,104 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Package pgraph represents the internal "pointer graph" that we use.
+package pgraph
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/purpleidea/mgmt/global"
+	"github.com/purpleidea/mgmt/resources"
+)
+
+// add edges to the vertex in a graph based on if it matches a uuid list
+func (g *Graph) addEdgesByMatchingUUIDS(v *Vertex, uuids []resources.ResUUID) []bool {
+	// search for edges and see what matches!
+	var result []bool
+
+	// loop through each uuid, and see if it matches any vertex
+	for _, uuid := range uuids {
+		var found = false
+		// uuid is a ResUUID object
+		for _, vv := range g.GetVertices() { // search
+			if v == vv { // skip self
+				continue
+			}
+			if global.DEBUG {
+				log.Printf("Compile: AutoEdge: Match: %v[%v] with UUID: %v[%v]", vv.Kind(), vv.GetName(), uuid.Kind(), uuid.GetName())
+			}
+			// we must match to an effective UUID for the resource,
+			// that is to say, the name value of a res is a helpful
+			// handle, but it is not necessarily a unique identity!
+			// remember, resources can return multiple UUID's each!
+			if resources.UUIDExistsInUUIDs(uuid, vv.GetUUIDs()) {
+				// add edge from: vv -> v
+				if uuid.Reversed() {
+					txt := fmt.Sprintf("AutoEdge: %v[%v] -> %v[%v]", vv.Kind(), vv.GetName(), v.Kind(), v.GetName())
+					log.Printf("Compile: Adding %v", txt)
+					g.AddEdge(vv, v, NewEdge(txt))
+				} else { // edges go the "normal" way, eg: pkg resource
+					txt := fmt.Sprintf("AutoEdge: %v[%v] -> %v[%v]", v.Kind(), v.GetName(), vv.Kind(), vv.GetName())
+					log.Printf("Compile: Adding %v", txt)
+					g.AddEdge(v, vv, NewEdge(txt))
+				}
+				found = true
+				break
+			}
+		}
+		result = append(result, found)
+	}
+	return result
+}
+
+// AutoEdges adds the automatic edges to the graph.
+func (g *Graph) AutoEdges() {
+	log.Println("Compile: Adding AutoEdges...")
+	for _, v := range g.GetVertices() { // for each vertexes autoedges
+		if !v.Meta().AutoEdge { // is the metaparam true?
+			continue
+		}
+		autoEdgeObj := v.AutoEdges()
+		if autoEdgeObj == nil {
+			log.Printf("%v[%v]: Config: No auto edges were found!", v.Kind(), v.GetName())
+			continue // next vertex
+		}
+
+		for { // while the autoEdgeObj has more uuids to add...
+			uuids := autoEdgeObj.Next() // get some!
+			if uuids == nil {
+				log.Printf("%v[%v]: Config: The auto edge list is empty!", v.Kind(), v.GetName())
+				break // inner loop
+			}
+			if global.DEBUG {
+				log.Println("Compile: AutoEdge: UUIDS:")
+				for i, u := range uuids {
+					log.Printf("Compile: AutoEdge: UUID%d: %v", i, u)
+				}
+			}
+
+			// match and add edges
+			result := g.addEdgesByMatchingUUIDS(v, uuids)
+
+			// report back, and find out if we should continue
+			if !autoEdgeObj.Test(result) {
+				break
+			}
+		}
+	}
+}

pgraph/autogroup.go

@@ -0,0 +1,348 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package pgraph
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/purpleidea/mgmt/global"
+)
+
+// AutoGrouper is the required interface to implement for an autogroup algorithm
+type AutoGrouper interface {
+	// listed in the order these are typically called in...
+	name() string                                  // friendly identifier
+	init(*Graph) error                             // only call once
+	vertexNext() (*Vertex, *Vertex, error)         // mostly algorithmic
+	vertexCmp(*Vertex, *Vertex) error              // can we merge these ?
+	vertexMerge(*Vertex, *Vertex) (*Vertex, error) // vertex merge fn to use
+	edgeMerge(*Edge, *Edge) *Edge                  // edge merge fn to use
+	vertexTest(bool) (bool, error)                 // call until false
+}
+
+// baseGrouper is the base type for implementing the AutoGrouper interface
+type baseGrouper struct {
+	graph    *Graph    // store a pointer to the graph
+	vertices []*Vertex // cached list of vertices
+	i        int
+	j        int
+	done     bool
+}
+
+// name provides a friendly name for the logs to see
+func (ag *baseGrouper) name() string {
+	return "baseGrouper"
+}
+
+// init is called only once and before using other AutoGrouper interface methods
+// the name method is the only exception: call it any time without side effects!
+func (ag *baseGrouper) init(g *Graph) error {
+	if ag.graph != nil {
+		return fmt.Errorf("The init method has already been called!")
+	}
+	ag.graph = g                               // pointer
+	ag.vertices = ag.graph.GetVerticesSorted() // cache in deterministic order!
+	ag.i = 0
+	ag.j = 0
+	if len(ag.vertices) == 0 { // empty graph
+		ag.done = true
+		return nil
+	}
+	return nil
+}
+
+// vertexNext is a simple iterator that loops through vertex (pair) combinations
+// an intelligent algorithm would selectively offer only valid pairs of vertices
+// these should satisfy logical grouping requirements for the autogroup designs!
+// the desired algorithms can override, but keep this method as a base iterator!
+func (ag *baseGrouper) vertexNext() (v1, v2 *Vertex, err error) {
+	// this does a for v... { for w... { return v, w }} but stepwise!
+	l := len(ag.vertices)
+	if ag.i < l {
+		v1 = ag.vertices[ag.i]
+	}
+	if ag.j < l {
+		v2 = ag.vertices[ag.j]
+	}
+
+	// in case the vertex was deleted
+	if !ag.graph.HasVertex(v1) {
+		v1 = nil
+	}
+	if !ag.graph.HasVertex(v2) {
+		v2 = nil
+	}
+
+	// two nested loops...
+	if ag.j < l {
+		ag.j++
+	}
+	if ag.j == l {
+		ag.j = 0
+		if ag.i < l {
+			ag.i++
+		}
+		if ag.i == l {
+			ag.done = true
+		}
+	}
+
+	return
+}
+
+func (ag *baseGrouper) vertexCmp(v1, v2 *Vertex) error {
+	if v1 == nil || v2 == nil {
+		return fmt.Errorf("Vertex is nil!")
+	}
+	if v1 == v2 { // skip yourself
+		return fmt.Errorf("Vertices are the same!")
+	}
+	if v1.Kind() != v2.Kind() { // we must group similar kinds
+		// TODO: maybe future resources won't need this limitation?
+		return fmt.Errorf("The two resources aren't the same kind!")
+	}
+	// someone doesn't want to group!
+	if !v1.Meta().AutoGroup || !v2.Meta().AutoGroup {
+		return fmt.Errorf("One of the autogroup flags is false!")
+	}
+	if v1.Res.IsGrouped() { // already grouped!
+		return fmt.Errorf("Already grouped!")
+	}
+	if len(v2.Res.GetGroup()) > 0 { // already has children grouped!
+		return fmt.Errorf("Already has groups!")
+	}
+	if !v1.Res.GroupCmp(v2.Res) { // resource groupcmp failed!
+		return fmt.Errorf("The GroupCmp failed!")
+	}
+	return nil // success
+}
+
+func (ag *baseGrouper) vertexMerge(v1, v2 *Vertex) (v *Vertex, err error) {
+	// NOTE: it's important to use w.Res instead of w, b/c
+	// the w by itself is the *Vertex obj, not the *Res obj
+	// which is contained within it! They both satisfy the
+	// Res interface, which is why both will compile! :(
+	err = v1.Res.GroupRes(v2.Res) // GroupRes skips stupid groupings
+	return                        // success or fail, and no need to merge the actual vertices!
+}
+
+func (ag *baseGrouper) edgeMerge(e1, e2 *Edge) *Edge {
+	return e1 // noop
+}
+
+// vertexTest processes the results of the grouping for the algorithm to know
+// return an error if something went horribly wrong, and bool false to stop
+func (ag *baseGrouper) vertexTest(b bool) (bool, error) {
+	// NOTE: this particular baseGrouper version doesn't track what happens
+	// because since we iterate over every pair, we don't care which merge!
+	if ag.done {
+		return false, nil
+	}
+	return true, nil
+}
+
+// TODO: this algorithm may not be correct in all cases. replace if needed!
+type nonReachabilityGrouper struct {
+	baseGrouper // "inherit" what we want, and reimplement the rest
+}
+
+func (ag *nonReachabilityGrouper) name() string {
+	return "nonReachabilityGrouper"
+}
+
+// this algorithm relies on the observation that if there's a path from a to b,
+// then they *can't* be merged (b/c of the existing dependency) so therefore we
+// merge anything that *doesn't* satisfy this condition or that of the reverse!
+func (ag *nonReachabilityGrouper) vertexNext() (v1, v2 *Vertex, err error) {
+	for {
+		v1, v2, err = ag.baseGrouper.vertexNext() // get all iterable pairs
+		if err != nil {
+			log.Fatalf("Error running autoGroup(vertexNext): %v", err)
+		}
+
+		if v1 != v2 { // ignore self cmp early (perf optimization)
+			// if NOT reachable, they're viable...
+			out1 := ag.graph.Reachability(v1, v2)
+			out2 := ag.graph.Reachability(v2, v1)
+			if len(out1) == 0 && len(out2) == 0 {
+				return // return v1 and v2, they're viable
+			}
+		}
+
+		// if we got here, it means we're skipping over this candidate!
+		if ok, err := ag.baseGrouper.vertexTest(false); err != nil {
+			log.Fatalf("Error running autoGroup(vertexTest): %v", err)
+		} else if !ok {
+			return nil, nil, nil // done!
+		}
+
+		// the vertexTest passed, so loop and try with a new pair...
+	}
+}
+
+// VertexMerge merges v2 into v1 by reattaching the edges where appropriate,
+// and then by deleting v2 from the graph. Since more than one edge between two
+// vertices is not allowed, duplicate edges are merged as well. an edge merge
+// function can be provided if you'd like to control how you merge the edges!
+func (g *Graph) VertexMerge(v1, v2 *Vertex, vertexMergeFn func(*Vertex, *Vertex) (*Vertex, error), edgeMergeFn func(*Edge, *Edge) *Edge) error {
+	// methodology
+	// 1) edges between v1 and v2 are removed
+	//Loop:
+	for k1 := range g.Adjacency {
+		for k2 := range g.Adjacency[k1] {
+			// v1 -> v2 || v2 -> v1
+			if (k1 == v1 && k2 == v2) || (k1 == v2 && k2 == v1) {
+				delete(g.Adjacency[k1], k2) // delete map & edge
+				// NOTE: if we assume this is a DAG, then we can
+				// assume only v1 -> v2 OR v2 -> v1 exists, and
+				// we can break out of these loops immediately!
+				//break Loop
+				break
+			}
+		}
+	}
+
+	// 2) edges that point towards v2 from X now point to v1 from X (no dupes)
+	for _, x := range g.IncomingGraphEdges(v2) { // all to vertex v (??? -> v)
+		e := g.Adjacency[x][v2] // previous edge
+		r := g.Reachability(x, v1)
+		// merge e with ex := g.Adjacency[x][v1] if it exists!
+		if ex, exists := g.Adjacency[x][v1]; exists && edgeMergeFn != nil && len(r) == 0 {
+			e = edgeMergeFn(e, ex)
+		}
+		if len(r) == 0 { // if not reachable, add it
+			g.AddEdge(x, v1, e) // overwrite edge
+		} else if edgeMergeFn != nil { // reachable, merge e through...
+			prev := x // initial condition
+			for i, next := range r {
+				if i == 0 {
+					// next == prev, therefore skip
+					continue
+				}
+				// this edge is from: prev, to: next
+				ex, _ := g.Adjacency[prev][next] // get
+				ex = edgeMergeFn(ex, e)
+				g.Adjacency[prev][next] = ex // set
+				prev = next
+			}
+		}
+		delete(g.Adjacency[x], v2) // delete old edge
+	}
+
+	// 3) edges that point from v2 to X now point from v1 to X (no dupes)
+	for _, x := range g.OutgoingGraphEdges(v2) { // all from vertex v (v -> ???)
+		e := g.Adjacency[v2][x] // previous edge
+		r := g.Reachability(v1, x)
+		// merge e with ex := g.Adjacency[v1][x] if it exists!
+		if ex, exists := g.Adjacency[v1][x]; exists && edgeMergeFn != nil && len(r) == 0 {
+			e = edgeMergeFn(e, ex)
+		}
+		if len(r) == 0 {
+			g.AddEdge(v1, x, e) // overwrite edge
+		} else if edgeMergeFn != nil { // reachable, merge e through...
+			prev := v1 // initial condition
+			for i, next := range r {
+				if i == 0 {
+					// next == prev, therefore skip
+					continue
+				}
+				// this edge is from: prev, to: next
+				ex, _ := g.Adjacency[prev][next]
+				ex = edgeMergeFn(ex, e)
+				g.Adjacency[prev][next] = ex
+				prev = next
+			}
+		}
+		delete(g.Adjacency[v2], x)
+	}
+
+	// 4) merge and then remove the (now merged/grouped) vertex
+	if vertexMergeFn != nil { // run vertex merge function
+		if v, err := vertexMergeFn(v1, v2); err != nil {
+			return err
+		} else if v != nil { // replace v1 with the "merged" version...
+			v1 = v // XXX: will this replace v1 the way we want?
+		}
+	}
+	g.DeleteVertex(v2) // remove grouped vertex
+
+	// 5) creation of a cyclic graph should throw an error
+	if _, dag := g.TopologicalSort(); !dag { // am i a dag or not?
+		return fmt.Errorf("Graph is not a dag!")
+	}
+	return nil // success
+}
+
+// autoGroup is the mechanical auto group "runner" that runs the interface spec
+func (g *Graph) autoGroup(ag AutoGrouper) chan string {
+	strch := make(chan string) // output log messages here
+	go func(strch chan string) {
+		strch <- fmt.Sprintf("Compile: Grouping: Algorithm: %v...", ag.name())
+		if err := ag.init(g); err != nil {
+			log.Fatalf("Error running autoGroup(init): %v", err)
+		}
+
+		for {
+			var v, w *Vertex
+			v, w, err := ag.vertexNext() // get pair to compare
+			if err != nil {
+				log.Fatalf("Error running autoGroup(vertexNext): %v", err)
+			}
+			merged := false
+			// save names since they change during the runs
+			vStr := fmt.Sprintf("%s", v) // valid even if it is nil
+			wStr := fmt.Sprintf("%s", w)
+
+			if err := ag.vertexCmp(v, w); err != nil { // cmp ?
+				if global.DEBUG {
+					strch <- fmt.Sprintf("Compile: Grouping: !GroupCmp for: %s into %s", wStr, vStr)
+				}
+
+				// remove grouped vertex and merge edges (res is safe)
+			} else if err := g.VertexMerge(v, w, ag.vertexMerge, ag.edgeMerge); err != nil { // merge...
+				strch <- fmt.Sprintf("Compile: Grouping: !VertexMerge for: %s into %s", wStr, vStr)
+
+			} else { // success!
+				strch <- fmt.Sprintf("Compile: Grouping: Success for: %s into %s", wStr, vStr)
+				merged = true // woo
+			}
+
+			// did these get used?
+			if ok, err := ag.vertexTest(merged); err != nil {
+				log.Fatalf("Error running autoGroup(vertexTest): %v", err)
+			} else if !ok {
+				break // done!
+			}
+		}
+
+		close(strch)
+		return
+	}(strch) // call function
+	return strch
+}
+
+// AutoGroup runs the auto grouping on the graph and prints out log messages
+func (g *Graph) AutoGroup() {
+	// receive log messages from channel...
+	// this allows test cases to avoid printing them when they're unwanted!
+	// TODO: this algorithm may not be correct in all cases. replace if needed!
+	for str := range g.autoGroup(&nonReachabilityGrouper{}) {
+		log.Println(str)
+	}
+}

pgraph/pgraph.go

@@ -0,0 +1,968 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Package pgraph represents the internal "pointer graph" that we use.
+package pgraph
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"math"
+	"os"
+	"os/exec"
+	"sort"
+	"strconv"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/purpleidea/mgmt/converger"
+	"github.com/purpleidea/mgmt/event"
+	"github.com/purpleidea/mgmt/global"
+	"github.com/purpleidea/mgmt/resources"
+)
+
+//go:generate stringer -type=graphState -output=graphstate_stringer.go
+type graphState int
+
+const (
+	graphStateNil graphState = iota
+	graphStateStarting
+	graphStateStarted
+	graphStatePausing
+	graphStatePaused
+)
+
+// Graph is the graph structure in this library.
+// The graph abstract data type (ADT) is defined as follows:
+// * the directed graph arrows point from left to right ( -> )
+// * the arrows point away from their dependencies (eg: arrows mean "before")
+// * IOW, you might see package -> file -> service (where package runs first)
+// * This is also the direction that the notify should happen in...
+type Graph struct {
+	Name      string
+	Adjacency map[*Vertex]map[*Vertex]*Edge // *Vertex -> *Vertex (edge)
+	state     graphState
+	mutex     sync.Mutex // used when modifying graph State variable
+}
+
+// Vertex is the primary vertex struct in this library.
+type Vertex struct {
+	resources.Res       // anonymous field
+	timestamp     int64 // last updated timestamp ?
+}
+
+// Edge is the primary edge struct in this library.
+type Edge struct {
+	Name string
+}
+
+// NewGraph builds a new graph.
+func NewGraph(name string) *Graph {
+	return &Graph{
+		Name:      name,
+		Adjacency: make(map[*Vertex]map[*Vertex]*Edge),
+		state:     graphStateNil,
+	}
+}
+
+// NewVertex returns a new graph vertex struct with a contained resource.
+func NewVertex(r resources.Res) *Vertex {
+	return &Vertex{
+		Res: r,
+	}
+}
+
+// NewEdge returns a new graph edge struct.
+func NewEdge(name string) *Edge {
+	return &Edge{
+		Name: name,
+	}
+}
+
+// Copy makes a copy of the graph struct
+func (g *Graph) Copy() *Graph {
+	newGraph := &Graph{
+		Name:      g.Name,
+		Adjacency: make(map[*Vertex]map[*Vertex]*Edge, len(g.Adjacency)),
+		state:     g.state,
+	}
+	for k, v := range g.Adjacency {
+		newGraph.Adjacency[k] = v // copy
+	}
+	return newGraph
+}
+
+// GetName returns the name of the graph.
+func (g *Graph) GetName() string {
+	return g.Name
+}
+
+// SetName sets the name of the graph.
+func (g *Graph) SetName(name string) {
+	g.Name = name
+}
+
+// getState returns the state of the graph. This state is used for optimizing
+// certain algorithms by knowing what part of processing the graph is currently
+// undergoing.
+func (g *Graph) getState() graphState {
+	//g.mutex.Lock()
+	//defer g.mutex.Unlock()
+	return g.state
+}
+
+// setState sets the graph state and returns the previous state.
+func (g *Graph) setState(state graphState) graphState {
+	g.mutex.Lock()
+	defer g.mutex.Unlock()
+	prev := g.getState()
+	g.state = state
+	return prev
+}
+
+// AddVertex uses variadic input to add all listed vertices to the graph
+func (g *Graph) AddVertex(xv ...*Vertex) {
+	for _, v := range xv {
+		if _, exists := g.Adjacency[v]; !exists {
+			g.Adjacency[v] = make(map[*Vertex]*Edge)
+		}
+	}
+}
+
+// DeleteVertex deletes a particular vertex from the graph.
+func (g *Graph) DeleteVertex(v *Vertex) {
+	delete(g.Adjacency, v)
+	for k := range g.Adjacency {
+		delete(g.Adjacency[k], v)
+	}
+}
+
+// AddEdge adds a directed edge to the graph from v1 to v2.
+func (g *Graph) AddEdge(v1, v2 *Vertex, e *Edge) {
+	// NOTE: this doesn't allow more than one edge between two vertexes...
+	g.AddVertex(v1, v2) // supports adding N vertices now
+	// TODO: check if an edge exists to avoid overwriting it!
+	// NOTE: VertexMerge() depends on overwriting it at the moment...
+	g.Adjacency[v1][v2] = e
+}
+
+// GetVertexMatch searches for an equivalent resource in the graph and returns
+// the vertex it is found in, or nil if not found.
+func (g *Graph) GetVertexMatch(obj resources.Res) *Vertex {
+	for k := range g.Adjacency {
+		if k.Res.Compare(obj) {
+			return k
+		}
+	}
+	return nil
+}
+
+// HasVertex returns if the input vertex exists in the graph.
+func (g *Graph) HasVertex(v *Vertex) bool {
+	if _, exists := g.Adjacency[v]; exists {
+		return true
+	}
+	return false
+}
+
+// NumVertices returns the number of vertices in the graph.
+func (g *Graph) NumVertices() int {
+	return len(g.Adjacency)
+}
+
+// NumEdges returns the number of edges in the graph.
+func (g *Graph) NumEdges() int {
+	count := 0
+	for k := range g.Adjacency {
+		count += len(g.Adjacency[k])
+	}
+	return count
+}
+
+// GetVertices returns a randomly sorted slice of all vertices in the graph
+// The order is random, because the map implementation is intentionally so!
+func (g *Graph) GetVertices() []*Vertex {
+	var vertices []*Vertex
+	for k := range g.Adjacency {
+		vertices = append(vertices, k)
+	}
+	return vertices
+}
+
+// GetVerticesChan returns a channel of all vertices in the graph.
+func (g *Graph) GetVerticesChan() chan *Vertex {
+	ch := make(chan *Vertex)
+	go func(ch chan *Vertex) {
+		for k := range g.Adjacency {
+			ch <- k
+		}
+		close(ch)
+	}(ch)
+	return ch
+}
+
+// VertexSlice is a linear list of vertices. It can be sorted.
+type VertexSlice []*Vertex
+
+func (vs VertexSlice) Len() int           { return len(vs) }
+func (vs VertexSlice) Swap(i, j int)      { vs[i], vs[j] = vs[j], vs[i] }
+func (vs VertexSlice) Less(i, j int) bool { return vs[i].String() < vs[j].String() }
+
+// GetVerticesSorted returns a sorted slice of all vertices in the graph
+// The order is sorted by String() to avoid the non-determinism in the map type
+func (g *Graph) GetVerticesSorted() []*Vertex {
+	var vertices []*Vertex
+	for k := range g.Adjacency {
+		vertices = append(vertices, k)
+	}
+	sort.Sort(VertexSlice(vertices)) // add determinism
+	return vertices
+}
+
+// String makes the graph pretty print.
+func (g *Graph) String() string {
+	return fmt.Sprintf("Vertices(%d), Edges(%d)", g.NumVertices(), g.NumEdges())
+}
+
+// String returns the canonical form for a vertex
+func (v *Vertex) String() string {
+	return fmt.Sprintf("%s[%s]", v.Res.Kind(), v.Res.GetName())
+}
+
+// Graphviz outputs the graph in graphviz format.
+// https://en.wikipedia.org/wiki/DOT_%28graph_description_language%29
+func (g *Graph) Graphviz() (out string) {
+	//digraph g {
+	//	label="hello world";
+	//	node [shape=box];
+	//	A [label="A"];
+	//	B [label="B"];
+	//	C [label="C"];
+	//	D [label="D"];
+	//	E [label="E"];
+	//	A -> B [label=f];
+	//	B -> C [label=g];
+	//	D -> E [label=h];
+	//}
+	out += fmt.Sprintf("digraph %v {\n", g.GetName())
+	out += fmt.Sprintf("\tlabel=\"%v\";\n", g.GetName())
+	//out += "\tnode [shape=box];\n"
+	str := ""
+	for i := range g.Adjacency { // reverse paths
+		out += fmt.Sprintf("\t%v [label=\"%v[%v]\"];\n", i.GetName(), i.Kind(), i.GetName())
+		for j := range g.Adjacency[i] {
+			k := g.Adjacency[i][j]
+			// use str for clearer output ordering
+			str += fmt.Sprintf("\t%v -> %v [label=%v];\n", i.GetName(), j.GetName(), k.Name)
+		}
+	}
+	out += str
+	out += "}\n"
+	return
+}
+
+// ExecGraphviz writes out the graphviz data and runs the correct graphviz
+// filter command.
+func (g *Graph) ExecGraphviz(program, filename string) error {
+
+	switch program {
+	case "dot", "neato", "twopi", "circo", "fdp":
+	default:
+		return errors.New("Invalid graphviz program selected!")
+	}
+
+	if filename == "" {
+		return errors.New("No filename given!")
+	}
+
+	// run as a normal user if possible when run with sudo
+	uid, err1 := strconv.Atoi(os.Getenv("SUDO_UID"))
+	gid, err2 := strconv.Atoi(os.Getenv("SUDO_GID"))
+
+	err := ioutil.WriteFile(filename, []byte(g.Graphviz()), 0644)
+	if err != nil {
+		return errors.New("Error writing to filename!")
+	}
+
+	if err1 == nil && err2 == nil {
+		if err := os.Chown(filename, uid, gid); err != nil {
+			return errors.New("Error changing file owner!")
+		}
+	}
+
+	path, err := exec.LookPath(program)
+	if err != nil {
+		return errors.New("Graphviz is missing!")
+	}
+
+	out := fmt.Sprintf("%v.png", filename)
+	cmd := exec.Command(path, "-Tpng", fmt.Sprintf("-o%v", out), filename)
+
+	if err1 == nil && err2 == nil {
+		cmd.SysProcAttr = &syscall.SysProcAttr{}
+		cmd.SysProcAttr.Credential = &syscall.Credential{
+			Uid: uint32(uid),
+			Gid: uint32(gid),
+		}
+	}
+	_, err = cmd.Output()
+	if err != nil {
+		return errors.New("Error writing to image!")
+	}
+	return nil
+}
+
+// IncomingGraphEdges returns an array (slice) of all directed vertices to
+// vertex v (??? -> v). OKTimestamp should probably use this.
+func (g *Graph) IncomingGraphEdges(v *Vertex) []*Vertex {
+	// TODO: we might be able to implement this differently by reversing
+	// the Adjacency graph and then looping through it again...
+	var s []*Vertex
+	for k := range g.Adjacency { // reverse paths
+		for w := range g.Adjacency[k] {
+			if w == v {
+				s = append(s, k)
+			}
+		}
+	}
+	return s
+}
+
+// OutgoingGraphEdges returns an array (slice) of all vertices that vertex v
+// points to (v -> ???). Poke should probably use this.
+func (g *Graph) OutgoingGraphEdges(v *Vertex) []*Vertex {
+	var s []*Vertex
+	for k := range g.Adjacency[v] { // forward paths
+		s = append(s, k)
+	}
+	return s
+}
+
+// GraphEdges returns an array (slice) of all vertices that connect to vertex v.
+// This is the union of IncomingGraphEdges and OutgoingGraphEdges.
+func (g *Graph) GraphEdges(v *Vertex) []*Vertex {
+	var s []*Vertex
+	s = append(s, g.IncomingGraphEdges(v)...)
+	s = append(s, g.OutgoingGraphEdges(v)...)
+	return s
+}
+
+// DFS returns a depth first search for the graph, starting at the input vertex.
+func (g *Graph) DFS(start *Vertex) []*Vertex {
+	var d []*Vertex // discovered
+	var s []*Vertex // stack
+	if _, exists := g.Adjacency[start]; !exists {
+		return nil // TODO: error
+	}
+	v := start
+	s = append(s, v)
+	for len(s) > 0 {
+		v, s = s[len(s)-1], s[:len(s)-1] // s.pop()
+
+		if !VertexContains(v, d) { // if not discovered
+			d = append(d, v) // label as discovered
+
+			for _, w := range g.GraphEdges(v) {
+				s = append(s, w)
+			}
+		}
+	}
+	return d
+}
+
+// FilterGraph builds a new graph containing only vertices from the list.
+func (g *Graph) FilterGraph(name string, vertices []*Vertex) *Graph {
+	newgraph := NewGraph(name)
+	for k1, x := range g.Adjacency {
+		for k2, e := range x {
+			//log.Printf("Filter: %v -> %v # %v", k1.Name, k2.Name, e.Name)
+			if VertexContains(k1, vertices) || VertexContains(k2, vertices) {
+				newgraph.AddEdge(k1, k2, e)
+			}
+		}
+	}
+	return newgraph
+}
+
+// GetDisconnectedGraphs returns a channel containing the N disconnected graphs
+// in our main graph. We can then process each of these in parallel.
+func (g *Graph) GetDisconnectedGraphs() chan *Graph {
+	ch := make(chan *Graph)
+	go func() {
+		var start *Vertex
+		var d []*Vertex // discovered
+		c := g.NumVertices()
+		for len(d) < c {
+
+			// get an undiscovered vertex to start from
+			for _, s := range g.GetVertices() {
+				if !VertexContains(s, d) {
+					start = s
+				}
+			}
+
+			// dfs through the graph
+			dfs := g.DFS(start)
+			// filter all the collected elements into a new graph
+			newgraph := g.FilterGraph(g.Name, dfs)
+
+			// add number of elements found to found variable
+			d = append(d, dfs...) // extend
+
+			// return this new graph to the channel
+			ch <- newgraph
+
+			// if we've found all the elements, then we're done
+			// otherwise loop through to continue...
+		}
+		close(ch)
+	}()
+	return ch
+}
+
+// InDegree returns the count of vertices that point to me in one big lookup map.
+func (g *Graph) InDegree() map[*Vertex]int {
+	result := make(map[*Vertex]int)
+	for k := range g.Adjacency {
+		result[k] = 0 // initialize
+	}
+
+	for k := range g.Adjacency {
+		for z := range g.Adjacency[k] {
+			result[z]++
+		}
+	}
+	return result
+}
+
+// OutDegree returns the count of vertices that point away in one big lookup map.
+func (g *Graph) OutDegree() map[*Vertex]int {
+	result := make(map[*Vertex]int)
+
+	for k := range g.Adjacency {
+		result[k] = 0 // initialize
+		for range g.Adjacency[k] {
+			result[k]++
+		}
+	}
+	return result
+}
+
+// TopologicalSort returns the sort of graph vertices in that order.
+// based on descriptions and code from wikipedia and rosetta code
+// TODO: add memoization, and cache invalidation to speed this up :)
+func (g *Graph) TopologicalSort() (result []*Vertex, ok bool) { // kahn's algorithm
+	var L []*Vertex                    // empty list that will contain the sorted elements
+	var S []*Vertex                    // set of all nodes with no incoming edges
+	remaining := make(map[*Vertex]int) // amount of edges remaining
+
+	for v, d := range g.InDegree() {
+		if d == 0 {
+			// accumulate set of all nodes with no incoming edges
+			S = append(S, v)
+		} else {
+			// initialize remaining edge count from indegree
+			remaining[v] = d
+		}
+	}
+
+	for len(S) > 0 {
+		last := len(S) - 1 // remove a node v from S
+		v := S[last]
+		S = S[:last]
+		L = append(L, v) // add v to tail of L
+		for n := range g.Adjacency[v] {
+			// for each node n remaining in the graph, consume from
+			// remaining, so for remaining[n] > 0
+			if remaining[n] > 0 {
+				remaining[n]--         // remove edge from the graph
+				if remaining[n] == 0 { // if n has no other incoming edges
+					S = append(S, n) // insert n into S
+				}
+			}
+		}
+	}
+
+	// if graph has edges, eg if any value in rem is > 0
+	for c, in := range remaining {
+		if in > 0 {
+			for n := range g.Adjacency[c] {
+				if remaining[n] > 0 {
+					return nil, false // not a dag!
+				}
+			}
+		}
+	}
+
+	return L, true
+}
+
+// Reachability finds the shortest path in a DAG from a to b, and returns the
+// slice of vertices that matched this particular path including both a and b.
+// It returns nil if a or b is nil, and returns empty list if no path is found.
+// Since there could be more than one possible result for this operation, we
+// arbitrarily choose one of the shortest possible. As a result, this should
+// actually return a tree if we cared about correctness.
+// This operates by a recursive algorithm; a more efficient version is likely.
+// If you don't give this function a DAG, you might cause infinite recursion!
+func (g *Graph) Reachability(a, b *Vertex) []*Vertex {
+	if a == nil || b == nil {
+		return nil
+	}
+	vertices := g.OutgoingGraphEdges(a) // what points away from a ?
+	if len(vertices) == 0 {
+		return []*Vertex{} // nope
+	}
+	if VertexContains(b, vertices) {
+		return []*Vertex{a, b} // found
+	}
+	// TODO: parallelize this with go routines?
+	var collected = make([][]*Vertex, len(vertices))
+	pick := -1
+	for i, v := range vertices {
+		collected[i] = g.Reachability(v, b) // find b by recursion
+		if l := len(collected[i]); l > 0 {
+			// pick shortest path
+			// TODO: technically i should return a tree
+			if pick < 0 || l < len(collected[pick]) {
+				pick = i
+			}
+		}
+	}
+	if pick < 0 {
+		return []*Vertex{} // nope
+	}
+	result := []*Vertex{a} // tack on a
+	result = append(result, collected[pick]...)
+	return result
+}
+
+// GetTimestamp returns the timestamp of a vertex
+func (v *Vertex) GetTimestamp() int64 {
+	return v.timestamp
+}
+
+// UpdateTimestamp updates the timestamp on a vertex and returns the new value
+func (v *Vertex) UpdateTimestamp() int64 {
+	v.timestamp = time.Now().UnixNano() // update
+	return v.timestamp
+}
+
+// OKTimestamp returns true if this element can run right now?
+func (g *Graph) OKTimestamp(v *Vertex) bool {
+	// these are all the vertices pointing TO v, eg: ??? -> v
+	for _, n := range g.IncomingGraphEdges(v) {
+		// if the vertex has a greater timestamp than any pre-req (n)
+		// then we can't run right now...
+		// if they're equal (eg: on init of 0) then we also can't run
+		// b/c we should let our pre-req's go first...
+		x, y := v.GetTimestamp(), n.GetTimestamp()
+		if global.DEBUG {
+			log.Printf("%v[%v]: OKTimestamp: (%v) >= %v[%v](%v): !%v", v.Kind(), v.GetName(), x, n.Kind(), n.GetName(), y, x >= y)
+		}
+		if x >= y {
+			return false
+		}
+	}
+	return true
+}
+
+// Poke notifies nodes after me in the dependency graph that they need refreshing...
+// NOTE: this assumes that this can never fail or need to be rescheduled
+func (g *Graph) Poke(v *Vertex, activity bool) {
+	// these are all the vertices pointing AWAY FROM v, eg: v -> ???
+	for _, n := range g.OutgoingGraphEdges(v) {
+		// XXX: if we're in state event and haven't been cancelled by
+		// apply, then we can cancel a poke to a child, right? XXX
+		// XXX: if n.Res.getState() != resources.ResStateEvent { // is this correct?
+		if true { // XXX
+			if global.DEBUG {
+				log.Printf("%v[%v]: Poke: %v[%v]", v.Kind(), v.GetName(), n.Kind(), n.GetName())
+			}
+			n.SendEvent(event.EventPoke, false, activity) // XXX: can this be switched to sync?
+		} else {
+			if global.DEBUG {
+				log.Printf("%v[%v]: Poke: %v[%v]: Skipped!", v.Kind(), v.GetName(), n.Kind(), n.GetName())
+			}
+		}
+	}
+}
+
+// BackPoke pokes the pre-requisites that are stale and need to run before I can run.
+func (g *Graph) BackPoke(v *Vertex) {
+	// these are all the vertices pointing TO v, eg: ??? -> v
+	for _, n := range g.IncomingGraphEdges(v) {
+		x, y, s := v.GetTimestamp(), n.GetTimestamp(), n.Res.GetState()
+		// if the parent timestamp needs poking AND it's not in state
+		// ResStateEvent, then poke it. If the parent is in ResStateEvent it
+		// means that an event is pending, so we'll be expecting a poke
+		// back soon, so we can safely discard the extra parent poke...
+		// TODO: implement a stateLT (less than) to tell if something
+		// happens earlier in the state cycle and that doesn't wrap nil
+		if x >= y && (s != resources.ResStateEvent && s != resources.ResStateCheckApply) {
+			if global.DEBUG {
+				log.Printf("%v[%v]: BackPoke: %v[%v]", v.Kind(), v.GetName(), n.Kind(), n.GetName())
+			}
+			n.SendEvent(event.EventBackPoke, false, false) // XXX: can this be switched to sync?
+		} else {
+			if global.DEBUG {
+				log.Printf("%v[%v]: BackPoke: %v[%v]: Skipped!", v.Kind(), v.GetName(), n.Kind(), n.GetName())
+			}
+		}
+	}
+}
+
+// Process is the primary function to execute for a particular vertex in the graph.
+func (g *Graph) Process(v *Vertex) error {
+	obj := v.Res
+	if global.DEBUG {
+		log.Printf("%v[%v]: Process()", obj.Kind(), obj.GetName())
+	}
+	obj.SetState(resources.ResStateEvent)
+	var ok = true
+	var apply = false // did we run an apply?
+	// is it okay to run dependency wise right now?
+	// if not, that's okay because when the dependency runs, it will poke
+	// us back and we will run if needed then!
+	if g.OKTimestamp(v) {
+		if global.DEBUG {
+			log.Printf("%v[%v]: OKTimestamp(%v)", obj.Kind(), obj.GetName(), v.GetTimestamp())
+		}
+
+		obj.SetState(resources.ResStateCheckApply)
+		// if this fails, don't UpdateTimestamp()
+		checkok, err := obj.CheckApply(!obj.Meta().Noop)
+		if checkok && err != nil { // should never return this way
+			log.Fatalf("%v[%v]: CheckApply(): %t, %+v", obj.Kind(), obj.GetName(), checkok, err)
+		}
+		if global.DEBUG {
+			log.Printf("%v[%v]: CheckApply(): %t, %v", obj.Kind(), obj.GetName(), checkok, err)
+		}
+
+		if !checkok { // if state *was* not ok, we had to have apply'ed
+			if err != nil { // error during check or apply
+				ok = false
+			} else {
+				apply = true
+			}
+		}
+
+		// when noop is true we always want to update timestamp
+		if obj.Meta().Noop && err == nil {
+			ok = true
+		}
+
+		if ok {
+			// update this timestamp *before* we poke or the poked
+			// nodes might fail due to having a too old timestamp!
+			v.UpdateTimestamp()                    // this was touched...
+			obj.SetState(resources.ResStatePoking) // can't cancel parent poke
+			g.Poke(v, apply)
+		}
+		// poke at our pre-req's instead since they need to refresh/run...
+		return err
+	}
+	// else... only poke at the pre-req's that need to run
+	go g.BackPoke(v)
+	return nil
+}
+
+// SentinelErr is a sentinal as an error type that wraps an arbitrary error.
+type SentinelErr struct {
+	err error
+}
+
+// Error is the required method to fulfill the error type.
+func (obj *SentinelErr) Error() string {
+	return obj.err.Error()
+}
+
+// Worker is the common run frontend of the vertex. It handles all of the retry
+// and retry delay common code, and ultimately returns the final status of this
+// vertex execution.
+func (g *Graph) Worker(v *Vertex) error {
+	// listen for chan events from Watch() and run
+	// the Process() function when they're received
+	// this avoids us having to pass the data into
+	// the Watch() function about which graph it is
+	// running on, which isolates things nicely...
+	obj := v.Res
+	chanProcess := make(chan event.Event)
+	go func() {
+		running := false
+		var timer = time.NewTimer(time.Duration(math.MaxInt64)) // longest duration
+		if !timer.Stop() {
+			<-timer.C // unnecessary, shouldn't happen
+		}
+		var delay = time.Duration(v.Meta().Delay) * time.Millisecond
+		var retry = v.Meta().Retry // number of tries left, -1 for infinite
+		var saved event.Event
+	Loop:
+		for {
+			// this has to be synchronous, because otherwise the Res
+			// event loop will keep running and change state,
+			// causing the converged timeout to fire!
+			select {
+			case event, ok := <-chanProcess: // must use like this
+				if running && ok {
+					// we got an event that wasn't a close,
+					// while we were waiting for the timer!
+					// if this happens, it might be a bug:(
+					log.Fatalf("%v[%v]: Worker: Unexpected event: %+v", v.Kind(), v.GetName(), event)
+				}
+				if !ok { // chanProcess closed, let's exit
+					break Loop // no event, so no ack!
+				}
+
+				// the above mentioned synchronous part, is the
+				// running of this function, paired with an ack.
+				if e := g.Process(v); e != nil {
+					saved = event
+					log.Printf("%v[%v]: CheckApply errored: %v", v.Kind(), v.GetName(), e)
+					if retry == 0 {
+						// wrap the error in the sentinel
+						event.ACKNACK(&SentinelErr{e}) // fail the Watch()
+						break Loop
+					}
+					if retry > 0 { // don't decrement the -1
+						retry--
+					}
+					log.Printf("%v[%v]: CheckApply: Retrying after %.4f seconds (%d left)", v.Kind(), v.GetName(), delay.Seconds(), retry)
+					// start the timer...
+					timer.Reset(delay)
+					running = true
+					continue
+				}
+				retry = v.Meta().Retry // reset on success
+				event.ACK()            // sync
+
+			case <-timer.C:
+				if !timer.Stop() {
+					//<-timer.C // blocks, docs are wrong!
+				}
+				running = false
+				log.Printf("%s[%s]: CheckApply delay expired!", v.Kind(), v.GetName())
+				// re-send this failed event, to trigger a CheckApply()
+				go func() { chanProcess <- saved }()
+				// TODO: should we send a fake event instead?
+				//saved = nil
+			}
+		}
+	}()
+	var err error // propagate the error up (this is a permanent BAD error!)
+	// the watch delay runs inside of the Watch resource loop, so that it
+	// can still process signals and exit if needed. It shouldn't run any
+	// resource specific code since this is supposed to be a retry delay.
+	// NOTE: we're using the same retry and delay metaparams that CheckApply
+	// uses. This is for practicality. We can separate them later if needed!
+	var watchDelay time.Duration
+	var watchRetry = v.Meta().Retry // number of tries left, -1 for infinite
+	// watch blocks until it ends, & errors to retry
+	for {
+		// TODO: do we have to stop the converged-timeout when in this block (perhaps we're in the delay block!)
+		// TODO: should we setup/manage some of the converged timeout stuff in here anyways?
+
+		// if a retry-delay was requested, wait, but don't block our events!
+		if watchDelay > 0 {
+			//var pendingSendEvent bool
+			timer := time.NewTimer(watchDelay)
+		Loop:
+			for {
+				select {
+				case <-timer.C: // the wait is over
+					break Loop // critical
+
+				// TODO: resources could have a separate exit channel to avoid this complexity!?
+				case event := <-obj.Events():
+					// NOTE: this code should match the similar Res code!
+					//cuuid.SetConverged(false) // TODO ?
+					if exit, send := obj.ReadEvent(&event); exit {
+						return nil // exit
+					} else if send {
+						// if we dive down this rabbit hole, our
+						// timer.C won't get seen until we get out!
+						// in this situation, the Watch() is blocked
+						// from performing until CheckApply returns
+						// successfully, or errors out. This isn't
+						// so bad, but we should document it. Is it
+						// possible that some resource *needs* Watch
+						// to run to be able to execute a CheckApply?
+						// That situation shouldn't be common, and
+						// should probably not be allowed. Can we
+						// avoid it though?
+						//if exit, err := doSend(); exit || err != nil {
+						//	return err // we exit or bubble up a NACK...
+						//}
+						// Instead of doing the above, we can
+						// add events to a pending list, and
+						// when we finish the delay, we can run
+						// them.
+						//pendingSendEvent = true // all events are identical for now...
+					}
+				}
+			}
+			timer.Stop() // it's nice to cleanup
+			log.Printf("%s[%s]: Watch delay expired!", v.Kind(), v.GetName())
+			// NOTE: we can avoid the send if running Watch guarantees
+			// one CheckApply event on startup!
+			//if pendingSendEvent { // TODO: should this become a list in the future?
+			//	if exit, err := obj.DoSend(chanProcess, ""); exit || err != nil {
+			//		return err // we exit or bubble up a NACK...
+			//	}
+			//}
+		}
+
+		// TODO: reset the watch retry count after some amount of success
+		e := v.Res.Watch(chanProcess)
+		if e == nil { // exit signal
+			err = nil // clean exit
+			break
+		}
+		if sentinelErr, ok := e.(*SentinelErr); ok { // unwrap the sentinel
+			err = sentinelErr.err
+			break // sentinel means, perma-exit
+		}
+		log.Printf("%v[%v]: Watch errored: %v", v.Kind(), v.GetName(), e)
+		if watchRetry == 0 {
+			err = fmt.Errorf("Permanent watch error: %v", e)
+			break
+		}
+		if watchRetry > 0 { // don't decrement the -1
+			watchRetry--
+		}
+		watchDelay = time.Duration(v.Meta().Delay) * time.Millisecond
+		log.Printf("%v[%v]: Watch: Retrying after %.4f seconds (%d left)", v.Kind(), v.GetName(), watchDelay.Seconds(), watchRetry)
+		// We need to trigger a CheckApply after Watch restarts, so that
+		// we catch any lost events that happened while down. We do this
+		// by getting the Watch resource to send one event once it's up!
+		//v.SendEvent(eventPoke, false, false)
+	}
+	close(chanProcess)
+	return err
+}
+
+// Start is a main kick to start the graph. It goes through in reverse topological
+// sort order so that events can't hit un-started vertices.
+func (g *Graph) Start(wg *sync.WaitGroup, first bool) { // start or continue
+	log.Printf("State: %v -> %v", g.setState(graphStateStarting), g.getState())
+	defer log.Printf("State: %v -> %v", g.setState(graphStateStarted), g.getState())
+	t, _ := g.TopologicalSort()
+	// TODO: only calculate indegree if `first` is true to save resources
+	indegree := g.InDegree() // compute all of the indegree's
+	for _, v := range Reverse(t) {
+
+		if !v.Res.IsWatching() { // if Watch() is not running...
+			wg.Add(1)
+			// must pass in value to avoid races...
+			// see: https://ttboj.wordpress.com/2015/07/27/golang-parallelism-issues-causing-too-many-open-files-error/
+			go func(vv *Vertex) {
+				defer wg.Done()
+				// TODO: if a sufficient number of workers error,
+				// should something be done? Will these restart
+				// after perma-failure if we have a graph change?
+				if err := g.Worker(vv); err != nil { // contains the Watch and CheckApply loops
+					log.Printf("%s[%s]: Exited with failure: %v", vv.Kind(), vv.GetName(), err)
+					return
+				}
+				log.Printf("%v[%v]: Exited", vv.Kind(), vv.GetName())
+			}(v)
+		}
+
+		// selective poke: here we reduce the number of initial pokes
+		// to the minimum required to activate every vertex in the
+		// graph, either by direct action, or by getting poked by a
+		// vertex that was previously activated. if we poke each vertex
+		// that has no incoming edges, then we can be sure to reach the
+		// whole graph. Please note: this may mask certain optimization
+		// failures, such as any poke limiting code in Poke() or
+		// BackPoke(). You might want to disable this selective start
+		// when experimenting with and testing those elements.
+		// if we are unpausing (since it's not the first run of this
+		// function) we need to poke to *unpause* every graph vertex,
+		// and not just selectively the subset with no indegree.
+		if (!first) || indegree[v] == 0 {
+			// ensure state is started before continuing on to next vertex
+			for !v.SendEvent(event.EventStart, true, false) {
+				if global.DEBUG {
+					// if SendEvent fails, we aren't up yet
+					log.Printf("%v[%v]: Retrying SendEvent(Start)", v.Kind(), v.GetName())
+					// sleep here briefly or otherwise cause
+					// a different goroutine to be scheduled
+					time.Sleep(1 * time.Millisecond)
+				}
+			}
+		}
+	}
+}
+
+// Pause sends pause events to the graph in a topological sort order.
+func (g *Graph) Pause() {
+	log.Printf("State: %v -> %v", g.setState(graphStatePausing), g.getState())
+	defer log.Printf("State: %v -> %v", g.setState(graphStatePaused), g.getState())
+	t, _ := g.TopologicalSort()
+	for _, v := range t { // squeeze out the events...
+		v.SendEvent(event.EventPause, true, false)
+	}
+}
+
+// Exit sends exit events to the graph in a topological sort order.
+func (g *Graph) Exit() {
+	if g == nil {
+		return
+	} // empty graph that wasn't populated yet
+	t, _ := g.TopologicalSort()
+	for _, v := range t { // squeeze out the events...
+		// turn off the taps...
+		// XXX: consider instead doing this by closing the Res.events channel instead?
+		// XXX: do this by sending an exit signal, and then returning
+		// when we hit the 'default' in the select statement!
+		// XXX: we can do this to quiesce, but it's not necessary now
+
+		v.SendEvent(event.EventExit, true, false)
+	}
+}
+
+// AssociateData associates some data with the object in the graph in question
+func (g *Graph) AssociateData(converger converger.Converger) {
+	for v := range g.GetVerticesChan() {
+		v.Res.AssociateData(converger)
+	}
+}
+
+// VertexContains is an "in array" function to test for a vertex in a slice of vertices.
+func VertexContains(needle *Vertex, haystack []*Vertex) bool {
+	for _, v := range haystack {
+		if needle == v {
+			return true
+		}
+	}
+	return false
+}
+
+// Reverse reverses a list of vertices.
+func Reverse(vs []*Vertex) []*Vertex {
+	//var out []*Vertex       // XXX: golint suggests, but it fails testing
+	out := make([]*Vertex, 0) // empty list
+	l := len(vs)
+	for i := range vs {
+		out = append(out, vs[l-i-1])
+	}
+	return out
+}

pgraph_test.go

@@ -1,201 +0,0 @@
-// Mgmt
-// Copyright (C) 2013-2015+ James Shubin and the project contributors
-// Written by James Shubin <james@shubin.ca> and the project contributors
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-// NOTE: this is pgraph, a pointer graph
-
-package main
-
-import (
-	"testing"
-)
-
-func TestPgraphT1(t *testing.T) {
-
-	G := NewGraph("g1")
-
-	if i := G.NumVertices(); i != 0 {
-		t.Errorf("Should have 0 vertices instead of: %d.", i)
-	}
-
-	v1 := NewVertex("v1", "type")
-	v2 := NewVertex("v2", "type")
-	e1 := NewEdge("e1")
-	G.AddEdge(v1, v2, e1)
-
-	if i := G.NumVertices(); i != 2 {
-		t.Errorf("Should have 2 vertices instead of: %d.", i)
-	}
-}
-
-func TestPgraphT2(t *testing.T) {
-
-	G := NewGraph("g2")
-	v1 := NewVertex("v1", "type")
-	v2 := NewVertex("v2", "type")
-	v3 := NewVertex("v3", "type")
-	v4 := NewVertex("v4", "type")
-	v5 := NewVertex("v5", "type")
-	v6 := NewVertex("v6", "type")
-	e1 := NewEdge("e1")
-	e2 := NewEdge("e2")
-	e3 := NewEdge("e3")
-	e4 := NewEdge("e4")
-	e5 := NewEdge("e5")
-	//e6 := NewEdge("e6")
-	G.AddEdge(v1, v2, e1)
-	G.AddEdge(v2, v3, e2)
-	G.AddEdge(v3, v1, e3)
-
-	G.AddEdge(v4, v5, e4)
-	G.AddEdge(v5, v6, e5)
-
-	if i := G.NumVertices(); i != 6 {
-		t.Errorf("Should have 6 vertices instead of: %d.", i)
-	}
-}
-
-func TestPgraphT3(t *testing.T) {
-
-	G := NewGraph("g3")
-	v1 := NewVertex("v1", "type")
-	v2 := NewVertex("v2", "type")
-	v3 := NewVertex("v3", "type")
-	v4 := NewVertex("v4", "type")
-	v5 := NewVertex("v5", "type")
-	v6 := NewVertex("v6", "type")
-	e1 := NewEdge("e1")
-	e2 := NewEdge("e2")
-	e3 := NewEdge("e3")
-	e4 := NewEdge("e4")
-	e5 := NewEdge("e5")
-	//e6 := NewEdge("e6")
-	G.AddEdge(v1, v2, e1)
-	G.AddEdge(v2, v3, e2)
-	G.AddEdge(v3, v1, e3)
-
-	G.AddEdge(v4, v5, e4)
-	G.AddEdge(v5, v6, e5)
-	//G.AddEdge(v6, v4, e6)
-	out1 := G.DFS(v1)
-	if i := len(out1); i != 3 {
-		t.Errorf("Should have 3 vertices instead of: %d.", i)
-		t.Errorf("Found: %v", out1)
-		for _, v := range out1 {
-			t.Errorf("Value: %v", v.Name)
-		}
-	}
-
-	out2 := G.DFS(v4)
-	if i := len(out2); i != 3 {
-		t.Errorf("Should have 3 vertices instead of: %d.", i)
-		t.Errorf("Found: %v", out1)
-		for _, v := range out1 {
-			t.Errorf("Value: %v", v.Name)
-		}
-	}
-}
-
-func TestPgraphT4(t *testing.T) {
-
-	G := NewGraph("g4")
-	v1 := NewVertex("v1", "type")
-	v2 := NewVertex("v2", "type")
-	v3 := NewVertex("v3", "type")
-	e1 := NewEdge("e1")
-	e2 := NewEdge("e2")
-	e3 := NewEdge("e3")
-	G.AddEdge(v1, v2, e1)
-	G.AddEdge(v2, v3, e2)
-	G.AddEdge(v3, v1, e3)
-
-	out := G.DFS(v1)
-	if i := len(out); i != 3 {
-		t.Errorf("Should have 3 vertices instead of: %d.", i)
-		t.Errorf("Found: %v", out)
-		for _, v := range out {
-			t.Errorf("Value: %v", v.Name)
-		}
-	}
-}
-
-func TestPgraphT5(t *testing.T) {
-	G := NewGraph("g5")
-	v1 := NewVertex("v1", "type")
-	v2 := NewVertex("v2", "type")
-	v3 := NewVertex("v3", "type")
-	v4 := NewVertex("v4", "type")
-	v5 := NewVertex("v5", "type")
-	v6 := NewVertex("v6", "type")
-	e1 := NewEdge("e1")
-	e2 := NewEdge("e2")
-	e3 := NewEdge("e3")
-	e4 := NewEdge("e4")
-	e5 := NewEdge("e5")
-	//e6 := NewEdge("e6")
-	G.AddEdge(v1, v2, e1)
-	G.AddEdge(v2, v3, e2)
-	G.AddEdge(v3, v1, e3)
-
-	G.AddEdge(v4, v5, e4)
-	G.AddEdge(v5, v6, e5)
-	//G.AddEdge(v6, v4, e6)
-
-	save := []*Vertex{v1, v2, v3}
-	out := G.FilterGraph("new g5", save)
-	if i := out.NumVertices(); i != 3 {
-		t.Errorf("Should have 3 vertices instead of: %d.", i)
-	}
-
-}
-
-func TestPgraphT6(t *testing.T) {
-	G := NewGraph("g6")
-	v1 := NewVertex("v1", "type")
-	v2 := NewVertex("v2", "type")
-	v3 := NewVertex("v3", "type")
-	v4 := NewVertex("v4", "type")
-	v5 := NewVertex("v5", "type")
-	v6 := NewVertex("v6", "type")
-	e1 := NewEdge("e1")
-	e2 := NewEdge("e2")
-	e3 := NewEdge("e3")
-	e4 := NewEdge("e4")
-	e5 := NewEdge("e5")
-	//e6 := NewEdge("e6")
-	G.AddEdge(v1, v2, e1)
-	G.AddEdge(v2, v3, e2)
-	G.AddEdge(v3, v1, e3)
-
-	G.AddEdge(v4, v5, e4)
-	G.AddEdge(v5, v6, e5)
-	//G.AddEdge(v6, v4, e6)
-
-	graphs := G.GetDisconnectedGraphs()
-	HeisenbergGraphCount := func(ch chan *Graph) int {
-		c := 0
-		for x := range ch {
-			_ = x
-			c++
-		}
-		return c
-	}
-
-	if i := HeisenbergGraphCount(graphs); i != 2 {
-		t.Errorf("Should have 2 graphs instead of: %d.", i)
-	}
-
-}

puppet/puppet.go

@@ -0,0 +1,145 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Package puppet provides the integration entrypoint for the puppet language.
+package puppet
+
+import (
+	"bufio"
+	"io"
+	"log"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/purpleidea/mgmt/gconfig"
+	"github.com/purpleidea/mgmt/global"
+)
+
+const (
+	// PuppetYAMLBufferSize is the maximum buffer size for the yaml input data
+	PuppetYAMLBufferSize = 65535
+)
+
+func runPuppetCommand(cmd *exec.Cmd) ([]byte, error) {
+	if global.DEBUG {
+		log.Printf("Puppet: running command: %v", cmd)
+	}
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		log.Printf("Puppet: Error opening pipe to puppet command: %v", err)
+		return nil, err
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		log.Printf("Puppet: Error opening error pipe to puppet command: %v", err)
+		return nil, err
+	}
+
+	if err := cmd.Start(); err != nil {
+		log.Printf("Puppet: Error starting puppet command: %v", err)
+		return nil, err
+	}
+
+	// XXX: the current implementation is likely prone to fail
+	// as soon as the YAML data overflows the buffer.
+	data := make([]byte, PuppetYAMLBufferSize)
+	var result []byte
+	for err == nil {
+		var count int
+		count, err = stdout.Read(data)
+		if err != nil && err != io.EOF {
+			log.Printf("Puppet: Error reading YAML data from puppet: %v", err)
+			return nil, err
+		}
+		// Slicing down to the number of actual bytes is important, the YAML parser
+		// will choke on an oversized slice. http://stackoverflow.com/a/33726617/3356612
+		result = append(result, data[0:count]...)
+	}
+	if global.DEBUG {
+		log.Printf("Puppet: read %v bytes of data from puppet", len(result))
+	}
+	for scanner := bufio.NewScanner(stderr); scanner.Scan(); {
+		log.Printf("Puppet: (output) %v", scanner.Text())
+	}
+	if err := cmd.Wait(); err != nil {
+		log.Printf("Puppet: Error: puppet command did not complete: %v", err)
+		return nil, err
+	}
+
+	return result, nil
+}
+
+// ParseConfigFromPuppet takes a special puppet param string and config and
+// returns the graph configuration structure.
+func ParseConfigFromPuppet(puppetParam, puppetConf string) *gconfig.GraphConfig {
+	var puppetConfArg string
+	if puppetConf != "" {
+		puppetConfArg = "--config=" + puppetConf
+	}
+
+	var cmd *exec.Cmd
+	if puppetParam == "agent" {
+		cmd = exec.Command("puppet", "mgmtgraph", "print", puppetConfArg)
+	} else if strings.HasSuffix(puppetParam, ".pp") {
+		cmd = exec.Command("puppet", "mgmtgraph", "print", puppetConfArg, "--manifest", puppetParam)
+	} else {
+		cmd = exec.Command("puppet", "mgmtgraph", "print", puppetConfArg, "--code", puppetParam)
+	}
+
+	log.Println("Puppet: launching translator")
+
+	var config gconfig.GraphConfig
+	if data, err := runPuppetCommand(cmd); err != nil {
+		return nil
+	} else if err := config.Parse(data); err != nil {
+		log.Printf("Puppet: Error: Could not parse YAML output with Parse: %v", err)
+		return nil
+	}
+
+	return &config
+}
+
+// PuppetInterval returns the graph refresh interval from the puppet configuration.
+func PuppetInterval(puppetConf string) int {
+	if global.DEBUG {
+		log.Printf("Puppet: determining graph refresh interval")
+	}
+	var cmd *exec.Cmd
+	if puppetConf != "" {
+		cmd = exec.Command("puppet", "config", "print", "runinterval", "--config", puppetConf)
+	} else {
+		cmd = exec.Command("puppet", "config", "print", "runinterval")
+	}
+
+	log.Println("Puppet: inspecting runinterval configuration")
+
+	interval := 1800
+	data, err := runPuppetCommand(cmd)
+	if err != nil {
+		log.Printf("Puppet: could not determine configured run interval (%v), using default of %v", err, interval)
+		return interval
+	}
+	result, err := strconv.ParseInt(strings.TrimSpace(string(data)), 10, 0)
+	if err != nil {
+		log.Printf("Puppet: error reading numeric runinterval value (%v), using default of %v", err, interval)
+		return interval
+	}
+
+	return int(result)
+}

recwatch/configwatch.go

@@ -0,0 +1,134 @@
+// Mgmt
+// Copyright (C) 2013-2016+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package recwatch
+
+import (
+	"log"
+	"sync"
+
+	"github.com/purpleidea/mgmt/global"
+)
+
+// ConfigWatcher returns events on a channel anytime one of its files events.
+type ConfigWatcher struct {
+	ch        chan string
+	wg        sync.WaitGroup
+	closechan chan struct{}
+	errorchan chan error
+}
+
+// NewConfigWatcher creates a new ConfigWatcher struct.
+func NewConfigWatcher() *ConfigWatcher {
+	return &ConfigWatcher{
+		ch:        make(chan string),
+		closechan: make(chan struct{}),
+		errorchan: make(chan error),
+	}
+}
+
+// Add new file paths to watch for events on.
+func (obj *ConfigWatcher) Add(file ...string) {
+	if len(file) == 0 {
+		return
+	}
+	if len(file) > 1 {
+		for _, f := range file { // add all the files...
+			obj.Add(f) // recurse
+		}
+		return
+	}
+	// otherwise, add the one file passed in...
+	obj.wg.Add(1)
+	go func() {
+		defer obj.wg.Done()
+		ch := ConfigWatch(file[0])
+		for {
+			select {
+			case e := <-ch:
+				if e != nil {
+					obj.errorchan <- e
+					return
+				}
+				obj.ch <- file[0]
+				continue
+			case <-obj.closechan:
+				return
+			}
+		}
+	}()
+}
+
+// Error returns a channel of errors that notifies us of permanent issues.
+func (obj *ConfigWatcher) Error() <-chan error {
+	return obj.errorchan
+}
+
+// Events returns a channel to listen on for file events. It closes when it is
+// emptied after the Close() method is called. You can test for closure with the
+// f, more := <-obj.Events() pattern.
+func (obj *ConfigWatcher) Events() chan string {
+	return obj.ch
+}
+
+// Close shuts down the ConfigWatcher object. It closes the Events channel after
+// all the currently pending events have been emptied.
+func (obj *ConfigWatcher) Close() {
+	if obj.ch == nil {
+		return
+	}
+	close(obj.closechan)
+	obj.wg.Wait() // wait until everyone is done sending on obj.ch
+	//obj.ch <- "" // send finished message
+	close(obj.ch)
+	obj.ch = nil
+	close(obj.errorchan)
+}
+
+// ConfigWatch writes on the channel every time an event is seen for the path.
+func ConfigWatch(file string) chan error {
+	ch := make(chan error)
+	go func() {
+		recWatcher, err := NewRecWatcher(file, false)
+		if err != nil {
+			ch <- err
+			close(ch)
+			return
+		}
+		defer recWatcher.Close()
+		for {
+			if global.DEBUG {
+				log.Printf("Watching: %v", file)
+			}
+			select {
+			case event, ok := <-recWatcher.Events():
+				if !ok { // channel is closed
+					close(ch)
+					return
+				}
+				if err := event.Error; err != nil {
+					ch <- err
+					close(ch)
+					return
+				}
+				ch <- nil // send event!
+			}
+		}
+		//close(ch)
+	}()
+	return ch
+}