Esempio n. 1
0
 def manage(self, command):
     """
     Django manage.py command execution. Local safe - could be used in cuisine_local() block.
     """
     with cd(self.src_root):
         with self.virtualenv_safe():
             print ("admin command dir %s" % cuisine.run("pwd"))
             cuisine.run("django-admin.py %s --pythonpath=%s" % (command, self.src_root))
Esempio n. 2
0
    def upload_code(self, update_submodules=True):
        self.before_upload_code()

        # we need to ensure the directory is open for writing
        with cuisine_sudo():
            dir_attribs(self.remote_project_path, mode="777")

        temp_dir_prefix = "django_temp_"

        # zip and upload file
        temp_dir = temp_dir_prefix + self.project_name + "_" + timestamp_str()

        temp_remote_path = path(remote_home()).joinpath("tmp").joinpath(temp_dir)
        temp_local_path = path(self.project_local_path).joinpath(temp_dir)
        local_dir_ensure(temp_local_path)
        with cuisine_sudo():
            dir_ensure(temp_remote_path, recursive=True, mode="666")

        files = self.scm.local_archive(temp_local_path, include_submodules=update_submodules)

        # upload files
        for dir, file in files.iteritems():
            local_archive_path = temp_local_path.joinpath(file)
            remote_archive_path = temp_remote_path.joinpath(file)
            operations.put(str(local_archive_path), str(temp_remote_path), use_sudo=True)
            local_file_delete(local_archive_path)

        # reset project dir
        self.reset_project_dir()

        # unpack files
        for dir, file in files.iteritems():
            remote_archive_path = temp_remote_path.joinpath(file)

            # unzip file
            with cuisine_sudo():
                if self.webserver:
                    self.webserver.stop()

                extdir = path(self.remote_project_path).joinpath(dir).abspath()
                dir_ensure(extdir, recursive=True, mode="777")
                file_unzip(remote_archive_path, extdir)
                file_delete(remote_archive_path)

        cuisine.run("cd %s" % self.src_root)
        cuisine.run("pwd")

        with cuisine_sudo():
            cuisine.dir_attribs(self.remote_project_path, mode="777", recursive=True)

        for precomp in self.precompilers:
            precomp.compile()

        # clear old archives
        local_dirs_delete(self.project_local_path, "%s%s.*" % (temp_dir_prefix, self.project_name))

        ## upload ends here
        self.after_upload_code()
Esempio n. 3
0
    def media_restore_local_latest(self):
        dump_basename = self.latest_media_dump_basename()
        dump_local_path = self.local_media_dump_dir.joinpath(dump_basename)

        dir_delete(self.local_media_root)
        dir_ensure(self.local_media_root)

        with cd(self.local_media_root):
            run("tar -xvzf %s" % dump_local_path)
Esempio n. 4
0
File: mac.py Progetto: gsstver/bount
    def backup_database(self, file_name=''):
        filepath = path(self.backup_path).joinpath(self._create_db_backup_name() if file_name == '' else file_name)

        dump_command = "%s/pg_dump -O -x %s -U %s -w -h %s" % (self.bin_path, self.database_name, self.user, self.host)

        if self.use_zip:
            command = "%s | gzip > %s" % (dump_command, filepath)
        else:
            command = "%s > %s" % (dump_command, filepath)
        run(command)
Esempio n. 5
0
    def configure_webserver(self, name, config, delete_other_sites=False):
        if delete_other_sites:
            with cuisine_sudo():
                clear_dir('/etc/apache2/sites-enabled')

        with cuisine_sudo():
            cuisine.file_write('/etc/apache2/sites-enabled/%s' % name, config)
            run("ln -fs /etc/apache2/mods-available/rewrite.load /etc/apache2/mods-enabled/rewrite.load")
            run("ln -s /etc/apache2/mods-available/ssl.load /etc/apache2/mods-enabled/ssl.load")

            print("Apache configured\n%s" % config)
Esempio n. 6
0
    def upload_code(self, update_submodules=True):
        if self.webserver:
            self.webserver.stop()

        self.before_upload_code()

        # we need to ensure the directory is open for writing
        with cuisine_sudo():
            dir_attribs(self.remote_project_path, mode='777')

        self.clear_remote_project_path_save_site()

        temp_dir_prefix = 'django_temp_'

        # zip and upload file
        temp_dir = temp_dir_prefix + self.project_name + '_' + timestamp_str()

        temp_remote_path = path(self.remote_project_path).joinpath(temp_dir)
        temp_local_path = path(self.project_local_path).joinpath(temp_dir)
        local_dir_ensure(temp_local_path)
        dir_ensure(temp_remote_path)

        files = self.scm.local_archive(temp_local_path, include_submodules=update_submodules)

        for dir, file in files.iteritems():
            local_archive_path = temp_local_path.joinpath(file)
            remote_archive_path = temp_remote_path.joinpath(file)
            put(str(local_archive_path), str(temp_remote_path), use_sudo=True)
            local_file_delete(local_archive_path)

            #unzip file
            with cuisine_sudo():
                extdir = path(self.remote_project_path).joinpath(dir).abspath()
                dir_ensure(extdir, recursive=True, mode='777')
                file_unzip(remote_archive_path, extdir)
                file_delete(remote_archive_path)

        cuisine.run("cd %s" % self.src_root)
        cuisine.run("pwd")

        with cuisine_sudo():
            cuisine.dir_attribs(self.remote_project_path, mode="777", recursive=True)

        for precomp in self.precompilers:
            precomp.compile()

        # clear old archives
        local_dirs_delete(self.project_local_path, '%s%s.*' % (temp_dir_prefix, self.project_name))

        ## upload ends here
        self.after_upload_code()

        if self.webserver:
            self.webserver.start()
