13 import config

    14 

    15 def get_export_path(version):

    16     base_path = os.path.join(env.base_export_path,env.export_prefix).rstrip("/")

    17     return os.path.expanduser(base_path) + "_%s" % (str(version))

    18 

    19 def clean_export_folder(path):

    20     print("Removing %s" % path)

    21     if os.path.isdir(path):

    22         shutil.rmtree(path, ignore_errors=True)

    23 

    24 def do_export_version(path, **export_keys):

    25     print("Export version %s " % (repr(export_keys)))

    26 

    27     for export_key, version in export_keys.items():

    28         export_path = os.path.join(path,export_key)

    29         

    30         repo_url = env.repos[export_key]

    31         url_part = urlparse.urlparse(repo_url)

    32         if url_part.scheme or url_part.netloc:

    33             # this is a remote repo. Let's clone first

    34             clone_path = os.path.join(path,'clone',export_keys)

    35             os.makedirs(clone_path)

    36             local("hg clone \"%s\" \"%s\"" % (repo_url,clone_path))

    37         else:

    38             clone_path = repo_url

    39         

    40         with lcd(clone_path):

    41             local("hg archive -r \'%s\' \"%s\"" % (str(version),export_path))

    42     

    43     print("Export version %s done"%repr(export_keys))

    44 

    45     

    46 def get_remote_env(remotepath, remotevirtualenvpath, platform_web_module, settings_key):

    47     activate_path = os.path.join(remotevirtualenvpath, "bin/activate")

    48     res = ""

    49     with prefix("source \"%s\"" % activate_path), prefix("export PYTHONPATH=\"%s\"" % remotepath), cd(remotepath):

    50         tempfilepath = run("mktemp -t ldtplatform.XXXXXX")

    51         with settings(warn_only=True):

    52             run("echo \"import os\" > %s" % (tempfilepath))

    53             map(lambda str: run("echo \"%s\" >> %s" % (str, tempfilepath)),

    54                 ["os.environ.setdefault('DJANGO_SETTINGS_MODULE', '%s.settings')" % (platform_web_module),

    55                  "from django.conf import settings",

    56                  "print settings.%s" % (settings_key)])

    57             res = run("python < %s" % (tempfilepath))

    58         run("rm -f \"%s\"" % (tempfilepath))

    59     return res

    60     

    61     

    62     

    63 def rsync_export(path, remotepath, filters):

    64     print("Rsync %s to %s",(path,remotepath))

    65     

    66     filter_option_str = "--progress --stats"

    67     if filters:

    68         filter_option_str += " " + " ".join(["--filter \"%s\"" % (f) for f in filters])

    69     

    70     run("mkdir -p \"%s\"" % remotepath)

    71     rsync_project(remotepath, local_dir=path, extra_opts=filter_option_str, delete=True)

    72     print("Rsync %s to %s done",(path,remotepath))

    73     

    74 def clean_rsync_folder(remotepath):

    75     print("clean rsync folder %s" % remotepath)

    76     run("rm -fr \"%s\"" % remotepath)

    77     

    78 def build_src(path):

    79     print("Build source dist at %s" % path)

    80     f = None

    81     try:

    82         f, pathname, description = imp.find_module("setup", [path])

    83         print(" 2 Build source dist at %s" % path)

    84         setup_mod = imp.load_module("setup", f, pathname, description)

    85         print(" 3 Build source dist at %s" % path)

    86     finally:

    87         if f:

    88             f.close()

    89         

    90     setup_mod.launch_setup("setup.py", ['sdist'])

    91     

    92     print("Build source dist at %s done" % path)

    93     

    94 

    95 def get_src_version(path):

    96     print("get src version at %s" % path)

    97     f = None

    98     try:

    99         f, pathname, description = imp.find_module("ldt", [path])

   100         ldt_mod = imp.load_module("ldt", f, pathname, description)

   101     finally:

   102         if f:

   103             f.close()

   104     version = ldt_mod.VERSION

   105     version_str = ldt_mod.get_version()

   106     

   107     return (version, version_str) 

   108     

   109 

   110 def sync_build(path):

   111     print("Sync build %s" % path)

   112     with cd(env.remote_path['ldt_base']):

   113         filename = os.path.basename(path)

   114         res_trans = put(path, os.path.join(env.remote_path['ldt_base'], filename))

   115         print("Sync build %s to %s" % (path,repr(res_trans)))

   116         return res_trans

   117 

   118 def remove_build(path):

   119     print("remove build build %s" % path)

   120     run("rm \"%s\"" % path)

   121         

   122 

   123 def install_build(remotepath, remotevirtualenvpath, module_to_uninstall= None):

   124     print("Install build %s in %s" % (remotepath, remotevirtualenvpath))

   125     activate_path = os.path.join(remotevirtualenvpath, "bin/activate")

   126     

   127     with prefix("source %s" % activate_path):

   128         if module_to_uninstall:

   129             with settings(warn_only=True):

   130                 run("pip uninstall -y %s" % module_to_uninstall)

   131         run("pip install \"%s\"" % remotepath)

   132 

   133 def collectstatic(remotepath, remotevirtualenvpath, platform_web_module):

   134     print("Collect static in %s with %s" % (remotepath, remotevirtualenvpath))

   135     remotestaticsitepath = get_remote_env(remotepath, remotevirtualenvpath, platform_web_module, "STATIC_ROOT")

   136     activate_path = os.path.join(remotevirtualenvpath, "bin/activate")

   137     with prefix("source \"%s\"" % activate_path), prefix("export PYTHONPATH=\"%s\"" % remotepath), cd(remotepath):

   138         #remocve old files optio -c of collect static fail !

   139         run("rm -fr \"%s\"" % (remotestaticsitepath))

   140         run("python manage.py collectstatic --noinput")

   141 

   142 def syncdb(remotepath, remotevirtualenvpath):

   143     activate_path = os.path.join(remotevirtualenvpath, "bin/activate")

   144     with prefix("source \"%s\"" % activate_path), prefix("export PYTHONPATH=\"%s\"" % remotepath), cd(remotepath):

   145         run("python manage.py syncdb --migrate --noinput")

   146         

   147 def create_config(export_path):    

   148     print("Create config from %s" % (export_path,))

   149     remotepath = env.remote_path['src']

   150     remote_config_path = os.path.join(remotepath, env.platform_web_module, "config.py")

   151     template_path = os.path.join(export_path, "src", env.platform_web_module, "config.py.tmpl")

   152     

   153     context = {

   154         'base_dir': os.path.join(remotepath, env.platform_web_module).rstrip("/")+"/",

   155         'asctime': '%(asctime)s',

   156         'levelname': '%(levelname)s',

   157         'message': '%(message)s',

   158         'module': '%(module)s',

   159     }

   160     context.update(env.config['web'])

   161     

   162     if not exists(remote_config_path, verbose=True):

   163         upload_template(template_path, remote_config_path, context=context)

   164 

   165 def export_version(**kwargs):

   166     print("export version %s" % (repr(kwargs)))

   167     

   168     export_path = get_export_path("_".join(["%s_%s" % (k,v) for k,v in kwargs.items()]))

   169     

   170     clean_export_folder(export_path)

   171     

   172     do_export_version(export_path,**kwargs)

   173     

   174     return export_path

   175 

   176 def do_create_virtualenv(remote_venv_export_path, remotevirtualenvpath):

   177     print("Create virtualenv export_path : %s - remote venvpath : %s" % (remote_venv_export_path, remotevirtualenvpath))

   178     activate_path = os.path.join(remotevirtualenvpath, "bin/activate")

   179     if "remote_baseline_venv" in env and env.remote_baseline_venv:

   180         prefix_str = "source \"%s\"" % os.path.join(env.remote_baseline_venv, "bin/activate")

   181     else:

   182         prefix_str = "echo"

   183     with settings(warn_only=True):

   184         run("rm -fr \"%s\"" % remotevirtualenvpath)

   185     run("mkdir -p \"%s\"" % remotevirtualenvpath)

   186     with prefix(prefix_str), cd(os.path.join(remote_venv_export_path,"virtualenv","web")):

   187         run("python create_python_env.py")

   188         run("python project-boot.py \"%s\"" % remotevirtualenvpath)

   189     with prefix("source \"%s\"" % activate_path):

   190         run("pip install -r \"%s\"" % os.path.join(remote_venv_export_path,"virtualenv","web","res","srvr_requirements.txt"))

   191 

   192 def do_sync_ldt(version, export_path):

   193     print("do_sync_ldt with version %s and path %s" % (version,export_path))

   194     

   195     ##

   196     src_path = export_path + "/src/ldt"

   197     build_src(src_path)

   198     (_,version_str) = get_src_version(src_path)

   199     build_path = os.path.join(src_path,"dist","ldt-%s.tar.gz" % version_str)

   200     sync_install_build(build_path, 'ldt')

   201         

   202 

   203 def sync_install_build(build_path, module_to_uninstall=None):

   204     res_trans = None

   205     try:

   206         res_trans = sync_build(build_path)

   207         install_build(res_trans[0], env.remote_path['virtualenv'], module_to_uninstall)        

   208     finally:

   209         if res_trans:

   210             remove_build(res_trans[0])

   211 

   212 

   213 def do_sync_web(version, export_path):

   214     print("do_sync_web with version %s and path %s" % (version,export_path))

   215     #sync web

   216     web_path = os.path.join(export_path,"web/") 

   217     rsync_export(web_path, env.remote_path['web'], env.rsync_filters['web'])

   218     #sync src

   219     src_path = os.path.join(export_path,"src/") 

   220     rsync_export(src_path, env.remote_path['src'], env.rsync_filters['src'])

   221         

   222     

   223 def check_folder_access():

   224     print("Check folder access")

   225     # get remote user

   226     for folder_path in env.folders:

   227         if not os.path.isabs(folder_path):

   228             folder_path = env.remote_path['web'].rstrip("/")+ "/" + folder_path

   229             with settings(warn_only=True):

   230                 if not exists(folder_path):

   231                     run("mkdir -p \"%s\"" % folder_path)

   232                 run("chown -R -c :%s \"%s\"" % (env.web_group, folder_path))

   233                 run("chmod -R -c g+w \"%s\"" % folder_path)

   253 

   254 @task

   255 def sync_ldt(version):

   256     print(green("sync ldt with version %s" % version))

   257     export_path = export_version(ldt=version)

   258     export_path_full = os.path.join(export_path,'ldt')

   259     do_sync_ldt(version, export_path_full)

   260     clean_export_folder(export_path)

   261     relaunch_server()