aboutsummaryrefslogtreecommitdiff
path: root/wqflask/utility/tools.py
blob: d82e478d93ad65b8f6c9b8d28fe7ea4406bbe2a6 (plain)
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
# Tools/paths finder resolves external paths from settings and/or environment
# variables

import os
import sys
import json

from wqflask import app

# Use the standard logger here to avoid a circular dependency
import logging
logger = logging.getLogger(__name__)

OVERRIDES = {}


def app_set(command_id, value):
    """Set application wide value"""
    app.config.setdefault(command_id, value)
    return value


def get_setting(command_id, guess=None):
    """Resolve a setting from the environment or the global settings in
    app.config, with valid_path is a function checking whether the
    path points to an expected directory and returns the full path to
    the binary command

      guess = os.environ.get('HOME')+'/pylmm'
      valid_path(get_setting('PYLMM_PATH',guess))

    first tries the environment variable in +id+, next gets the Flask
    app setting for the same +id+ and finally does an educated
    +guess+.

    In all, the environment overrides the others, next is the flask
    setting, then the guess. A valid path to the binary command is
    returned. If none is resolved an exception is thrown.

    Note that we do not use the system path. This is on purpose
    because it will mess up controlled (reproducible) deployment. The
    proper way is to either use the GNU Guix defaults as listed in
    etc/default_settings.py or override them yourself by creating a
    different settings.py file (or setting the environment).

    """
    def value(command):
        if command:
            # sys.stderr.write("Found "+command+"\n")
            app_set(command_id, command)
            return command
        else:
            return None

    # ---- Check whether environment exists
    # print("Looking for "+command_id+"\n")
    command = value(os.environ.get(command_id))
    if command is None or command == "":
        command = OVERRIDES.get(command_id)  # currently not in use
        if command is None:
            # ---- Check whether setting exists in app
            command = value(app.config.get(command_id))
            if command is None:
                command = value(guess)
                if command is None or command == "":
                    # print command
                    raise Exception(
                        command_id + ' setting unknown or faulty (update default_settings.py?).')
    # print("Set "+command_id+"="+str(command))
    return command


def get_setting_bool(id):
    v = get_setting(id)
    if v not in [0, False, 'False', 'FALSE', None]:
      return True
    return False


def get_setting_int(id):
    v = get_setting(id)
    if isinstance(v, str):
        return int(v)
    if v is None:
        return 0
    return v


def valid_bin(bin):
    if os.path.islink(bin) or valid_file(bin):
        return bin
    return None


def valid_file(fn):
    if os.path.isfile(fn):
        return fn
    return None


def valid_path(dir):
    if os.path.isdir(dir):
        return dir
    return None


def js_path(module=None):
    """
    Find the JS module in the two paths
    """
    try_gn = get_setting("JS_GN_PATH") + "/" + module
    if valid_path(try_gn):
        return try_gn
    try_guix = get_setting("JS_GUIX_PATH") + "/" + module
    if valid_path(try_guix):
        return try_guix
    raise "No JS path found for " + module + \
        " (if not in Guix check JS_GN_PATH)"


def reaper_command(guess=None):
    return get_setting("REAPER_COMMAND", guess)


def gemma_command(guess=None):
    return assert_bin(get_setting("GEMMA_COMMAND", guess))


def gemma_wrapper_command(guess=None):
    return assert_bin(get_setting("GEMMA_WRAPPER_COMMAND", guess))


def plink_command(guess=None):
    return assert_bin(get_setting("PLINK_COMMAND", guess))


def flat_file_exists(subdir):
    base = get_setting("GENENETWORK_FILES")
    return valid_path(base + "/" + subdir)


def flat_files(subdir=None):
    base = get_setting("GENENETWORK_FILES")
    if subdir:
        return assert_dir(base + "/" + subdir)
    return assert_dir(base)


def assert_bin(fn):
    if not valid_bin(fn):
        raise Exception("ERROR: can not find binary " + fn)
    return fn


