helpers.py 8.51 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# coding: utf-8
#
# Copyright (C) 2016 Savoir-faire Linux Inc. (<www.savoirfairelinux.com>).
#
#    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/>.
#

from __future__ import unicode_literals
20

21
import os
22
23
import socket

24
from getpass import getuser
25

26
27
from fabric.api import lcd, cd, roles, local, run
from fabric.colors import green
28
from fabric.context_managers import settings
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
from fabric.contrib.console import confirm
from fabric.contrib.files import exists

from default_vars import *

if path.exists(path.join(path.dirname(__file__), 'local_vars.py')):
    from local_vars import *


#####################################################################
# Function to manage differents users, hosts, roles, and variables  #
#####################################################################

# Get info of the current user and host
user_name = getuser()
host_name = local("hostname", capture=True)

# Set the env dict with the roles and the hosts
env.roledefs['local'] = ["{}@{}".format(user_name, host_name)]
48
env.roledefs['docker'] = ["drupalizer@{}".format(env.container_ip)]
49
50

env.builddir = path.join(env.workspace, 'build')
51
52
53
54
55
56
57
58
59

def is_core_profile(profile_name):
    return profile_name in ( 'minimal', 'standard', 'testing' )


if is_core_profile(env.site_profile):
  env.makefile = path.join(env.builddir, env.site_profile_makefile)
else:
  env.makefile = path.join(env.builddir, env.site_profile, env.site_profile_makefile)
60
env.site_drush_aliases = path.join(env.docker_site_root, 'sites/all/drush')
61

62

63
def fab_run(role="local", cmd=""):
64
65
66
67
68
69
70
    """
    Helper function to run the task locally or remotely
    :param role: the role to use for define the host
    :param cmd: the command to execute
    :return: the function to execute the command locally or remotely
    """
    if role == "local":
71
        return local(cmd)
72
    else:
73
        with settings(key_filename=fab_ssh_key()):
74
            return run(cmd)
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


def fab_cd(role, directory):
    """
    Helper function to manage the context locally or remotely
    :param role: the role to use for define the host
    :param directory: the directory of context
    :return: the function to manage the context locally or remotely
    """
    if role == "local":
        return lcd(directory)
    else:
        return cd(directory)


def fab_exists(role, directory):
    """
    Herlper function to check if a directory exist locally or remotely
    :param role: the role to use for define the host.
    :param directory: the directory to check
    :return: the function for check the existence of the directory locally or remotely
    """
    if role == "local":
        return path.exists(directory)
    else:
100
101
        with settings(key_filename=fab_ssh_key()):
            return exists(directory)
102
103
104
105
106
107
108
109
110


def fab_add_to_hosts(ip, site_hostname):
    """
    Helper function to add the ip and hostname to /etc/hosts
    :param ip:
    :param site_hostname:
    :return:
    """
111
112
113
    if not site_hostname:
        return

114
115
116
    if confirm(green('Do you want add to the /etc/hosts the line "{}    {}"? '
                     'If you say yes you will be able to visit the site using a more frienldy url '
                     '"http://{}".'.format(ip, site_hostname, site_hostname))):
117

118
119
120
121
122
123
124
125
126
127
128
129
130
131
        # Add if not find the comment "# Docker auto-added host" to the file /etc/hosts
        local('grep "# Docker auto-added host" /etc/hosts > /dev/null || '
              'sudo sed -i "$ a # Docker auto-added host" /etc/hosts')

        # Add the ip address and hostname after the comment "# Docker auto-added host"
        local('sudo sed -i "/# Docker auto-added host/a {}     {}" /etc/hosts'.format(ip, site_hostname))


def fab_remove_from_hosts(site_hostname):
    """
    Helper function to remove the ip  and the hostname to /etc/hosts
    :param site_hostname:
    :return:
    """
132
133
134
    if not site_hostname:
        return

135
136
137
138
    print(green('Enter your password to remove the {} from your /etc/hosts file'.format(site_hostname)))
    local('sudo sed -i "/{}/d" /etc/hosts'.format(site_hostname))


139
def fab_update_container_ip(container_ip):
140
141
142
    local('sed -i "/env.container_ip/d" {}'.format(fab_path('local_vars.py')))
    local('sed -i "/# Docker auto-added container IP/a env.container_ip = \'{}\'" {}'.format(''.join(container_ip), fab_path('local_vars.py')))

