about summary refs log tree commit diff stats
path: root/tools/conf/srv/gitolite/deploy-web.sh
blob: 01e92ac33a16fe552f52ccdf59edac6c8ed7ee1c (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#!/bin/bash

pkg_path=$1

www_root="/srv/www"
www_user="nginx"
www_group="www"

pkg_file="${pkg_path}/project"
pkg_rm="${pkg_path}/deleted"
pkg_files="${pkg_path}/files"

if [ ! -f ${pkg_file} ]; then
    echo "Deploy web: invalid pkg_file ${pkg_file}"
    exit 1
fi

pkg_name=$(head -1 ${pkg_file})
pkg_new=$(head -3 ${pkg_file} | tail -1)
pkg_new7=$(echo ${pkg_new} | cut -c1-7)

pkg_www="${www_root}/${pkg_name}"
pkg_back="${pkg_www}/backup_deploy"
pkg_last="${pkg_www}/.last_deploy"

if [ ! -d ${pkg_www} ]; then
    echo "Deploy web: invalid pkg_www ${pkg_www}"
    exit 1
fi

# first backup all data
if [[ ! $(ls ${pkg_www} | grep -v "backup_deploy") = "" ]]; then
    if [ ! -d ${pkg_back} ]; then
        sudo -u ${www_user} mkdir -p ${pkg_back}
    fi
    backup_file="${pkg_back}/${pkg_name}-$(date '+%Y-%j-%H-%M-%S').tar.gz"
    echo "Deploy web: making backup ${backup_file}"
    sudo -u ${www_user} tar --exclude ${pkg_back} --xattrs -zcpf ${backup_file} ${pkg_www}
fi

# remove files and directories that have been deleted
if [ -f ${pkg_rm} ]; then

    echo "Deploy web: files to delete:"
    # first we delete files
    while read deleted_file; do
        deleted_file="${pkg_www}/${deleted_file}"
        if [ -f ${deleted_file} ]; then
            echo "file      rm ${deleted_file}"
            rm ${deleted_file}
        fi
    done <${pkg_rm}

    # delete directories
    while read deleted_file; do
        deleted_file="${pkg_www}/${deleted_file}"
        if [ -d ${deleted_file} ]; then
            echo "file      rm ${deleted_file}"
            rm ${deleted_file}
        fi
    done <${pkg_rm}

fi

# copy new files to destination
if [ -d ${pkg_files} ]; then
    echo "Deploy web: cp from ${pkg_files} to ${pkg_www}"
    sudo -u ${www_user} cp -r ${pkg_files}/* ${pkg_www}
fi

echo ${pkg_new} > ${pkg_last}
echo "Deploy: scripts/deployweb.sh ${pkg_name} ${pkg_new7} deployed."

#remove temporary package
rm -r ${pkg_path}
lass="n">Recipe, r).name << end(); for (int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { const instruction& inst = get(Recipe, r).steps.at(i); if (inst.is_label) continue; for (int j = 0; j < SIZE(inst.products); ++j) { if (is_literal(inst.products.at(j))) continue; if (inst.products.at(j).name != "0") continue; if (!is_space(inst.products.at(j))) { raise << "slot 0 should always have type address:array:location, but is '" << to_string(inst.products.at(j)) << "'\n" << end(); continue; } string_tree* s = property(inst.products.at(j), "names"); if (!s) { raise << "slot 0 requires a /names property in recipe '" << get(Recipe, r).name << "'\n" << end(); continue; } if (!s->atom) raise << "slot 0 should have a single value in /names, but got '" << to_string(inst.products.at(j)) << "'\n" << end(); const string& surrounding_recipe_name = s->value; if (surrounding_recipe_name.empty()) { raise << "slot 0 doesn't initialize its /names property in recipe '" << get(Recipe, r).name << "'\n" << end(); continue; } if (contains_key(Surrounding_space, r) && get(Surrounding_space, r) != get(Recipe_ordinal, surrounding_recipe_name)) { raise << "recipe '" << get(Recipe, r).name << "' can have only one 'surrounding' recipe but has '" << get(Recipe, get(Surrounding_space, r)).name << "' and '" << surrounding_recipe_name << "'\n" << end(); continue; } trace(9993, "name") << "lexically surrounding space for recipe " << get(Recipe, r).name << " comes from " << surrounding_recipe_name << end(); if (!contains_key(Recipe_ordinal, surrounding_recipe_name)) { raise << "can't find recipe providing surrounding space for '" << get(Recipe, r).name << "'; looking for '" << surrounding_recipe_name << "'\n" << end(); continue; } put(Surrounding_space, r, get(Recipe_ordinal, surrounding_recipe_name)); } } } //: Once surrounding spaces are available, transform_names uses them to handle //: /space properties. :(replace{} "int lookup_name(const reagent& r, const recipe_ordinal default_recipe)") int lookup_name(const reagent& x, const recipe_ordinal default_recipe) { if (!has_property(x, "space")) { if (Name[default_recipe].empty()) raise << "name not found: " << x.name << '\n' << end(); return Name[default_recipe][x.name]; } string_tree* p = property(x, "space"); if (!p || !p->atom) raise << "/space property should have exactly one (non-negative integer) value\n" << end(); int n = to_integer(p->value); assert(n >= 0); recipe_ordinal surrounding_recipe = lookup_surrounding_recipe(default_recipe, n); if (surrounding_recipe == -1) return -1; set<recipe_ordinal> done; vector<recipe_ordinal> path; return lookup_name(x, surrounding_recipe, done, path); } // If the recipe we need to lookup this name in doesn't have names done yet, // recursively call transform_names on it. int lookup_name(const reagent& x, const recipe_ordinal r, set<recipe_ordinal>& done, vector<recipe_ordinal>& path) { if (!Name[r].empty()) return Name[r][x.name]; if (contains_key(done, r)) { raise << "can't compute address of '" << to_string(x) << "' because\n" << end(); for (int i = 1; i < SIZE(path); ++i) { raise << path.at(i-1) << " requires computing names of " << path.at(i) << '\n' << end(); } raise << path.at(SIZE(path)-1) << " requires computing names of " << r << "..ad infinitum\n" << end(); return -1; } done.insert(r); path.push_back(r); transform_names(r); // Not passing 'done' through. Might this somehow cause an infinite loop? assert(!Name[r].empty()); return Name[r][x.name]; } recipe_ordinal lookup_surrounding_recipe(const recipe_ordinal r, int n) { if (n == 0) return r; if (!contains_key(Surrounding_space, r)) { raise << "don't know surrounding recipe of '" << get(Recipe, r).name << "'\n" << end(); return -1; } assert(contains_key(Surrounding_space, r)); return lookup_surrounding_recipe(get(Surrounding_space, r), n-1); } //: weaken use-before-set detection just a tad :(replace{} "bool already_transformed(const reagent& r, const map<string, int>& names)") bool already_transformed(const reagent& r, const map<string, int>& names) { if (has_property(r, "space")) { string_tree* p = property(r, "space"); if (!p || !p->atom) { raise << "/space property should have exactly one (non-negative integer) value in '" << r.original_string << "'\n" << end(); return false; } if (p->value != "0") return true; } return contains_key(names, r.name); } :(scenario missing_surrounding_space) % Hide_errors = true; def f [ local-scope x:num/space:1 <- copy 34 ] +error: don't know surrounding recipe of 'f' +error: f: can't find a place to store 'x' //: extra test for try_reclaim_locals() from previous layers :(scenario local_scope_ignores_nonlocal_spaces) def new-scope [ new-default-space x:&:num <- new number:type *x:&:num <- copy 34 return default-space:space ] def use-scope [ local-scope outer:space <- next-ingredient 0:space/names:new-scope <- copy outer:space return *x:&:num/space:1 ] def main [ 1:space/raw <- new-scope 2:num/raw <- use-scope 1:space/raw ] +mem: storing 34 in location 2