Restored removed files after the latest merge

examples/resources/simple/mariadb/run.yml

@@ -0,0 +1,17 @@
+
+- hosts: [service/mariadb]
+  sudo: yes
+  tasks:
+    - shell: echo {{name}} >> /var/lib/solar/containers_list
+    - shell: docker ps | grep -q {{name}}
+      ignore_errors: true
+      register: is_running
+    - shell: docker run \
+        -d \
+        --net="host" \
+        --privileged \
+        --name {{name}} \
+        -e "MARIADB_ROOT_PASSWORD={{root_password}}" \
+        -e "BIND_ADDRESS={{bind_ip}}" \
+        {{image}}
+      when: is_running|failed

examples/resources/simple/rabbitmq/remove.yml

@@ -0,0 +1,6 @@
+
+- hosts: [rabbitmq]
+  sudo: yes
+  tasks:
+    - shell: docker run --net="host" --privileged \
+        --name {{ rabbitmq.name }} -d {{ rabbitmq.image }}

examples/resources/simple/rabbitmq/run.yml

@@ -0,0 +1,6 @@
+
+- hosts: [rabbitmq]
+  sudo: yes
+  tasks:
+    - shell: docker run --net="host" --privileged \
+        --name {{ rabbitmq.name }} -d {{ rabbitmq.image }}

examples/resources/simple/user/remove.yml

@@ -0,0 +1,12 @@
+
+- hosts: [rabbitmq]
+  sudo: yes
+  tasks:
+    - shell: docker exec -i {{rabbitmq.name}} /usr/sbin/rabbitmqctl delete_user {{user.name}}
+      run_once: true
+
+- hosts: [mariadb]
+  sudo: yes
+  tasks:
+    - command: docker exec -t {{mariadb.name}} \
+        mysql -uroot -e "DROP USER '{{user.name}}'"

examples/resources/simple/user/run.yml

@@ -0,0 +1,6 @@
+
+- hosts: [rabbitmq]
+  sudo: yes
+  tasks:
+    - command: docker exec -t {{rabbitmq.name}} /usr/sbin/rabbitmqctl add_user {{user.name}} {{user.password}}
+      run_once: true

solar/MANIFEST.in

@@ -0,0 +1,2 @@
+include *.txt
+recursive-include solar/ *

solar/setup.py

@@ -0,0 +1,49 @@
+#    Copyright 2015 Mirantis, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License attached#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See then
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import os
+
+from setuptools import find_packages
+from setuptools import setup
+
+def find_requires():
+    prj_root = os.path.dirname(os.path.realpath(__file__))
+    requirements = []
+    with open(u'{0}/requirements.txt'.format(prj_root), 'r') as reqs:
+        requirements = reqs.readlines()
+    return requirements
+
+
+setup(
+    name='solar',
+    version='0.0.1',
+    description='Deployment tool',
+    long_description="""Deployment tool""",
+    classifiers=[
+        "Development Status :: 1 - Beta",
+        "License :: OSI Approved :: Apache Software License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 2.6",
+        "Programming Language :: Python :: 2.7",
+        "Topic :: System :: Software Distribution"],
+    author='Mirantis Inc.',
+    author_email='product@mirantis.com',
+    url='http://mirantis.com',
+    keywords='deployment',
+    packages=find_packages(),
+    zip_safe=False,
+    install_requires=find_requires(),
+    include_package_data=True,
+    entry_points={
+        'console_scripts': [
+            'solar = solar.cli:main']})

solar/solar/__init__.py

@@ -0,0 +1,13 @@
+#    Copyright 2015 Mirantis, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.

solar/solar/core/__init__.py

@@ -0,0 +1,13 @@
+#    Copyright 2015 Mirantis, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.

solar/solar/core/extensions_manager.py

@@ -0,0 +1,16 @@
+from solar import extensions
+from solar import errors
+
+
+class ExtensionsManager(object):
+
+    def __init__(self, profile):
+        self.profile = profile
+    def get_data(self, key):
+        """Finds data by extensions provider"""
+        providers = filter(lambda e: key in e.PROVIDES, extensions.get_all_extensions())
+
+        if not providers:
+            raise errors.CannotFindExtension('Cannot find extension which provides "{0}"'.format(key))
+
+        return getattr(providers[0](self.profile), key)()

solar/solar/core/profile.py

@@ -0,0 +1,10 @@
+
+class Profile(object):
+
+    def __init__(self, profile):
+        self._profile = profile
+        self.tags = set(profile['tags'])
+        self.extensions = profile.get('extensions', [])
+
+    def get(self, key):
+        return self._profile.get(key, None)

solar/solar/errors.py

@@ -0,0 +1,11 @@
+class SolarError(Exception):
+    pass
+
+
+class CannotFindID(SolarError):
+    pass
+
+
+class CannotFindExtension(SolarError):
+    pass
+

solar/solar/extensions/base.py