def assert_dir(dir):
    if not valid_path(dir):
        raise Exception("ERROR: can not find directory " + dir)
    return dir


def assert_writable_dir(dir):
    try:
        fn = dir + "/test.txt"
        fh = open(fn, 'w')
        fh.write("I am writing this text to the file\n")
        fh.close()
        os.remove(fn)
    except IOError:
        raise Exception('Unable to write test.txt to directory ' + dir)
    return dir


def assert_file(fn):
    if not valid_file(fn):
        raise Exception('Unable to find file ' + fn)
    return fn


def mk_dir(dir):
    if not valid_path(dir):
        os.makedirs(dir)
    return assert_dir(dir)


def locate(name, subdir=None):
    """
    Locate a static flat file in the GENENETWORK_FILES environment.

    This function throws an error when the file is not found.
    """
    base = get_setting("GENENETWORK_FILES")
    if subdir:
        base = base + "/" + subdir
    if valid_path(base):
        lookfor = base + "/" + name
        if valid_file(lookfor):
            logger.info("Found: file " + lookfor + "\n")
            return lookfor
        else:
            raise Exception("Can not locate " + lookfor)
    if subdir:
        sys.stderr.write(subdir)
    raise Exception("Can not locate " + name + " in " + base)


def locate_phewas(name, subdir=None):
    return locate(name, '/phewas/' + subdir)


def locate_ignore_error(name, subdir=None):
    """
    Locate a static flat file in the GENENETWORK_FILES environment.

    This function does not throw an error when the file is not found
    but returns None.
    """
    base = get_setting("GENENETWORK_FILES")
    if subdir:
        base = base + "/" + subdir
    if valid_path(base):
        lookfor = base + "/" + name
        if valid_file(lookfor):
            logger.debug("Found: file " + name + "\n")
            return lookfor
    logger.info("WARNING: file " + name + " not found\n")
    return None


def tempdir():
    """
    Get UNIX TMPDIR by default
    """
    return valid_path(get_setting("TMPDIR", "/tmp"))


BLUE = '\033[94m'
GREEN = '\033[92m'
BOLD = '\033[1m'
ENDC = '\033[0m'


def show_settings():
    from utility.tools import LOG_LEVEL

    print(("Set global log level to " + BLUE + LOG_LEVEL + ENDC))
    log_level = getattr(logging, LOG_LEVEL.upper())
    logging.basicConfig(level=log_level)

    logger.info(OVERRIDES)
    logger.info(BLUE + "Mr. Mojo Risin 2" + ENDC)
    keylist = list(app.config.keys())
    print("runserver.py: ****** Webserver configuration - k,v pairs from app.config ******")
    keylist.sort()
    for k in keylist:
        try:
            print(("%s: %s%s%s%s" % (k, BLUE, BOLD, get_setting(k), ENDC)))
        except:
            print(("%s: %s%s%s%s" % (k, GREEN, BOLD, app.config[k], ENDC)))


# Cached values
GN_VERSION = get_setting('GN_VERSION')
HOME = get_setting('HOME')
SERVER_PORT = get_setting('SERVER_PORT')
WEBSERVER_MODE = get_setting('WEBSERVER_MODE')
GN2_BASE_URL = get_setting('GN2_BASE_URL')
GN2_BRANCH_URL = get_setting('GN2_BRANCH_URL')
GN_SERVER_URL = get_setting('GN_SERVER_URL')
SERVER_PORT = get_setting_int('SERVER_PORT')
SQL_URI = get_setting('SQL_URI')
LOG_LEVEL = get_setting('LOG_LEVEL')
LOG_LEVEL_DEBUG = get_setting_int('LOG_LEVEL_DEBUG')
LOG_SQL = get_setting_bool('LOG_SQL')
LOG_SQL_ALCHEMY = get_setting_bool('LOG_SQL_ALCHEMY')
LOG_BENCH = get_setting_bool('LOG_BENCH')
LOG_FORMAT = "%(message)s"    # not yet in use
USE_REDIS = get_setting_bool('USE_REDIS')
USE_GN_SERVER = get_setting_bool('USE_GN_SERVER')