143
144
145
    # Redeclare 'docker' role with updated IP
    env.roledefs['docker'] = ["drupalizer@{}".format(env.container_ip)]

146
147
148
    if os.path.exists(fab_path('local_vars.pyc')):
        # Clear cached bytecode file
        os.remove(fab_path('local_vars.pyc'))
149
150


151
152
153
154
155
156
157
158
159
160
161
def fab_update_hosts(ip, site_hostname):
    """
    Helper function to update the file /etc/hosts
    :param ip:
    :param site_hostname:
    :return:
    """
    fab_remove_from_hosts(site_hostname)
    fab_add_to_hosts(ip, site_hostname)


162
def hook_execute(cmds=env.hook_post_install, role='docker'):
163
164
165
166
167
168
169
170
171
    """
    Execute a list of drush commands after the installation or update process
    :param role Default 'role' where to run the task
    :param cmds Drush commands to run, default to POST_INSTALL, it could be POST_UPDATE too.
    """
    for cmd in cmds:
        with fab_cd(role, env.docker_site_root):
            fab_run(role, cmd)

172

173
def copy_public_ssh_keys(role='local'):
174
175
176
177
    """
    Copy your public SSH keys to use it in the docker container to connect to it using ssh protocol.
    :param role Default 'role' where to run the task
    """
178
    with fab_cd(role, env.workspace):
179
        fab_run(role, 'cp ~/.ssh/id_rsa.pub conf/')
180
        print green('Public SSH key copied successful to {}/conf directory'.format(env.workspace))
181
182


183
def update_profile(role='local'):
184
185
186
187
188
189
190
191
192
193
    """
    Update or clone the installation profile specified in the configuration file.
    The build file included will be used to build the application.
    """
    if fab_exists(role, '{}/{}'.format(env.builddir, env.site_profile)):
        with fab_cd(role, path.join(env.builddir, env.site_profile)):
            fab_run(role, 'git checkout . && git pull')
            print green('{} installation profile updated in {}/{}'.format(env.site_profile, env.builddir, env.site_profile))
    else:
        with fab_cd(role, env.builddir):
194
            fab_run(role, 'git clone --branch={} {} {}'.format(env.site_profile_branch, env.site_profile_repo, env.site_profile))
195
196
197
198
            print green('{} installation profile cloned in {}/{}'.format(env.site_profile, env.builddir, env.site_profile))


@roles('docker')
199
def init_db(role='docker'):
200
201
202
    """
    Create a database and a user that can access it.
    """
203
    container_ip = local('docker inspect -f "{{{{.NetworkSettings.IPAddress}}}}" '
204
                                                 '{}_container'.format(env.project_name), capture=True)
205

206
207
    docker_iface_ip = [(s.connect((container_ip, 80)), s.getsockname()[0], s.close())
                                   for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]
208
209
210
211

    fab_run(role, 'mysql -uroot -e "CREATE DATABASE IF NOT EXISTS {}; GRANT ALL PRIVILEGES ON {}.* TO '
                  '\'{}\'@\'localhost\' IDENTIFIED BY \'{}\'; GRANT ALL PRIVILEGES ON {}.* TO \'{}\'@\'{}\' '
                  'IDENTIFIED BY \'{}\'; FLUSH PRIVILEGES;"'.format(env.site_db_name, env.site_db_name, env.site_db_user, env.site_db_pass,
212
                                                                    env.site_db_name, env.site_db_user, docker_iface_ip, env.site_db_user))
213
214
215
216
217
218
219
220
221

def fab_path(filename):
    """
    Returns the full path a file relative to the location of fabfile.

    :param filename Name of the file to compose path from.
    """
    path = os.path.dirname(os.path.abspath(__file__))
    return os.path.abspath('{0}/{1}'.format(path, filename))
222
223
224
225
226
227
228
229
230
231
232
233

def fab_ssh_key():
    """
    Returns the full path to default RSA key for SSH connections.

    This helper checks and (if necessary) fixes filesystem permissions on the
    RSA key file to make sure that SSH does not ignore keys accessible by other
    users.
    """
    path = fab_path('docker/ssh/id_rsa')
    local('chmod 600 {}'.format(path))
    return path