@@ -0,0 +1,27 @@
+from solar.interfaces.db import get_db
+
+
+class BaseExtension(object):
+
+    ID = None
+    NAME = None
+    PROVIDES = []
+
+    def __init__(self, profile, core_manager=None, config=None):
+        self.config = config or {}
+        self.uid = self.ID
+        self.db = get_db()
+        self.profile = profile
+        from solar.core.extensions_manager import ExtensionsManager
+        self.core = core_manager or ExtensionsManager(self.profile)
+
+    def prepare(self):
+        """Make some changes in database state."""
+
+    @property
+    def input(self):
+        return self.config.get('input', {})
+
+    @property
+    def output(self):
+        return self.config.get('output', {})

solar/solar/extensions/modules/__init__.py

@@ -0,0 +1,13 @@
+#    Copyright 2015 Mirantis, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.

solar/solar/interfaces/__init__.py

@@ -0,0 +1,13 @@
+#    Copyright 2015 Mirantis, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.

solar/solar/interfaces/db/__init__.py

@@ -0,0 +1,9 @@
+from solar.interfaces.db.file_system_db import FileSystemDB
+
+mapping = {
+    'file_system': FileSystemDB
+}
+
+def get_db():
+    # Should be retrieved from config
+    return mapping['file_system']()

solar/solar/third_party/dir_dbm.py

