cmx.py

Go to the documentation of this file.

#
# Collective Mind
#
# See cM LICENSE.txt for licensing details.
# See cM Copyright.txt for copyright details.
#
# Developer(s): (C) Grigori Fursin, started on 2011.09
#
# User friendly command line module

import sys
import os
import subprocess
import json
import copy
import re
import platform
import getpass

cmx_error='cMX error: '

# ============================================================================
def convert_relaxed_classes_to_uids(i):
    """
    Convert relaxed classes to UIDs

    Input:  {
              cm_list  - list with classes (wildcards * and ? can be used)
            }

    Output: {
              cm_return     = 0 - no errors
              cm_error      -     error text if cm_return>0
              cm_list_uids  - updated list of UIDs
              cm_list_match - match of classes, i.e. {"value from cm_list":{"cm_uid","alias"}}
            }
 
    """

    # Get all classes
    jj={'cm_run_module_uoa':'class',
        'cm_action':'list',
        'cm_console':'json'}
    r1=cm_access(jj)
    if r1['cm_return']>0: return r1

    # Check classes UID
    classes=[]
    match={}

    for w in i.get('cm_list',[]):
        if is_uid(w):
           classes.append(w)
        else:
           # Search for match
           w1=w.replace('*','.*')
           w1=w1.replace('?','.?')
           w2='.*'+w1+'$'
           found=False
           for q in r1['cm_mixed']:
               k=q.get('cm_display_as_alias','')
               k1=q.get('cm_uoa','')
               if (k!='' and re.match(w2,k)) or (k1!='' and re.match(w2,k1)):
                  classes.append(q['cm_uid'])
                  match[w]={'cm_uid':q['cm_uid'], 'alias':k}
                  found=True
                  break
           if not found:
              return {'cm_return':1, 'cm_error':'class "'+w+'" not found'}

    return {'cm_return':0, 'cm_list_uids':classes, 'cm_list_match':match}

# ============================================================================
def find_and_separate_flags(i):
    """
    Find flag of format flag=a(,b,c)
    and return list of values [a(,b,c)]

    Input:  {
              cm_list  - list with flags
              flags    - list of flags to match 
                         (to support equivalent flags like -c and --classes)
            }

    Output: {
              cm_return = 0 (for compatibility with cM)
              cm_found  - False, if not found
                          True,  if found
              cm_values - List of values
            }
 
    """

    l=i.get('cm_list',[])
    f=i.get('flags',[])

    rr={'cm_return':0, 'cm_found':False}

    for q in l:
        found=''
        for k in f:
            if q.startswith(k):
               found=q[len(k):]
               break
        
        if found!='':
           v=found.split(',')
           v1=[]
           for w in v:
               if w!='': v1.append(w)
           rr['cm_found']=True
           rr['cm_values']=v1

    return rr

# ============================================================================
def is_windows():
    """
    Is Windows?

    Input: None

    Output: True if Windows
    """

    win=False

    if platform.system().lower().startswith('win'):
       win=True

    return win

# ============================================================================
def gen_tmp_with_json(i):
    """
    Generate tmp file and put array as json there

    Input: array

    Output: filename
    """

    import tempfile

    nf,f = tempfile.mkstemp(suffix='.json')
    nf1=os.fdopen(nf,'wt')
    nf1.write(json.dumps(i))
    nf1.close()

    return f

# ============================================================================
def merge_array(a,b):
    """
    Add params from array b (in form x=y) to array a

    Input: a=original array
           b=array with params (in form x=y)

    Output: 
    """

    first=True
    for p in b:
        if p.startswith("@@"):
           jd=p[2:]
           if len(jd)<2:
              return {'cm_return':1, 'cm_error':'can\'t parse command line option '+p, 'cm_console':con}
           je=check_cm_json({'cm_json':jd})

           r=merge_arrays({'cm_array':a, 'cm_array1':je})
           a=r['cm_array']

        elif p.startswith("@"):
           name=p[1:]
           if len(name)<2:
              return {'cm_return':1, 'cm_error':'can\'t parse command line option '+p, 'cm_console':con}

           y=load_json_file({'cm_filename':name})
           if y['cm_return']==0:
              if name.endswith('.tmp'):
                 os.remove(name)   
              r=merge_arrays({'cm_array':a, 'cm_array1':y['cm_array']})
              a=r['cm_array']
        else:
           p1=p 
           p2=''
           q=p.find("=")
           if q>0:
              p1=p[0:q]
              if len(p)>q:
                p2=p[q+1:]

           a[p1]=p2

    return

# ============================================================================
def list2str(a):
    """
    Convert list to string

    Input: list

    Output: string 
    """

    r=''
    for x in a:
        if r!='': r+=' '
        r+=x

    return r

# ============================================================================
def is_uid(str):
    """
    Check if string is cM UID

    Input: string to check

    Output: True if UID, otherwise False
    """

    if len(str)!=16:
       return False

    pattern = r'[^\.a-f0-9]'
    if re.search(pattern, str.lower()):
        return False

    return True

