lcm/pub/utils/toscaparser/basemodel.py

   1 import copy
   2 import os
   3 import shutil
   4 import urllib
   5
   6 from toscaparser.functions import GetInput
   7 from toscaparser.tosca_template import ToscaTemplate
   8
   9 from lcm.pub.utils.toscaparser.dataentityext import DataEntityExt
  10
  11
  12 class BaseInfoModel(object):
  13
  14     def buildToscaTemplate(self, path, params):
  15         file_name = None
  16         try:
  17             file_name = self._check_download_file(path)
  18             valid_params = self._validate_input_params(file_name, params)
  19             return self._create_tosca_template(file_name, valid_params)
  20         finally:
  21             if file_name != None and file_name != path and os.path.exists(file_name):
  22                 try:
  23                     os.remove(file_name)
  24                 except Exception, e:
  25                     pass
  26
  27     def _validate_input_params(self, path, params):
  28         valid_params = {}
  29         if params and len(params) > 0:
  30             tmp = self._create_tosca_template(path, None)
  31             for key,value in params.items():
  32                 if hasattr(tmp, 'inputs') and len(tmp.inputs) > 0:
  33                     for input_def in tmp.inputs:
  34                         if (input_def.name == key):
  35                             valid_params[key] = DataEntityExt.validate_datatype(input_def.type, value)
  36
  37         return valid_params
  38
  39     def _create_tosca_template(self, file_name, valid_params):
  40         tosca_tpl = None
  41         try:
  42             tosca_tpl = ToscaTemplate(file_name, valid_params)
  43             print "-----------------------------"
  44             print '\n'.join(['%s:%s' % item for item in tosca_tpl.__dict__.items()])
  45             print "-----------------------------"
  46             return tosca_tpl
  47         finally:
  48             if tosca_tpl != None and hasattr(tosca_tpl, "temp_dir") and os.path.exists(tosca_tpl.temp_dir):
  49                 try:
  50                     shutil.rmtree(tosca_tpl.temp_dir)
  51                 except Exception, e:
  52                     pass
  53
  54     def _check_download_file(self, path):
  55         if (path.startswith("ftp") or path.startswith("sftp")):
  56             return self.downloadFileFromFtpServer(path)
  57         elif (path.startswith("http")):
  58             return self.download_file_from_httpserver(path)
  59         return path
  60
  61     def download_file_from_httpserver(self, path):
  62         path = path.encode("utf-8")
  63         tmps = str.split(path, '/')
  64         localFileName = tmps[len(tmps) - 1]
  65         urllib.urlretrieve(path, localFileName)
  66         return localFileName
  67
  68     def downloadFileFromFtpServer(self, path):
  69         path = path.encode("utf-8")
  70         tmp = str.split(path, '://')
  71         protocol = tmp[0]
  72         tmp = str.split(tmp[1], ':')
  73         if len(tmp) == 2:
  74             userName = tmp[0]
  75             tmp = str.split(tmp[1], '@')
  76             userPwd = tmp[0]
  77             index = tmp[1].index('/')
  78             hostIp = tmp[1][0:index]
  79             remoteFileName = tmp[1][index:len(tmp[1])]
  80             if protocol.lower() == 'ftp':
  81                 hostPort = 21
  82             else:
  83                 hostPort = 22
  84
  85         if len(tmp) == 3:
  86             userName = tmp[0]
  87             userPwd = str.split(tmp[1], '@')[0]
  88             hostIp = str.split(tmp[1], '@')[1]
  89             index = tmp[2].index('/')
  90             hostPort = tmp[2][0:index]
  91             remoteFileName = tmp[2][index:len(tmp[2])]
  92
  93         localFileName = str.split(remoteFileName, '/')
  94         localFileName = localFileName[len(localFileName) - 1]
  95
  96         if protocol.lower() == 'sftp':
  97             self.sftp_get(userName, userPwd, hostIp, hostPort, remoteFileName, localFileName)
  98         else:
  99             self.ftp_get(userName, userPwd, hostIp, hostPort, remoteFileName, localFileName)
 100         return localFileName
 101
 102     def buidMetadata(self, tosca):
 103         if 'metadata' in tosca.tpl:
 104             self.metadata = copy.deepcopy(tosca.tpl['metadata'])
 105
 106         def buildProperties(self, nodeTemplate, parsed_params):
 107             properties = {}
 108             isMappingParams = parsed_params and len(parsed_params) > 0
 109             for k, item in nodeTemplate.get_properties().items():
 110                 properties[k] = item.value
 111                 if isinstance(item.value, GetInput):
 112                     if item.value.result() and isMappingParams:
 113                         properties[k] = DataEntityExt.validate_datatype(item.type, item.value.result())
 114                     else:
 115                         tmp = {}
 116                         tmp[item.value.name] = item.value.input_name
 117                         properties[k] = tmp
 118             if 'attributes' in nodeTemplate.entity_tpl:
 119                 for k, item in nodeTemplate.entity_tpl['attributes'].items():
 120                     properties[k] = str(item)
 121             return properties
 122
 123     def buildProperties(self, nodeTemplate, parsed_params):
 124         properties = {}
 125         isMappingParams = parsed_params and len(parsed_params) > 0
 126         for k, item in nodeTemplate.get_properties().items():
 127             properties[k] = item.value
 128             if isinstance(item.value, GetInput):
 129                 if item.value.result() and isMappingParams:
 130                     properties[k] = DataEntityExt.validate_datatype(item.type, item.value.result())
 131                 else:
 132                     tmp = {}
 133                     tmp[item.value.name] = item.value.input_name
 134                     properties[k] = tmp
 135         if 'attributes' in nodeTemplate.entity_tpl:
 136             for k, item in nodeTemplate.entity_tpl['attributes'].items():
 137                 properties[k] = str(item)
 138         return properties
 139
 140
 141     def verify_properties(self, props, inputs, parsed_params):
 142         ret_props = {}
 143         if (props and len(props) > 0):
 144             for key, value in props.items():
 145                 ret_props[key] = self._verify_value(value, inputs, parsed_params)
 146                 #                 if isinstance(value, str):
 147                 #                     ret_props[key] = self._verify_string(inputs, parsed_params, value);
 148                 #                     continue
 149                 #                 if isinstance(value, list):
 150                 #                     ret_props[key] = map(lambda x: self._verify_dict(inputs, parsed_params, x), value)
 151                 #                     continue
 152                 #                 if isinstance(value, dict):
 153                 #                     ret_props[key] = self._verify_map(inputs, parsed_params, value)
 154                 #                     continue
 155                 #                 ret_props[key] = value
 156         return ret_props