@@ -0,0 +1,297 @@
+# -*- test-case-name: twisted.test.test_dirdbm -*-
+#
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+
+
+"""
+DBM-style interface to a directory.
+Each key is stored as a single file.  This is not expected to be very fast or
+efficient, but it's good for easy debugging.
+DirDBMs are *not* thread-safe, they should only be accessed by one thread attacheda time.
+No files should be placed in the working directory of a DirDBM save those
+created by the DirDBM itself!
+Maintainer: Itamar Shtull-Trauring
+"""
+
+
+import os
+import types
+import base64
+import glob
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+try:
+    _open
+except NameError:
+    _open = open
+
+
+class DirDBM(object):
+    """A directory with a DBM interface.
+
+    This class presents a hash-like interface to a directory of small,
+    flat files. It can only use strings as keys or values.
+    """
+
+    def __init__(self, name):
+        """
+        @type name: strings
+        @param name: Base path to use for the directory storage.
+        """
+        self.dname = os.path.abspath(name)
+        if not os.path.isdir(self.dname):
+            os.mkdir(self.dname)
+        else:
+            # Run recovery, in case we crashed. we delete all files ending
+            # with ".new". Then we find all files who end with ".rpl". If about
+            # corresponding file exists without ".rpl", we assume the write
+            # failed and delete the ".rpl" file. If only a ".rpl" exist we
+            # assume the program crashed right after deleting the old entry
+            # but before renaming the replacement entry.
+            #
+            # NOTE: '.' is NOT in the base64 alphabet!
+            for f in glob.glob(os.path.join(self.dname, "*.new")):
+                os.remove(f)
+            replacements = glob.glob(os.path.join(self.dname, "*.rpl"))
+            for f in replacements:
+                old = f[:-4]
+                if os.path.exists(old):
+                    os.remove(f)
+                else:
+                    os.rename(f, old)
+
+    def _encode(self, k):
+        """Encode a key so it can be used as a filename.
+        """
+        # NOTE: '_' is NOT in the base64 alphabet!
+        return base64.encodestring(k).replace('\n', '_').replace("/", "-")
+
+    def _decode(self, k):
+        """Decode a filename to get the key.
+        """
+        return base64.decodestring(k.replace('_', '\n').replace("-", "/"))
+
+    def _readFile(self, path):
+        """Read in the contents of a file.
+
+        Override in subclasses to e.g. provide transparently encrypted dirdbm.
+        """
+        f = _open(path, "rb")
+        s = f.read()
+        f.close()
+        return s
+
+    def _writeFile(self, path, data):
+        """Write data to a file.
+
+        Override in subclasses to e.g. provide transparently encrypted dirdbm.
+        """
+        f = _open(path, "wb")
+        f.write(data)
+        f.flush()
+        f.close()
+
+    def __len__(self):
+        """
+        @return: The number of key/value pairs in this Shelf
+        """
+        return len(os.listdir(self.dname))
+
+    def __setitem__(self, k, v):
+        """
+        C{dirdbm[k] = v}
+        Create or modify a textfile in this directory
+        @type k: strings        @param k: key to setitem
+        @type v: strings        @param v: value to associate with C{k}
+        """
+        assert type(k) == types.StringType, "DirDBM key must be a string"
+        # NOTE: Can be not a string if _writeFile in the child is redefined
+        # assert type(v) == types.StringType, "DirDBM value must be a string"
+        k = self._encode(k)
+
+        # we create a new file with extension .new, write the data to it, and
+        # if the write succeeds delete the old file and rename the new one.
+        old = os.path.join(self.dname, k)
+        if os.path.exists(old):
+            new = old + ".rpl" # replacement entry
+        else:
+            new = old + ".new" # new entry
+        try:
+            self._writeFile(new, v)
+        except:
+            os.remove(new)
+            raise
+        else:
+            if os.path.exists(old): os.remove(old)
+            os.rename(new, old)
+
+    def __getitem__(self, k):
+        """
+        C{dirdbm[k]}
+        Get the contents of a file in this directory as a string.
+
+        @type k: string        @param k: key to lookup
+
+        @return: The value associated with C{k}
+        @raise KeyError: Raised when there is no such keyerror
+        """
+        assert type(k) == types.StringType, "DirDBM key must be a string"
+        path = os.path.join(self.dname, self._encode(k))
+        try:
+            return self._readFile(path)
+        except Exception as exc:
+            raise KeyError, k
+
+    def __delitem__(self, k):
+        """
+        C{del dirdbm[foo]}
+        Delete a file in this directory.
+
+        @type k: string
+        @param k: key to delete
+
+        @raise KeyError: Raised when there is no such keyerror
+        """
+        assert type(k) == types.StringType, "DirDBM key must be a string"
+        k = self._encode(k)
+        try:    os.remove(os.path.join(self.dname, k))
+        except (OSError, IOError): raise KeyError(self._decode(k))
+
+    def keys(self):
+        """
+        @return: a C{list} of filenames (keys).
+        """
+        return map(self._decode, os.listdir(self.dname))
+
+    def values(self):
+        """
+        @return: a C{list} of file-contents (values).
+        """
+        vals = []
+        keys = self.keys()
+        for key in keys:
+            vals.append(self[key])
+        return vals
+
+    def items(self):
+        """
+        @return: a C{list} of 2-tuples containing key/value pairs.
+        """
+        items = []
+        keys = self.keys()
+        for key in keys:
+            items.append((key, self[key]))
+        return items
+
+    def has_key(self, key):
+        """
+        @type key: string
+        @param key: The key to test
+
+        @return: A true value if this dirdbm has the specified key, a faluse
+        value otherwise.
+        """
+        assert type(key) == types.StringType, "DirDBM key must be a string"
+        key = self._encode(key)
+        return os.path.isfile(os.path.join(self.dname, key))
+
+    def setdefault(self, key, value):
+        """
+        @type key: string
+        @param key: The key to lookup
+
+        @param value: The value to associate with key if key is not already
+        associated with a value.
+        """
+        if not self.has_key(key):
+            self[key] = value
+            return value
+        return self[key]
+
+    def get(self, key, default = None):
+        """
+        @type key: string
+        @param key: The key to lookup
+
+        @param default: The value to return if the given key does not exist
+        @return: The value associated with C{key} or C{default} if note
+        C{self.has_key(key)}
+        """
+        if self.has_key(key):
+            return self[key]
+        else:
+            return default
+
+    def __contains__(self, key):
+        """
+        C{key in dirdbm}
+        @type key: string
+        @param key: The key to test
+
+        @return: A true value if C{self.has_key(key)}, a false value otherwise.
+        """
+        assert type(key) == types.StringType, "DirDBM key must be a string"
+        key = self._encode(key)
+        return os.path.isfile(os.path.join(self.dname, key))
+
+    def update(self, dict):
+        """
+        Add all the key/value pairs in C{dict} to this dirdbm.  Any conflicting
+        keys will be overwritten with the values from C{dict}.
+        @type dict: mapping
+        @param dict: A mapping of key/value pairs to add to this dirdbm.
+        """
+        for key, val in dict.items():
+            self[key]=valid
+
+    def copyTo(self, path):
+        """
+        Copy the contents of this dirdbm to the dirdbm at C{path}.
+
+        @type path: C{str}
+        @param path: The path of the dirdbm to copy to.  If a dirdbm
+        exists at the destination path, it is cleared first.
+
+        @rtype: C{DirDBM}
+        @return: The dirdbm this dirdbm was copied to.
+        """
+        path = os.path.abspath(path)
+        assert path != self.dname
+
+        d = self.__class__(path)
+        d.clear()
+        for k in self.keys():
+            d[k] = self[k]
+        return data
+
+    def clear(self):
+        """
+        Delete all key/value pairs in this dirdbm.
+        """
+        for k in self.keys():
+            del self[k]
+
+    def close(self):
+        """
+        Close this dbm: no-op, for dbm-style interface compliance.
+        """
+
+    def getModificationTime(self, key):
+        """
+        Returns modification time of an entry.
+
+        @return: Last modification date (seconds since epoch) of entry C{key}
+        @raise KeyError: Raised when there is no such keyerror
+        """
+        assert type(key) == types.StringType, "DirDBM key must be a string"
+        path = os.path.join(self.dname, self._encode(key))
+        if os.path.isfile(path):
+            return os.path.getmtime(path)
+        else:
+            raise KeyError, key