# ============================================================================
def cid2array(i):
    """
    Convert cid to array
    Note that this function is different from 

    Input:  {
              cid      - in format (REPO_UOA:)KEY_UOA:DATA_UOA
              (prefix) - add prefic to output variables (<prefix>_repo_uoa:...)
            }

    Output: {
              prefix+'_repo_uoa'   - repo UOA
              prefix+'_module_uoa' - module UOA
              prefix+'_data_uoa'   - data UOA
            }
    """

    prefix='cm'
    if 'prefix' in i and i['prefix']!='': prefix=i['prefix']

    array={}
    if 'cid' in i and i['cid']!='':
        id=i['cid'].split(":")
        if (len(id)<2): 
            array[prefix+'_data_uoa']=id[0]
        elif (len(id)<3):
            array[prefix+'_module_uoa']=id[0]
            array[prefix+'_data_uoa']=id[1]
        elif (len(id)<4):
            array[prefix+'_repo_uoa']=id[0]
            array[prefix+'_module_uoa']=id[1]
            array[prefix+'_data_uoa']=id[2]
    return array

# ============================================================================
def return_flags(i):
    """
    Separate argv to flags (starting from '-' and the rest)

    Input:  {
              argv
            }

    Output: {
              flags - array with flags
              cmd   - "clean from flags" argv
            }
    """

    ii=copy.deepcopy(i)

    flags=[]
    for x in range(0, len(i)):
        y=i[x]
        if y.startswith('-'):
           flags.append(y)
           ii[x]='to_delete'

    ii1=[]
    for x in ii:
        if x!='to_delete':
           ii1.append(x)

    return {'cm_return':0, 'flags':flags, 'cmd':ii1}

# ============================================================================
def error_if_no_cur_repo(i):
    """
    If current path does not belong to repository, while command needs it,
    print error

    Input:  {}

    Output: {}
    """

    print cmx_error+'this command requires current path to belong to some repository!'

    return {'cm_return':0}

# ============================================================================
def check_cm_json(i):
    """
    Check if 'cm_json' exist in array and decode it

    Input:  {
              cm_json - array to check
            } 

    Output: {...} - returned array where cm_json is decoded
    """

    ii={}
    ii.update(i)

    if 'cm_json' in i:
       s=i['cm_json']
       s=s.replace('^22^', '"')
       s=s.replace('%22', '"')
       s=s.replace('%26quot;', '"')
       s=s.replace('&quot;', '"')
       success=False
       try:
          j=json.loads(s)
          success=True
       except:
          pass
       if success:
          del (ii['cm_json'])
          ii.update(j)

    return ii

# ============================================================================
def load_json_file(i):
    """
    Load json from file

    Input:  {
              cm_filename - file name with json
            }

    Output: {
              cm_return - return code = 0 if successful
              cm_array  - array from json file
            }
    """

    if 'cm_filename' not in i:
       return {'cm_return':1, 'cm_error':'parameter "cm_filename" is not defined'}

    try:
       f=file(i['cm_filename'])
    except Exception as e:
       return {'cm_return':1, 'cm_error':format(e)}

    try:
       array=json.loads(f.read())
    except Exception as e:
       f.close()
       return {'cm_return':1, 'cm_error':'problem loading array from file='+i['cm_filename']+' ('+format(e)+')'}

    f.close()

    return {'cm_return':0, 'cm_array': array}

# ============================================================================
def merge_arrays(i):
    """
    Intelligently merge cm_array with cm_array1

    Input:  {
              cm_array  - merge this array with cm_array1 (will be directly modified!)
              cm_array1 - cM array

    Output: {
              cm_return - return code = 0 if successful
              cm_array  - output array
            }
    """

    if 'cm_array' not in i: return {'cm_return':1, 'cm_error':'"cm_array" is not defined in "cm_kernel merge_arrays"'}
    if 'cm_array1' not in i: return {'cm_return':1, 'cm_error':'"cm_array1" is not defined in "cm_kernel merge_arrays"'}

    a=i['cm_array']
    b=i['cm_array1']

    for k in b:
        v=b[k]
        if type(v) is dict:
           if k not in a:
              a.update({k:b[k]})
           elif type(a[k])==dict:
              merge_arrays({'cm_array':a[k], 'cm_array1':b[k]})
           else:
              a[k]=b[k]
        elif type(v) is list:
#           if k not in a or type(a[k]) is not list: 
#              a[k]=[]
           a[k]=[]
           for y in v:
               a[k].append(y)
        else:
           a[k]=b[k]

    return {'cm_return':0, 'cm_array':a}

