def cm::access | ( | i | ) |
Single entry point to access all cM functions. Input: { Set of global cM variables: cm_run_module_uoa - UOA of the module to run cm_action - module action (function) (cm_console) - by default, do not output anything except errors if 'txt' then output as plain text if 'web' then output for web (html, image, etc) if 'json' then output as json cm_web - if 'yes', function was called from web environment cm_web_preprocess - if 'yes', we in the preprocessing stage in the web environment, where we can still change the http headers, etc ... If cM Web access or fully remote access: cm_user_uoa - user UOA If requires user authentication in web environment! After authentication, passwords will be removed from the array cm_user_password - user password in plain text (not secure, usually used for web form authentication) cm_user_password1 - user password in SHA1 (more secure, can be stored in environment, session or cookies) cM authenicates by taking SHA1(cm_user_password1)... If access to remote repository or fully remote access: cm_remote_user_uoa - remote user UOA cm_remote_user_password - remote user password Set of parameters depending on the called module and action (function) } Output: { cm_return - return code = 0 if successful > 0 if error < 0 if warning (rarely used at this moment) (cm_error) - error text, if cm_return > 0 Set of output parameters depending on the called module and action (function) }
def cm::access_control | ( | i | ) |
Control access Input: { dcfg - cfg of the current entry module_uoa - module UOA of the entry module_uid - module UID of the entry data_uoa - data UOA of the entry key - 'read' or 'write' } Output: { cm_return - 0, if Ok; ==32 if access denied cm_error - if access is denied }
def cm::access_fe | ( | i | ) |
def cm::access_fe_as_string | ( | s | ) |
def cm::access_fe_from_cmd | ( | a | ) |
Front-end to single entry 'access' function from command line (bash, windows shell, etc) If cm_console=='', it will be set to 'txt' If cm_user_uoa and cm_user_password1 are not in input but in environment, they will be also used Input: cmd list that will be converted to array (See "access" function) Output: See "access" function
def cm::access_fe_through_cmd | ( | i | ) |
FGG TBD: Currently used only in cM web server. Should be cleaned and updated! Should check that tmp files are deleted! Main function to access cM through a command line (useful for web server, etc). Input: { ... - see "access" function from this module (cm_detach_console) - if 'yes', detach console (for installations or experiments) } Output: { cm_return - return code = 0 if successful cm_stdout - stdout cm_stderr - stderr }
def cm::array2cm | ( | a | ) |
Convert list to cm array cm_module_uoa cm_action A=B C=D ... @file1.json E=F ... -- <unparsed arguments> if extension of @file is .tmp, it will be deleted after read! Input: input array Output: { cm_return - return code = 0 if successful cm_array - array cm_console - if 'cm_console' in array, set it to the value of 'cm_console' parameter }
def cm::array2str | ( | i | ) |
def cm::auth_user | ( | i | ) |
Authenticate user Input: { cm_user_uoa - user UOA cm_user_password - user password in plain text (not secure, usually used for web form authentication) cm_user_password1 - user password in SHA1 (more secure, can be stored in environment, session or cookies) cM authenicates by taking SHA1(cm_user_password1)... cm_user_password2 - only should be set here by web environment! } Output: { cm_return - return code = 0 if authenticated (cm_error) - error text, if cm_return > 0 cm_user_cfg - user config if authenticated (to check groups, etc) cm_user_password2 - user password in SHA1(SHA1) cm_user_uid - user UID cm_user_uoa - user UOA cm_user_alias - user alias cm_user_path - user path }
def cm::auth_user_and_ini_cm | ( | i | ) |
Check if need to auth user, try to auth and set cM vars Input: { cm_user_uoa - user UOA cm_user_password - user password in plain text (not secure, usually used for web form authentication) cm_user_password1 - user password in SHA1 (more secure, can be stored in environment, session or cookies) cM authenicates by taking SHA1(cm_user_password1)... cm_user_password2 - only should be set here by web environment! } Output: { cm_return - return code = 0 if authenticated (cm_error) - error text, if cm_return > 0 If needed to auth or default user: cm_user_cfg - user config if authenticated (to check groups, etc) cm_user_password1 - user password in SHA1 cm_user_uid - user UID cm_user_uoa - user UOA cm_user_alias - user alias cm_user_path - user path cm_user_status - 'no_user', 'default', 'logged_in' or 'failed' }
def cm::check_cm_json | ( | i | ) |
def cm::check_global_writing | ( | i | ) |
def cm::cid2array | ( | i | ) |
def cm::convert_cm_array_to_uri | ( | i | ) |
Convert cM array to uri (convert various special parameters) Input: { cm_array - array to convert to uri } Output: { cm_return - return code (check "access" function for full description) (cm_error) - error text (check "access" function for full description) cm_string - converted string cm_string1 - converted string (for urlopen) }
def cm::convert_file_to_upload_string | ( | i | ) |
def cm::convert_iso_time_to_str | ( | i | ) |
def cm::convert_str_to_sha1 | ( | i | ) |
Convert string to sha1 Input: { cm_string - string } Output: { cm_return - return code >0 if not authentificated cm_string_sha1 - password in SHA1 (digest) cm_string_sha1_hex - password in SHA1 (digest in hex) cm_string_sha1_base64 - BASE64 (SHA1 digest) - compatible with htpasswd format }
def cm::convert_str_to_special | ( | s | ) |
def cm::convert_string_to_html | ( | i | ) |
def cm::convert_text_to_value | ( | i | ) |
def cm::copy_vars | ( | i | ) |
def cm::create_data_entry | ( | i | ) |
Create data entry Input: { cm_path - path to the repository cm_module_uoa - module UOA cm_data_uoa - data UOA (cm_data_uid) - if cm_data_uoa==alias, we can force a given UID through this variable (cm_array) - array to add to the entry If not set, the whole array will be added including all working variables - we do not suggest to do that (cm_add_default) - if 'yes', add default params from descriptions (module/kernel) (cm_update) - if 'yes', update entry (cm_description) - description of the data entry (cm_display_as_alias) - user readable alias to display instead of module:data (cm_skip_update_info) - if == 'yes', do not write 'cm_updated' (cm_note) - note about this data entry (cm_like) - if 'yes' add +1 for this user to the entry (cm_file_upload_tmp_uid) - normally generated automatically by web server when uploading files (cm_file_upload_name) - preffered uploaded file name (cm_file_upload_type) - type of file (if .zip, it will be automatically unziped) (cm_archive) - if file should be kept as archive ... - if 'cm_array' not present, add everything else from this array to the entry (lock_uid) - unlock data } Output: { cm_return - return code >0 if error -1 if entry exists cm_path - path to created data entry cm_uid - uid (from UOA) cm_alias - alias (from UOA) }
def cm::create_default_array_from_description | ( | i | ) |
def cm::create_entry | ( | i | ) |
Create an UOA entry directory structure. Input: { cm_path - path to a repository (cm_data_uoa) - data UOA (cm_data_uid) - if cm_data_uoa==alias, we can force a given UID through this variable (lock_uid) - UID of the aquired lock } Output: { cm_return - return code = 0 if created entry = -1 if already exist > 0 if error cm_path - path to data entry cm_uid - uid (from UOA) cm_alias - alias (from UOA) cm_uoa - alias or uid if alias=='' }
def cm::delete_alias | ( | i | ) |
def cm::delete_directory | ( | i | ) |
def cm::delete_entry | ( | i | ) |
Delete entry Input: { cm_path - path to the entry cm_path_module - part of the path with module cm_uid - uid (from UOA), needed to delete alias disambiguator if exists cm_alias - alias (from UOA), needed to delete alias disambiguator if exists } Output: { cm_return - return code >0 if error }
def cm::find_index_in_array | ( | i | ) |
Find index in array of formart [{cm_index:'a', ...}, {cm_index='b', ...}, ...] We use such array instead of simple associative array when we need to keep an order such as for actions ... Input: { cm_array - array of format cm_index - index } Output: { cm_return - return code = 0 if successful -1 if not found cm_array - sub-array with given index }
def cm::find_keys_by_prefix | ( | i | ) |
def cm::find_path_to_current_repository | ( | i | ) |
Finds local repository (recursively checks all upper directories until it finds the repository) Input: { cm_get_uid - if 'yes' load data to get UID besides UOA } Output: { cm_return - return code >0 if error -1 if doesn't exist cm_path - path to the local repository (cm_module_uoa) - module UOA of the current path (cm_module_uid) - module UID of the current path (cm_data_uoa) - data UOA of the current path (cm_data_uid) - data UID of the current path }
def cm::find_path_to_entry | ( | i | ) |
Find path to an UOA entry (check UID or alias). Input: { cm_path - path to a repository cm_data_uoa - data UOA } Output: { cm_return - return code = 0 if found path to entry = -1 if not found path to entry > 0 if error cm_path_orig - i['cm_path'] cm_path - path to data entry cm_uid - uid (from UOA) cm_alias - alias (from UOA) cm_uoa - alias or uid, if alias=='' }
def cm::find_path_to_work_repositories | ( | i | ) |
def cm::flatten_array | ( | i | ) |
Flatten array Any list item is converted to @number=value Any dict item is converted to #key=value # is always added at the beginning Input: { cm_array - full array prefix - prefix (for recursion) } Output: { cm_return - if =0, success cm_array - flattened array }
def cm::flatten_classification | ( | i | ) |
def cm::gen_cm_tmp_file | ( | i | ) |
def cm::gen_uid | ( | i | ) |
def cm::get_all_uoa | ( | i | ) |
Get a list of all entries in the repository Input: { cm_path - path to repository (cm_module_uoa) - module UOA. If =='', return available modules in the repository (or use cm_only_available_modules explicitly) cm_only_uid - 'yes' to show only UIDs (cm_classes_uoa) - prune by classes UOA (prune_data_uoa) - prune by data UOA (cm_only_available_modules) - if 'yes', return only available modules in a given repository (skip_data_cfg) - if 'yes', do not add data cfg (cm_admin) - if 'yes', override access control - only internal use, can not be used during web access (explicitly removed) } Output: { cm_return - return code = 0 if successful cm_array - list of UOA or only UID cm_mixed - list of {cm_uid, cm_alias, cm_uoa, cm_display_as_alias, cm_display_html, cm_data_obj_cfg} }
def cm::get_cm_version | ( | i | ) |
def cm::get_current_date_time | ( | i | ) |
def cm::get_data_description | ( | i | ) |
Get data entry description Input: { cm_run_module_uoa | cm_module_uoa - module UOA (cm_desc_key) - if this key is specified, take description from this key (cm_flat_desc_key) - if this flat key is specified, take description from this flat key (cm_action_key) - action key cm_which_action - action (cm_key) - if action is specified, use this key instead of default one } Output: { cm_return - return code >0 if error cm_data_desc - data description cm_params_default - data description ... - other parameters from load_data }
def cm::get_list_of_all_files | ( | i | ) |
Get a list of all files in a given directory recursively Input: { cm_path - path cm_path_ext - path extension limit - limit number of files (if huge directories) number - cur. number of files cm_all_files - if 'yes' do not ignore special files (like .cm) } Output: { cm_return - return code = 0 if successful cm_array - list of files }
def cm::get_value_by_flattened_key | ( | i | ) |
def cm::get_var | ( | a, | ||
p | ||||
) |
def cm::init | ( | i | ) |
def cm::is_uid | ( | str | ) |
def cm::is_windows | ( | ) |
def cm::load_array_from_file | ( | i | ) |
def cm::load_code | ( | i | ) |
def cm::load_data | ( | i | ) |
Load and cache cM data Input: { cm_module_uoa - UOA of the module cm_data_uoa - UOA of the data (cm_path) - path to repository (cm_path_array) - array of paths to search (lock_acquire) - if 'yes', acquire lock (lock_retry_num) - number of retries to acquire lock (default=6) (lock_retry_delay) - delay in sec before retrying to acquire lock (default=11) (lock_expire) - for how long to acquire lock (secs) (unlock_uid) - unlock data (FGG note: I changed lock_uid to unlock_uid not to interfere with update locking) (cm_admin) - if 'yes', override access control - only internal use, can not be used during web access (explicitly removed) } Output: { cm_return - return code = 0, if successful (cm_error) - error text if return code > 0 cm_data_obj - cM data object cm_path - path to data entry cm_path_module - path to module entry with this entry cm_path_repo - path to the repository of this entry cm_uid - uid (from UOA) cm_alias - alias (from UOA) cm_uoa - cm_data_uoa (alias or uid if alias=='') cm_module_uoa - module UOA cm_module_uid - module UID cm_display_as_alias - taken from the data cm_display_html - prepare display: "display as alias" or <I>alias</I> or UID (lock_uid) - UID of the aquired lock }
def cm::load_json_file | ( | i | ) |
def cm::load_module | ( | i | ) |
Load and cache cM module Input: { cm_module_uoa - UOA of the module (cm_path) } Output: { cm_return - return code = 0, if successful cm_code - python code object external_module - if 'yes', module is external cm_path - path to data entry cm_uid - uid (from UOA) cm_alias - alias (from UOA) }
def cm::merge_arrays | ( | i | ) |
def cm::merge_arrays_ll | ( | a, | ||
b | ||||
) |
def cm::prepare_cid | ( | i | ) |
Prepare cid Input: { (cm_repo_uoa) - repository UOA cm_run_module_uoa | cm_module_uoa - module UOA cm_data_uoa - data UOA } Output: { cm_return - 0 cm_string_uid - cid with only uid cm_string_with_repo_uid - cid with only uid cm_string_uoa - cid with alias or uid cm_string_with_repo_uoa - cid with alias or uid cm_repo_uid - cm_repo_uid cm_repo_uoa - cm_repo_uoa cm_module_uid - cm_module_uid cm_module_uoa - cm_module_uoa cm_data_uid - cm_data_uid cm_data_uoa - cm_data_uoa }
def cm::prepare_final_out | ( | i, | ||
j | ||||
) |
Prepare final output of cM access function depending on cm_console Input: i= { cm_return - return code (check "access" function for full description) (cm_error) - error text (check "access" function for full description) ... } j= { (cm_console) - cm_console (check "access" function for full description) (cm_output) - if !='', save output to file ... } Output: {}
def cm::print_for_con | ( | s | ) |
def cm::print_for_web | ( | s | ) |
def cm::remote_access | ( | i | ) |
Remote access to cM Input: { cm_remote_url - remote URL (cm_user_uoa) - (cm_user_password) - (cm_user_password1) - (remote_repo_uoa) (remote_pre_auth) - if 'yes', need standard http login/password pre-authentication (cm_remote_user_name) - remote username (cm_remote_user_password) - remote password (cm_web_module_uoa) - module to run (cm_web_action) - action to perform if =='download', prepare entry/file download through Internet (cm_save_to_file) - if cm_web_action==download, save output to this file ... - all other request parameters } Output: { cm_return - return code = 0 if successful > 0 if error < 0 if warning (rarely used at this moment) (cm_error) - error text, if cm_return > 0 }
def cm::replace_from_dict | ( | s, | ||
rep | ||||
) |
def cm::restore_flattened_array | ( | i | ) |
def cm::save_array_to_file_as_json | ( | i | ) |
def cm::save_flat_array_to_file | ( | i | ) |
def cm::set_print_mode | ( | i | ) |
def cm::set_value_by_flattened_key | ( | i | ) |
Set value in array using flattened key Input: { cm_array - array (it will be directly changed!) cm_key - flattened key (or not if doesn't start with #) cm_value - value to set cm_replace_in_keys - array with strings to replace in keys (used in forms to process # and @ through ^35^ and ^64^ for example) } Output: { cm_return - if =0, success cm_array - modified array }
def cm::str2cm | ( | i | ) |
def cm::substitute_str_in_file | ( | i | ) |
def cm::system | ( | i | ) |
System call with timeout (careful, may cause overheads) Input: { cmd - command line (timeout) - timeout in seconds (granularity 0.01 sec) - may cause overheads ... } Output: { cm_return - return code =0 if success =1 if timedout and killed (cm_error) - error text if return code > 0 cm_return_code - return code of a program }
Definition at line 2271 of file cm.py.
Referenced by cm_action().
def cm::web_print_array_for_debug | ( | i | ) |
string cm::cm_action_default = 'default' |
string cm::cm_json_with_text_sep = '*** ### --- CM JSON SEPARATOR --- ### ***' |
cm::cm_kernel = None |
string cm::cm_module_default = 'core' |
string cm::cm_module_default_access = 'access' |
string cm::cm_unparsed_sep = '--' |
string cm::env_cm_bin = 'CM_BIN' |
string cm::env_cm_cfg = 'CM_DEFAULT_CFG' |
string cm::env_cm_cfg_path = 'CM_DEFAULT_CFG_PATH' |
string cm::env_cm_default_repo = 'CM_DEFAULT_REPO' |
string cm::env_cm_local_repo = 'CM_LOCAL_REPO' |
string cm::env_cm_remote_repo_proxy_http = 'CM_REMOTE_REPO_PROXY_HTTP' |
string cm::env_cm_remote_repo_proxy_https = 'CM_REMOTE_REPO_PROXY_HTTPS' |
string cm::env_cm_root = 'CM_ROOT' |
string cm::env_cm_tmp = 'CM_TMP' |
string cm::env_cm_user_password = 'CM_USER_PASSWORD' |
string cm::env_cm_user_password1 = 'CM_USER_PASSWORD1' |
string cm::env_cm_user_uoa = 'CM_USER_UOA' |
dictionary cm::ini |
{ # This variable describes initialization of cM framework # -1 - not initalized # 0 - initialized # 1 - error during initialization 'init':-1, 'loaded_module_by_path':{}, 'loaded_module_by_path_last_modification':{}, 'loaded_data_by_path':{}, 'loaded_data_by_path_last_modification':{}, 'pcfg':'', 'cfg':{}, 'dcfg':{}, 'path':'', 'web':'no', 'web_auth':{}, 'web_style':{}, 'remote_repo':{} }
cm::print_on = True |
string cm::var_cm_cfg_default = 'default' |
string cm::var_cm_cfg_local = 'local' |
string cm::var_cm_data = 'data.json' |
string cm::var_cm_info = '.cm' |