Esempio n. 7
0
    def init_database(self, init_sql_file, delete_if_exists=False, unzip=False):
        self.create_database(delete_if_exists)
        if unzip:
            command = "cat %s | gunzip | psql %s -w -U %s"
        else:
            command = "cat %s | psql %s -w -U %s"

        with self.pg_pass():
            run(command % (init_sql_file, self.database_name, self.user))

        sudo_pipeline("echo GRANT ALL ON SCHEMA public TO %s | psql" % self.user, user=self.superuser_login)
        sudo_pipeline("echo ALTER DATABASE %s OWNER TO %s | psql" % (self.database_name, self.user), user=self.superuser_login)
Esempio n. 8
0
    def download_media(self):
        media_dump_basename = "%s_media_%s.tar.gz" % (self.django.project_name, timestamp_str())
        media_dump_remote_path = "%s/%s" % (remote_home(), media_dump_basename)

        media_dump_local_path = self.local_media_dump_dir.joinpath(media_dump_basename)

        with cd(self.django.media_root): cuisine.run("tar -cvzf %s ." % media_dump_remote_path)
        cuisine.file_attribs(media_dump_remote_path, '777')

        get(media_dump_remote_path, media_dump_local_path)

        with cuisine_sudo(): file_delete(media_dump_remote_path)
Esempio n. 9
0
    def setup(self):
        if not file_exists(self.lessc_path()):
            print("Installing Node and Less")
            cuisine.sudo("sudo apt-get --yes install python-software-properties")
            cuisine.sudo("sudo add-apt-repository ppa:chris-lea/node.js --yes")
            cuisine.sudo("sudo apt-get --yes update")
            cuisine.sudo("sudo apt-get --yes install nodejs")

            cuisine.run("curl http://npmjs.org/install.sh | sudo sh")

            with cd('~'):
                cuisine.run("npm install less")
        else:
            print ("Less is already installed")
Esempio n. 10
0
    def init(self, delete_if_exists, python_path=""):
        if self.use_virtualenv:
            virtualenv_full_path = path(self.virtualenv_path).joinpath(self.virtualenv_name)
            if cuisine.dir_exists(virtualenv_full_path) and delete_if_exists:
                dir_delete(virtualenv_full_path)

            with cuisine_sudo():
                pip_install(['virtualenv'])

            with cuisine_sudo():
                dir_ensure(self.virtualenv_path, recursive=True, mode=777)
                dir_attribs(self.virtualenv_path, mode=777, recursive=True)

            # make lib synlinks to install PIL correctly
            with cuisine_sudo():
                if not file_exists("/usr/lib/libfreetype.so"):
                    run("ln -sf /usr/lib/x86_64-linux-gnu/libfreetype.so /usr/lib/")

                if not file_exists("/usr/lib/libz.so"):
                    run("ln -sf /usr/lib/x86_64-linux-gnu/libz.so /usr/lib/")

                if not file_exists("/usr/lib/libjpeg.so"):
                    run("ln -sf /usr/lib/x86_64-linux-gnu/libjpeg.so /usr/lib/")

            with cd(self.virtualenv_path):
                run('VIRTUALENV_EXTRA_SEARCH_DIR="%s" && virtualenv %s' % (python_path, self.virtualenv_name))
Esempio n. 11
0
    def reset_project_dir(self):
        home_dir = remote_home()
        site_path_basename = path(self.remote_site_path).name
        with cuisine_sudo():
            cuisine.dir_ensure(self.remote_site_path, recursive=True, mode="777")
            cuisine.dir_ensure("%s/tmp" % home_dir, mode="777")
            dir_delete("%(home_dir)s/tmp/%(site_path_basename)s" % locals())
            cuisine.run("mv %(site_dir)s %(home_dir)s/tmp" % {"site_dir": self.remote_site_path, "home_dir": home_dir})

            clear_dir(self.remote_project_path)

            # restore site dir
            cuisine.run(
                "mv %(home_dir)s/tmp/%(site_dir_basename)s %(proj_path)s"
                % {"site_dir_basename": site_path_basename, "proj_path": self.remote_project_path, "home_dir": home_dir}
            )
Esempio n. 12
0
def ls_re(root_dir, regex):
    """
    Lists files in the dirs that match a reg ex
    """
    dir_list = [filename for filename in re.split('\\s+',cuisine.run('ls %s' % root_dir)) if filename]
    re_obj = re.compile(regex)
    new_dir_list = [dir for dir in dir_list if re_obj.match(dir)]
    return new_dir_list