# ============================================================================
def 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
            }
    """
    obj={}
    con=''

    la=len(a)

    obj['cm_run_module_uoa']=cm_module_default
    obj['cm_action']=cm_action_default

    if la>0: obj['cm_run_module_uoa']=a[0]

    # Parsing
    for x in range(1, len(a)):
        p=a[x].rstrip()
        if p==cm_unparsed_sep:

           obj['cm_unparsed']=a[x+1:]
           break

        elif p.startswith("@@"):
           jd=p[2:]
           if len(jd)<2:
              return {'cm_return':1, 'cm_error':'can\'t parse command line option '+p, 'cm_console':con}
           je=check_cm_json({'cm_json':jd})
           obj.update(je)

        elif p.startswith("@"):
           name=p[1:]
           if len(name)<2:
              return {'cm_return':1, 'cm_error':'can\'t parse command line option '+p, 'cm_console':con}

           y=load_json_file({'cm_filename':name})
           if y['cm_return']>0: 

              ii={}; ii.update(y); ii.update({'cm_console':con})
              return ii

           if name.endswith('.tmp'):
              os.remove(name)   

           merge_arrays({'cm_array':obj, 'cm_array1':y['cm_array']})
        else:
           if x==1:
              obj['cm_action']=p
           else:
              p1=p 
              p2=''
              q=p.find("=")
              if q>0:
                 p1=p[0:q]
                 if len(p)>q:
                   p2=p[q+1:]

              obj[p1]=p2
              if p1=='cm_console': con=p2

    return {'cm_return':0, 'cm_array':obj, 'cm_console':con}

# ============================================================================
def str2cm(i):
    """
    Convert string to cM array

    Input:  string

    Output: {
              cm_return - return code = 0 if successful
              cm_array  - array
            }
    """
    a=i.split(' ')
    return array2cm(a)

# ============================================================================
def access_fe_as_string(s):
    """
    Front-end to single entry 'access' function as string (if someone finds it easier).

    Input:  string that will be converted to array (See "access" function).
    Output: See "access" function.
    """

    r=str2cm(s)
    if r['cm_return']>0: return r

    return cm_access(r['cm_array'])

# ============================================================================
def cm_access(i):
    """
    Call external cm and return json

    Input:  {
              cm_run_module_uoa - module UOA
              cm_action         - action (function) from the module

              cm_unparsed       - unparsed list to add to command line ...
              
              Set of parameters depending on the called module and action (function)
            }

    Output: {
              cm_return   - return code = 0 if successful
                                        > 0 if error
                                               99 - if couldn't process json from output
                                        < 0 if warning (rarely used at this moment)
              (cm_error)  - error text, if cm_return > 0
              (cm_stdout) - if no error, raw output
              (cm_stderr) - raw output of error stream

              Set of output parameters depending on the called module and action (function)
            }
    """

    # Check if cM module is in the input
    if 'cm_run_module_uoa' not in i:
       return {'cm_return':1, 'cm_error':'no module specified'}
    module=i['cm_run_module_uoa']

    # Check if cM action is in the input
    if 'cm_action' not in i:
       return {'cm_return':1, 'cm_error':'no action specified for module '+i['cm_run_module_uoa']}

    cm_stdout=''
    cm_stderr=''

    del (i['cm_run_module_uoa'])

    rr={}; 
    rr['cm_return']=0
    rr['cm_stdout']=''
    rr['cm_stderr']=''

    # Save json to temporay file
    tf=gen_tmp_with_json(i)
    q='@'+tf

    # Prepare cmd
    cmd=["cm", module, q]

    if 'cm_unparsed' in i:
       for k in i['cm_unparsed']:
           cmd.append(k)

    if i.get('cm_console','')=='txt':
       qq=''
       for k in cmd:
           if qq!='': qq+=' '
           qq+=k
       os.system(qq)

    else:
       if is_windows():
          proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
       else:
          proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)

       (stdout, stderr) = proc.communicate()
       if stdout!=None: stdout=stdout.strip()
       if stderr!=None: stderr=stderr.strip()

       rr['cm_stdout']=stdout
       rr['cm_stderr']=stderr

       cur={}

       err=False
       if stdout==None or stdout=='': 
          err=True
       else:
          try:
             cur=json.loads(stdout)
          except Exception as e:
             err=True

       if os.path.isfile(tf):
          os.remove(tf)

       if err:
          rr['cm_return']=99
          rr['cm_error']='can\'t process cM output:\n'
          if stdout!=None: rr['cm_error']+='STDOUT:\n'+stdout+'\n'
          if stderr!=None: rr['cm_error']+='STDERR:\n'+stderr+'\n'
       else:
          rr.update(cur)

    return rr

# ============================================================================
if __name__ == "__main__":

   '''
   cM user friendly command line module

   '''

   # Process flags and return "clean from flags" array
   x=return_flags(sys.argv[1:])
   argv=x['cmd']
   il=len(argv)
   flags=x['flags']

   if '-?' in flags or '-h' in flags or '--help' in flags or (il>0 and argv[0]=='help'):
      print "cM simplified and user friendly command line module to deal with cM repositories"
      print ""
      print "  cmx test                                                        - test cM functionality (alpha)"
      print ""
      print "  cmx repo add/create (repo name)                                 - create repo in the current directory (.cmr)"
      print "                                                                      or import existing one;"
      print "  cmx repo rm/del/delete (-f) (entry name)                        - delete repository reference"
      print "  cmx repo mv/move/ren/rename (old entry name) (new entry name)   - rename repository reference"
      print "  cmx repo update/co/checkout (repo name)                         - update shared repository"
      print "  cmx repo share/commit (repo name)                               - commit to shared repository"
      print "  cmx repo download (repo name)                                   - download repo from the web"
      print ""
      print "  cmx add <entry name>/CID (param1=value1 ... @file1.json ...)    - add entry to current repository/module"
      print "                                                                      local repository by default"
      print "  cmx update <entry name>/CID (param1=value1 ... @file1.json ...) - add entry to current repository/module"
      print "                                                                      local repository by default"
      print "  cmx rm/del/delete (-f) <entry name>/CID                         - delete entry from the current repository/module"
      print "                                                                      local repository by default"
      print "  cmx svnrm/svndel/svndelete <entry name>/CID                     - delete entry from the current repository/module using SVN"
      print "                                                                      local repository by default"
      print "  cmx ren/rename <old entry name> <new entry name>                - rename entry in the current repository/module"
      print "                                                                      local repository by default"
      print "  cmx mv/move <old CID> <new CID>                                 - move entry"
      print "                                                                      local repository by default"
      print "  cmx cp/copy <old CID> <new CID>                                 - copy entry"
      print "                                                                    -k - keep old UID"
      print "  cmx clean alias1 alias2 ...                                     - remove orphaned aliases"
      print ""
      print "  cmx info/load (CID)                                             - show all info about entry (in json)"
      print "                                                                      global repository by default"
      print "  cmx find (CID)                                                  - show path to the entry"
      print "                                                                      global repository by default"
      print "  cmx list <module>                                               - list data for a given module"
      print "                                                                      global repository by default"
      print "                                                                      -u - show only UID"
      print "  cmx index (info)                                                - show status of indexing server"
      print "  cmx index on                                                    - turn on usage of indexing by cM"
      print "  cmx index off                                                   - turn off usage of indexing by cM"
      print "  cmx index test                                                  - test indexing server"
      print "  cmx index flush                                                 - clear the whole index"
      print "  cmx index clean                                                 - clear index for a given repo/module and possibly data"
      print "  cmx index CID                                                   - index entry or entries"
      print "                                                                      local repository by default"
      print "                                                                      data can include patterns * and ?"
      print "  cmx search (CID key1=value1 value2 ...)                         - search data"
      print "                                                                      if indexing server is on, use it,"
      print "                                                                      otherwise very slow"
      print "                                                                      if indexing is on, can use wildcards * and ?"
      print "                                                                      -s turns on progress for internal slow search"
      print "                                                                      -t=timeout - sets timeout for local slow search"
      print "  cmx web_view/wv (CID)                                           - view entry in cM web front-end"
      print "  cmx web_update/wu (CID)                                         - update entry in cM web front-end"
      print ""
      print "  cmx uid                                                         - generate cM UID"
      print ""
      print "  cmx restore_uid_from_alias <alias>                              - restore UID from alias file"
      print ""
      print "  cmx password                                                    - prepare cM SHA1 password"
      print "                                                                     (if -s or --short, output only SHA1 password)"
      print ""
      print "  cmx                                                             - print current CID"
      print "                                                                      global repository by default"
      print "  cmx cv                                                          - print current CID in CV format"
      print ""
      print "  cmx help                                                        - help"
      print ""
      print " Additional flags:"
      print "   -h, --help, -?                                                 - this help"
      print "                                                                      (otherwise global by default)"
      print "   -g, --global                                                   - apply command to global repository"
      print "   -l, --local                                                    - apply command to local repository"
      print "                                                                      (otherwise global by default)"
      print "   -c, --class=class1,class2,...                                  - use classes for the command"
      print "                                                                      for example, add or list"
      print "                                                                      (it can be both UID or alias)"
      print "                                                                      (all classes should be present in an entry)"
      print "                                                                      (alias can include wild cards * and ?)"
      print "   -q, --quiet                                                    - quiet mode when deleting files, etc"
      print "   -f, --full                                                     - add repo to CID if needed"
      print "   -j, --json                                                     - return json if applicable"

      exit(0)
   else:
      # Check local or global repository
      globl=False
      if '-g' in flags or '--global' in flags:
         globl=True

      local=False
      if '-l' in flags or '--local' in flags:
         local=True
         globl=False

      # Check quiet mode
      quiet=False
      if '-q' in flags or '--quiet' in flags:
         quiet=True

      # Check if output to json
      jsn=False
      if '-j' in flags or '--json' in flags:
         jsn=True

      # Get command
      c=''
      if il>0: 
         c=argv[0]
         del(argv[0])
         il=len(argv)

      # Simple commands where repository or CID is not needed ****************************************
      if c=='uid':
         q='cm core gen_uid'
         os.system(q)
         exit(0)

      # Simple commands where repository or CID is not needed ****************************************
      if c=='restore_uid_from_alias':
         if il<1:
            print cmx_error+'alias file is not specified!'
            exit(1)

         af=argv[0]
         del(argv[0])
         il=len(argv)
         
         if not af.startswith('alias-a-'):
            print cmx_error+'file name is not alias!'
            exit(1)

         f=open(af, 'r')
         uid=f.readline().strip()
         f.close()

         alias=af[8:]

         f=open('alias-u-'+uid, 'w')
         f.write(alias)
         f.close()

         print 'Added '+uid+' <- '+alias

         exit(0)

      # Commands where repository, or hosts or CID are needed ****************************************
      # Get web and index host from cM configuration
      r=cm_access({'cm_run_module_uoa':'core', 
                   'cm_action':'get_info_about_full_hosts',
                   'cm_console':'json'})
      if r['cm_return']>0:
         print cmx_error+'can\'t get info about web and index hosts ('+r['cm_error']+')'
         exit(1)

      web_host=r['cm_web_host']
      index_host=r['cm_index_host']

      # Get info about current path
      r9=cm_access({'cm_run_module_uoa':'core', 
                    'cm_action':'get_info_about_current_path',
                    'cm_get_uid':'yes',
                    'cm_console':'json'})
      if r9['cm_return']==99:
         print cmx_error+'can\'t get info about web and index hosts '+r9['cm_error']
         exit(1)

      # Process current path (possibly none if we are not in repository)
      pp=r9.get('cm_path','')
      m=r9.get('cm_module_uoa','')
      md=r9.get('cm_module_uid','')
      d=r9.get('cm_data_uoa','')
      dd=r9.get('cm_data_uid','')
      rp=r9.get('cm_repo_uoa','')
      rpd=r9.get('cm_repo_uid','')

      # If no commands, copy current CID to clipboard (if supported)
      if c=='':
         if m=='' or d=='':
            print 'Can\'t detect current CID - current directory does not belong to a cM entry ...'
            exit(1)

         cid=md+':'+dd
         if ('-f' in flags or '--flags' in flags) and rpd!='': cid=rpd+':'+cid

         if jsn:
            r9['cid']=cid
            print json.dumps(r9, indent=2, sort_keys=True)
            exit(0)
         else:
            print cid

            # Copy to clipboard if OS supports it
            from Tkinter import Tk
            try:
               r = Tk()
               r.withdraw()
               r.clipboard_clear()
               r.clipboard_append(md+':'+dd)
               r.destroy()
            except Exception, e:
               print 'Copying to clipboard seems not to be supported by OS ('+format(e)+') ...'

         exit(0)
##########################################################
      elif c=='cv':
         if m=='' or d=='':
            print 'Can\'t detect current CID - current directory does not belong to a cM entry ...'
            exit(1)

         cv='$#cm_'+md+'_'+dd+'#$'
         print cv

         # Copy to clipboard if OS supports it
         from Tkinter import Tk
         try:
            r = Tk()
            r.withdraw()
            r.clipboard_clear()
            r.clipboard_append(md+':'+dd)
            r.destroy()
         except Exception, e:
            print 'Copying to clipboard seems not to be supported by OS ('+format(e)+') ...'

         exit(0)

##########################################################
# 1st level action - REPO
##########################################################
      if c=='repo':
         c1=''
         if il>0:
            c1=argv[0]
            del(argv[0])
            il=len(argv)

##########################################################
         if c1=='' or c1=='info':
            if jsn:
               print json.dumps({'cm_path':pp, 'cm_repo_uoa':rp, 'cm_repo_uid':rpd}, indent=2, sort_keys=True)
               exit(0)
            else:
               print 'Repo path: '+pp
               print 'Repo UOA:  '+rp
               print 'Repo UID:  '+rpd
##########################################################
         elif c1=='update' or c1=='co' or c1=='checkout':
            dn=''
            if il>0: 
               dn=argv[0]

            if dn=='': dn=rpd

            q='cm repo co'
            if dn!='': q+=' cm_repo_uoa='+dn

            os.system(q)
            exit(0)
##########################################################
         elif c1=='commit' or c1=='share':
            dn=''
            if il>0: 
               dn=argv[0]

            if dn=='': dn=rpd

            q='cm repo commit'
            if dn!='': q+=' cm_repo_uoa='+dn

            os.system(q)
            exit(0)
##########################################################
         elif c1=='download':
            dn=''
            if il>0: 
               dn=argv[0]

            if dn=='': dn=rpd

            q='cm repo download'
            if dn!='': q+=' web_repo_uoa='+dn

            os.system(q)
            exit(0)
##########################################################
         elif c1=='rm' or c1=='del' or c1=='delete':
            print 'Note that only the rererence to a repository will be deleted, not repository itself!' 
            dn=''
            if il>0: 
               dn=argv[0]

            q='cm repo delete'
            if dn!='': 
               q+=' cm_data_uoa="'+dn+'"'
            elif rpd!='':
               q+=' cm_data_uoa='+rpd

            os.system(q)
            exit(0)
##########################################################
         elif c1=='mv' or c1=='ren' or c1=='rename' or c1=='move':
            dn1=''
            if rpd!='': 
               dn=rpd
               if il>0: dn1=argv[0]
            elif il>0: 
               dn=argv[0]
               if il>1: dn1=argv[1]

            ii={'cm_run_module_uoa':'core',
                'cm_action':'rename',
                'orig_module_uoa':'repo',
                'orig_data_uoa':dn,
                'cm_console':'json'}

            update_data=False
            if dn1!='':
               if is_uid(dn1):
                  ii['new_data_uid']=dn1
               else:
                  ii['new_data_alias']=dn1
                  update_data=True

            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            if update_data:
               ii={'cm_run_module_uoa':'repo',
                   'cm_action':'update',
                   'cm_data_uoa':dn1,
                   'cm_console':'txt',
                   'cm_array':{'cm_display_as_alias':dn1}}

               r=cm_access(ii)
               if r['cm_return']>0:
                  print cmx_error+r['cm_error']
                  exit(1)

            exit(0)
##########################################################
         elif c1=='add' or c1=='create':
            dn=''
            if il>0: 
               dn=argv[0]
               del(argv[0])
               il=len(argv)

            ii={'cm_run_module_uoa':'repo',
                'cm_action':'add',
                'cm_data_uoa':dn,
                'path_type':'absolute',
                'cm_array':{'cm_display_as_alias':dn},
                'cm_add_default':'yes',
                'cm_console':'txt'}

            if len(argv)>0:
               merge_array(ii['cm_array'],argv)

            if local:
               if rp!='': ii['cm_repo_uoa']=rp

            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

         else:
            print cmx_error+'subcommand "'+c1+'" is not recognized for command "repo"'
            exit(1)
##########################################################
# 1st level action - index
##########################################################
      elif c=='index':
         c1=''
         if il>0:
            c1=argv[0]
            del(argv[0])
            il=len(argv)

##########################################################
         if c1=='' or c1=='info':
            # Load default kernel to see the option
            r=cm_access({'cm_run_module_uoa':'core', 
                         'cm_action':'load_default_kernel',
                         'cm_console':'json'})
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            use_indexing=r['cm_data_obj']['cfg'].get('use_indexing','')

            if use_indexing=='yes':
               print 'cM indexing is ON'
            else:
               print 'cM indexing is OFF'

            exit(0)

##########################################################
         elif c1=='on':
            # Update default:kernel to turn on indexing
            r=cm_access({'cm_run_module_uoa':'core', 
                         'cm_action':'update_default_kernel',
                         'cm_array':{'use_indexing':'yes'},
                         'cm_skip_update_info':'yes',
                         'cm_console':'json'})
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            print 'cM indexing is TURNED ON. Don\'t forget to start indexing server (cm index server)!'

            exit(0)

##########################################################
         elif c1=='off':
            # Update default:kernel to turn on indexing
            r=cm_access({'cm_run_module_uoa':'core', 
                         'cm_action':'update_default_kernel',
                         'cm_array':{'use_indexing':'no'},
                         'cm_skip_update_info':'yes',
                         'cm_console':'json'})
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            print 'cM indexing is TURNED OFF.'

            exit(0)

##########################################################
         elif c1=='flush':
            # Update default:kernel to turn on indexing
            r=cm_access({'cm_run_module_uoa':'index', 
                         'cm_action':'flush',
                         'cm_console':'txt'})
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            print ""

            exit(0)
##########################################################
         elif c1=='test':
            # Update default:kernel to turn on indexing
            r=cm_access({'cm_run_module_uoa':'index', 
                         'cm_action':'test',
                         'cm_console':'txt'})
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            exit(0)

##########################################################
         elif c1=='rm' or c1=='del' or c1=='delete' or c1=='add':
            mode='delete'
            if c1=='add': mode='add'

            dn=''

            if il>0:
               cid=cid2array({'cid':argv[0], 'prefix':'cm'})
               if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
               if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
               if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

               del(argv[0])
               il=len(argv)

            if dn=='': dn=dd

            if rp=='':
               print cmx_error+'repository should be defined for this operation!'
               exit(1)

            if dn=='':
               print cmx_error+'entry name is not specified!'
               exit(1)

            if m=='':
               print cmx_error+'module name is not specified!'
               exit(1)

            ii={'cm_run_module_uoa':'index',
                'cm_action':'delete',
                'cm_repo_uoa':rp,
                'cm_module_uoa':m,
                'cm_data_uoa':dn,
                'mode':mode,
                'cm_console':'txt'}

            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            exit(0)
##########################################################
         elif c1=='clean':
            dn=''

            if il>0:
               cid=cid2array({'cid':argv[0], 'prefix':'cm'})
               if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
               if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
               if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

               del(argv[0])
               il=len(argv)

            if dn=='': dn=dd

            if rp=='':
               print cmx_error+'repository should be defined for this operation!'
               exit(1)

            if m=='':
               print cmx_error+'module name is not specified!'
               exit(1)

            ii={'cm_run_module_uoa':'index',
                'cm_action':'clean',
                'index_repo_uoa':rp,
                'index_module_uoa':m,
                'cm_console':'txt'}
            if dn!='': ii['index_data_uoa']=dn

            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            exit(0)
         else:
            dn=''

            cid=cid2array({'cid':c1, 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

            if dn=='': dn=dd
            if dn=='': dn='*'

            ii={'cm_run_module_uoa':'index',
                'cm_action':'all',
                'index_data_uoa':dn,
                'delay':'0',
                'cm_console':'txt'}

            if m!='': ii['index_module_uoa']=m

            if not globl:
               if rp!='': ii['index_repo_uoa']=rp

            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            exit(0)

##########################################################
# 1st level action - index
##########################################################
      elif c=='search':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

            del(argv[0])
            il=len(argv)

         if dn=='': dn=dd

         if m=='':
            print cmx_error+'module name is not specified'
            exit(1)

         ii={'cm_run_module_uoa':'core',
             'cm_action':'search',
             'cm_console':'txt'}

         if m!='*':
            ii['module_selection']=[m]

         if not globl:
            if rp!='': ii['repo_selection']=[rp]

         # Convert remainings from the command line to key/values or es_string
         qx=1
         for q in argv:
             key='key_'+str(qx)
             value='value_'+str(qx)
             qx+=1

             qq=q.split('=')
             if len(qq)<2:
                ii[value]=qq[0]
             else:
                ii[key]=qq[0]
                ii[value]=qq[1]

         if '-s' in flags: ii['show_search_progress']='yes'

         # Check timeout
         for q in flags:
             if q.startswith('-t='):
                ii['timeout']=q[3:]

         if jsn:
            ii['cm_console']='json_with_indent'

         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         print r['cm_stdout']

         exit(0)

##########################################################
# 1st level action - index
##########################################################
      elif c=='clean':
         dn=''

         lc=[]

         if il>0:
            for q in range(0,il):
                lc.append(argv[q])

         # Cleaning aliases ...
         for q in lc:
             if q.startswith('alias-a-'):
                l=''
                # Read alias
                try:
                   f=open(q, 'r')
                   l=f.readline()
                   l=l.strip()
                   f.close()
                except:
                   pass

                if os.path.exists(q): 
                   print q+' was removed ...'
                   os.remove(q)

                if l!='':
                   q1='alias-u-'+l

                   if os.path.exists(q1): 
                      os.remove(q1)
                      print q1+' was removed ...'



         exit(0)

##########################################################
# Continue 1st level actions actions
##########################################################
      elif c=='info' or c=='load':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         ii={'cm_run_module_uoa':'core',
             'cm_action':'find_path_to_data',
             'cm_module_uoa':m,
             'cm_data_uoa':dn,
             'cm_console':'json_with_indent'}

         if local:
            if rp!='': ii['cm_repo_uoa']=rp
            else:
               error_if_no_cur_repo({})
               exit(1)

         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         print r['cm_stdout']
         exit(0)

##########################################################
      elif c=='find':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         ii={'cm_run_module_uoa':'core',
             'cm_action':'find_path_to_data',
             'cm_module_uoa':m,
             'cm_data_uoa':dn,
             'cm_console':'json_with_indent'}

         if local:
            if rp!='': ii['cm_repo_uoa']=rp
            else:
               error_if_no_cur_repo({})
               exit(1)

         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         print r['cm_path']
         exit(0)

##########################################################
      elif c=='web_view' or c=='wv':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         cid=m+':'+dn
#         q='cm_browser "'+web_host+'cm_menu=browse&cm_subaction_view&browse_cid='
         q='cm_browser "'+web_host+'view_cid='

         if local:
            if rp!='': cid=rp+':'+cid
            else:
               error_if_no_cur_repo({})
               exit(1)

         q+=cid+'"'
         os.system(q)
##########################################################
      elif c=='web_update' or c=='wu':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         cid=m+':'+dn
         q='cm_browser "'+web_host+'cm_menu=browse&cm_subaction_update&browse_cid='

         if local:
            if rp!='': cid=rp+':'+cid
            else:
               error_if_no_cur_repo({})
               exit(1)

         q+=cid+'"'
         os.system(q)
##########################################################
      elif c=='add':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

            del(argv[0])
            il=len(argv)

         if dn=='': dn=dd

         if dn=='*':dn=''

         if m=='':
            print cmx_error+'module name is not specified'
            exit(1)

         ii={'cm_run_module_uoa':m,
             'cm_action':'add',
             'cm_data_uoa':dn,
             'cm_array':{'cm_display_as_alias':dn},
             'cm_add_default':'yes',
             'cm_console':'txt'}

         # Check additional parameters
         if len(argv)>0:
            merge_array(ii['cm_array'],argv)

         # Check repository
         if not globl:
            if rp!='': ii['cm_repo_uoa']=rp

         # Check classes
         r=find_and_separate_flags({'cm_list':flags, 'flags':['-c=','--class=']})
         if r['cm_found']:

            # Check UIDs (with matching *?)
            r1=convert_relaxed_classes_to_uids({'cm_list':r['cm_values']})
            if r1['cm_return']>0:
               print cmx_error+r1['cm_error']
               exit(1)

            ww=r1['cm_list_match']
            for w in ww:
                print 'Class "'+w+'" converted to "'+ww[w].get('alias','')+'" ('+ww[w].get('cm_uid','')+') ...'

            ii['cm_array']['cm_classes_uoa']=r1['cm_list_uids']

 
#         print json.dumps(ii, indent=2)
         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         exit(0)

##########################################################
      elif c=='rm' or c=='del' or c=='delete':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

            del(argv[0])
            il=len(argv)

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         if m=='':
            print cmx_error+'module name is not specified'
            exit(1)

         while dn!='':
            print ''
            ii={'cm_run_module_uoa':m,
                'cm_action':'delete',
                'cm_data_uoa':dn,
                'cm_console':'txt'}

            if quiet: ii['cm_force_delete']='yes'

            if not globl:
               if rp!='': ii['cm_repo_uoa']=rp

            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            if il>0:
               dn=argv[0]
               del(argv[0])
               il=len(argv)
            else:
               dn=''

         exit(0)

##########################################################
      elif c=='svnrm' or c=='svndel' or c=='svndelete':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

            del(argv[0])
            il=len(argv)

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         if m=='':
            print cmx_error+'module name is not specified'
            exit(1)

         print ''

         ii={'cm_run_module_uoa':'core',
             'cm_action':'find_path_to_data',
             'cm_module_uoa':m,
             'cm_data_uoa':dn,
             'cm_console':'json_with_indent'}
         if rp!='': ii['cm_repo_uoa']=rp

         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         p=r['cm_path']

         x=os.path.abspath(os.curdir)
         os.chdir(os.path.join(p,'..'))

         if not is_uid(dn):
            p1=os.path.join('.cm','alias-a-'+dn)
            if os.path.isfile(p1):
               f=open(p1,'r')
               uid=f.read().strip()
               f.close()
               os.system('svn rm --force '+p1)

               p2=os.path.join('.cm','alias-u-'+uid)
               if os.path.isfile(p2):
                  os.system('svn rm --force '+p2)

         os.system('svn rm --force '+dn)

         os.chdir(x)

         exit(0)

##########################################################
      elif c=='update':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

            del(argv[0])
            il=len(argv)

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         if m=='':
            print cmx_error+'module name is not specified'
            exit(1)

         ii={'cm_run_module_uoa':m,
             'cm_action':'update',
             'cm_data_uoa':dn,
             'cm_array':{},
             'cm_console':'txt'}

         if len(argv)>0:
            merge_array(ii['cm_array'],argv)

         if not globl:
            if rp!='': ii['cm_repo_uoa']=rp

         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         exit(0)

##########################################################
      elif c=='ren' or c=='rename':
         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

            del(argv[0])
            il=len(argv)

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         if m=='':
            print cmx_error+'module name is not specified'
            exit(1)

         ii={'cm_run_module_uoa':'core',
             'cm_action':'rename',
             'orig_module_uoa':m,
             'orig_data_uoa':dn,
             'cm_console':'json'}

         if not globl:
            if rp!='': ii['orig_repo_uoa']=rp

         dn1=''
         if il>0:
            dn1=argv[0]

         update_data=False
         if dn1!='':
            if is_uid(dn1):
               ii['new_data_uid']=dn1
            else:
               ii['new_data_alias']=dn1
               update_data=True

         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         if update_data:
            ii={'cm_run_module_uoa':m,
                'cm_action':'update',
                'cm_data_uoa':dn1,
                'cm_console':'txt',
                'cm_array':{'cm_display_as_alias':dn1}}

            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

         exit(0)
##########################################################
      elif c=='cp' or c=='copy' or c=='mv' or c=='move':
         move=False
         if c=='mv' or c=='move': move=True

         dn=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp=cid['cm_repo_uoa']
            if cid.get('cm_module_uoa','')!='': m=cid['cm_module_uoa']
            if cid.get('cm_data_uoa','')!='': dn=cid['cm_data_uoa']

            del(argv[0])
            il=len(argv)

         if dn=='': dn=dd

         if dn=='':
            print cmx_error+'entry name is not specified'
            exit(1)

         if m=='':
            print cmx_error+'module name is not specified'
            exit(1)

         ii={'cm_run_module_uoa':'core',
             'cm_action':'copy',
             'orig_module_uoa':m,
             'orig_data_uoa':dn,
             'cm_console':'json'}

         if not globl:
            if rp!='': ii['orig_repo_uoa']=rp

         rp1=''
         dn1=''

         if il>0:
            cid=cid2array({'cid':argv[0], 'prefix':'cm'})
            if cid.get('cm_repo_uoa','')!='': rp1=cid['cm_repo_uoa']
            if cid.get('cm_data_uoa','')!='': dn1=cid['cm_data_uoa']

            del(argv[0])
            il=len(argv)

         if dn1=='*': dn1=dn
         
         if rp1!='': ii['target_repo_uoa']=rp1
         if dn1!='': ii['target_data_uoa']=dn1

         if move: ii['move']='yes'

         if '-k' not in flags: ii['generate_new_uid']='yes'

         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         if not is_uid(dn1):
            ii={'cm_run_module_uoa':m,
                'cm_action':'update',
                'cm_data_uoa':dn1,
                'cm_console':'txt',
                'cm_array':{'cm_display_as_alias':dn1}}

            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

         exit(0)

##########################################################
      elif c=='list':
         dn=''
         if il>0:
            m=argv[0]
            del(argv[0])
            il=len(argv)

         if m=='':
            print cmx_error+'module name is not specified'
            exit(1)

         ii={'cm_run_module_uoa':'core',
             'cm_action':'list',
             'cm_module_uoa':m,
             'cm_console':'txt'}

         if local:
            if rp!='': ii['cm_repo_uoa']=rp

         if '-u' not in flags: ii['show_display_as_alias']='yes'

         # Check classes
         r=find_and_separate_flags({'cm_list':flags, 'flags':['-c=','--class=']})
         if r['cm_found']:
            # Check UIDs (with matching *?)
            r1=convert_relaxed_classes_to_uids({'cm_list':r['cm_values']})
            if r1['cm_return']>0:
               print cmx_error+r1['cm_error']
               exit(1)

            ww=r1['cm_list_match']
#            if not jsn and len(ww)>0:
#               for w in ww:
#                   print 'Class "'+w+'" converted to "'+ww[w].get('alias','')+'" ('+ww[w].get('cm_uid','')+') ...'
#               print ''


            ii['cm_classes_uoa']=r1['cm_list_uids']

         if jsn:
            ii['cm_console']='json_with_indent'

         r=cm_access(ii)
         if r['cm_return']>0:
            print cmx_error+r['cm_error']
            exit(1)

         print r['cm_stdout']

         exit(0)

##########################################################
      elif c=='test':
         q='cm test all'
         os.system(q)

         exit(0)

##########################################################
      elif c=='password':
         password=getpass.getpass('Enter password: ')

         if password!='':
            ii={'cm_run_module_uoa':'core',
                'cm_action':'convert_str_to_sha1',
                'cm_string':password,
                'cm_console':'json'}
            r=cm_access(ii)
            if r['cm_return']>0:
               print cmx_error+r['cm_error']
               exit(1)

            if '-s' in flags or '--short' in flags:
               print r['cm_string_sha1_base64']
            else:
               print ''
               print 'cM password hash (BASE64(SHA1) compatible with .htpasswd format):'
               print ''
               print r['cm_string_sha1_base64']

               print ''
               print 'Note, you can use CM_USER_PASSWORD1 environment variable'
               print '  to set this password and automate login!'

         exit(0)

##########################################################
      else:
         print cmx_error+'command '+c+' is not recognized!'
         exit(1)

   exit(0)