GENENETWORK_FILES = get_setting('GENENETWORK_FILES')
JS_GUIX_PATH = get_setting('JS_GUIX_PATH')
assert_dir(JS_GUIX_PATH)
JS_GN_PATH = get_setting('JS_GN_PATH')
# assert_dir(JS_GN_PATH)

GITHUB_CLIENT_ID = get_setting('GITHUB_CLIENT_ID')
GITHUB_CLIENT_SECRET = get_setting('GITHUB_CLIENT_SECRET')
if GITHUB_CLIENT_ID != 'UNKNOWN' and GITHUB_CLIENT_SECRET:
    GITHUB_AUTH_URL = "https://github.com/login/oauth/authorize?client_id=" + \
                      GITHUB_CLIENT_ID + "&client_secret=" + GITHUB_CLIENT_SECRET
    GITHUB_API_URL = get_setting('GITHUB_API_URL')

ORCID_CLIENT_ID = get_setting('ORCID_CLIENT_ID')
ORCID_CLIENT_SECRET = get_setting('ORCID_CLIENT_SECRET')
ORCID_AUTH_URL = None
if ORCID_CLIENT_ID != 'UNKNOWN' and ORCID_CLIENT_SECRET:
    ORCID_AUTH_URL = "https://orcid.org/oauth/authorize?response_type=code&scope=/authenticate&show_login=true&client_id=" + \
                      ORCID_CLIENT_ID + "&client_secret=" + ORCID_CLIENT_SECRET + \
                          "&redirect_uri=" + GN2_BRANCH_URL + "n/login/orcid_oauth2"
    ORCID_TOKEN_URL = get_setting('ORCID_TOKEN_URL')

ELASTICSEARCH_HOST = get_setting('ELASTICSEARCH_HOST')
ELASTICSEARCH_PORT = get_setting('ELASTICSEARCH_PORT')
# import utility.elasticsearch_tools as es
# es.test_elasticsearch_connection()

SMTP_CONNECT = get_setting('SMTP_CONNECT')
SMTP_USERNAME = get_setting('SMTP_USERNAME')
SMTP_PASSWORD = get_setting('SMTP_PASSWORD')

REAPER_COMMAND = app_set("REAPER_COMMAND", reaper_command())
GEMMA_COMMAND = app_set("GEMMA_COMMAND", gemma_command())
assert(GEMMA_COMMAND is not None)
PLINK_COMMAND = app_set("PLINK_COMMAND", plink_command())
GEMMA_WRAPPER_COMMAND = gemma_wrapper_command()
TEMPDIR = tempdir()  # defaults to UNIX TMPDIR
assert_dir(TEMPDIR)

# ---- Handle specific JS modules
JS_GUIX_PATH = get_setting("JS_GUIX_PATH")
assert_dir(JS_GUIX_PATH)
assert_dir(JS_GUIX_PATH + '/cytoscape-panzoom')

CSS_PATH = JS_GUIX_PATH  # The CSS is bundled together with the JS
# assert_dir(JS_PATH)

JS_TWITTER_POST_FETCHER_PATH = get_setting(
    "JS_TWITTER_POST_FETCHER_PATH", js_path("javascript-twitter-post-fetcher"))
assert_dir(JS_TWITTER_POST_FETCHER_PATH)
assert_file(JS_TWITTER_POST_FETCHER_PATH + "/js/twitterFetcher_min.js")

JS_CYTOSCAPE_PATH = get_setting("JS_CYTOSCAPE_PATH", js_path("cytoscape"))
assert_dir(JS_CYTOSCAPE_PATH)
assert_file(JS_CYTOSCAPE_PATH + '/cytoscape.min.js')

# assert_file(PHEWAS_FILES+"/auwerx/PheWAS_pval_EMMA_norm.RData")