Esempio n. 13
0
    def clear_remote_project_path_save_site(self):
        home_dir = remote_home()
        site_path_basename = path(self.remote_site_path).name
        with cuisine_sudo():
            cuisine.dir_ensure(self.remote_site_path, recursive=True, mode='777')
            cuisine.dir_ensure("%s/tmp" % home_dir, mode='777')
            dir_delete("%(home_dir)s/tmp/%(site_path_basename)s" % locals())
            cuisine.run('mv %(site_dir)s %(home_dir)s/tmp' % {'site_dir': self.remote_site_path, 'home_dir': home_dir})

            clear_dir(self.remote_project_path)


            #restore site dir
            cuisine.run('mv %(home_dir)s/tmp/%(site_dir_basename)s %(proj_path)s' % {
                'site_dir_basename': site_path_basename,
                'proj_path': self.remote_project_path,
                'home_dir': home_dir
            })
Esempio n. 14
0
File: mac.py Progetto: RuuPiE/bount
    def database_exists(self):
        query = "SELECT 1 AS result FROM pg_database WHERE datname='%s'" % self.database_name
        result = run(self.psql_command('template1', query))

        if "0" in result:
            return False
        elif "1" in result:
            return True
        else:
            print("Result: %s" % result)
            raise RuntimeError("Unknown PostgreSQL result: %s" % result)
Esempio n. 15
0
File: mac.py Progetto: RuuPiE/bount
    def restore_database(self, delete_if_exists=False):
        self.create_database(delete_if_exists)
        if self.use_zip:
            command = "cat %s | gunzip | %s"
        else:
            command = "cat %s | %s"


        init_sql_file = path(self.backup_path).joinpath(self.latest_db_dump_basename())

        return run(command % (init_sql_file, self.psql_command_db()))
Esempio n. 16
0
    def pg_pass(self):
        run("echo *:*:%s:%s:%s > ~/.pgpass" % (self.database_name, self.user, self.password))
        run("chmod 0600 ~/.pgpass")

        yield

        run("rm ~/.pgpass")
Esempio n. 17
0
    def version(self):
        version_info = cuisine.run("psql --version")
        version_line = version_info.split("\n")[0].strip()
#        assert len(version_line) > 7, "There's something wrong with Postgres version info: " + version_info
        return re.search("\\d+\\.\\d+\\.\\d+", version_line).group(0)
Esempio n. 18
0
 def test_full_version(self):
     cuisine.run = lambda arg: 'Python 2.6.6'
     tt = cuisine.run("python --version")
     a = self.python_manager.get_full_version()
     self.assertNotEquals(a, None)
     self.assertRegexpMatches(a, "^[\\d\\.]+$")
Esempio n. 19
0
def file_delete(file):
    cuisine.run("rm %s" % file)
Esempio n. 20
0
def dir_delete(dir_name):
    cuisine.run('rm -rf %s' % dir_name)
Esempio n. 21
0
 def status(self):
     result = run("service apache2 status")
     if "running" in result:
         return "running"
     else:
         return "stopped"
Esempio n. 22
0
def sym_link(file_from, file_to):
    cuisine.run("ln -s %s %s" % (file_from, file_to))
Esempio n. 23
0
def file_unzip(filename, extdir="."):
    cuisine.run("unzip %s -d %s" % (filename, extdir))
Esempio n. 24
0
File: mac.py Progetto: RuuPiE/bount
 def create_user(self):
     run("echo CREATE USER %s WITH PASSWORD \\'%s\\' | %s" %
         (self.user, self.password, self.psql_command(as_dba=True)))
Esempio n. 25
0
def file_delete(file, only_if_exists=True):
    if only_if_exists and not cuisine.file_exists(file):
        return
    cuisine.run("rm %s" % file)
Esempio n. 26
0
def python_egg_ensure(egg_name):
    cuisine.run("pip install %s" % egg_name)
Esempio n. 27
0
File: mac.py Progetto: RuuPiE/bount
 def psql(self, command, database="", as_dba=False):
     return run("echo \"%s\" | %s" % (command, self.psql_command(database, as_dba=as_dba)))
Esempio n. 28
0
def clear_dir(dir):
    cuisine.run("rm -rf %s/*" % dir)
    cuisine.run("rm -rf %s/.??*" % dir)
Esempio n. 29
0
 def get_version_pattern(self, pattern):
     ver_str = cuisine.run('python --version')
     regex = re.compile(pattern)
     match = regex.match(ver_str)
     version = match.group(1)
     return version
Esempio n. 30
0
File: mac.py Progetto: RuuPiE/bount
    def drop_database_connections(self):
#        self.psql("SELECT pg_terminate_backend(pg_stat_activity.procpid) FROM pg_stat_activity " \
#             "WHERE pg_stat_activity.datname = '%s';" % self.database_name)
#
        run("%s restart -D %s -w -m f" % (self.pg_ctl_path(), self.pgdata))