DCAE-D tosca-lab initial commit

DCAE-D tosca-lab initial commit Change-Id: Ia42934ce7c75abe05fa106585c9334c8b048ee36 Issue-ID: SDC-1218 Signed-off-by: Stone, Avi (as206k) <as206k@att.com>
author: Stone, Avi (as206k) <as206k@att.com> 2018-04-12 16:41:45 +0300
committer: Stone, Avi (as206k) <as206k@att.com> 2018-04-12 16:41:45 +0300
commit: 879e94b78193798e8b170fca9b924d2c3881f7ba (patch)
tree: 150de697138a7593869eaae455add025b06a6e04
parent: 7e02c7aaab14828ef8baaef98865f26d98e3b795 (diff)
122 files changed, 5894 insertions, 0 deletions
diff --git a/app/README.md b/app/README.md
new file mode 100644
index 0000000..e1bf2e4
--- /dev/null
+++ b/app/README.md
@@ -0,0 +1,9 @@
+TOSCA Lab
+
+Ideally, I try to make TOSCA Lab like Matlab, a tool set to create/modify/connect/translate TOSCA templates. 
+
+It is also my first Python project for coding practice. 
+
+Version: 
+0.1 -- The original version was created to write everything from scratch. It is able to read YAML files following TOSCA standard and do TOSCA-to-HEAT translation provided with the translation library. 
+0.2 -- I will try to integrate with the existing open source project tosca-parser. In that case, I can make full use of the existing parser and focus more on more features.  The tosca-parser version I am working with is 0.4.0
diff --git a/app/__init__.py b/app/__init__.py
new file mode 100644
index 0000000..53da910
--- /dev/null
+++ b/app/__init__.py
@@ -0,0 +1 @@
+from app.version import __version__
+\ No newline at end of file
diff --git a/app/map_sup_enrich_compose.py b/app/map_sup_enrich_compose.py
new file mode 100644
index 0000000..815a258
--- /dev/null
+++ b/app/map_sup_enrich_compose.py
@@ -0,0 +1,99 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+from toscalib.tosca_workbook import ToscaWorkBook
+from toscalib.tosca_builder import ToscaBuilder
+
+import getopt, sys, json, logging
+
+def usage():
+    print('OPTIONS:')
+    print('\t-h|--help: print this help message')
+    print('\t-i|--input: The home folder where all spec files are')
+    print('\t-o|--output: the output file name')
+    print('\t-v|--value: the json value file')
+
+    
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "hi:o:v:", ["help", "input=", "output=", "value="])
+    except getopt.GetoptError as err:
+        # print help information and exit:
+        logging.error( str(err)) # will print something like "option -a not recognized"
+        usage()
+        sys.exit(2)
+
+    spec_prefix = None
+    output_file = None
+    value_file = None
+    
+    for o, a in opts:
+        if  o in ("-h", "--help"):
+            usage()
+            sys.exit()
+        elif o in ("-i", "--input"):
+            spec_prefix = a
+        elif o in ("-o", "--output"):
+            output_file = a
+        elif o in ("-v", "--value"):
+            value_file = a
+        else:
+            logging.error( 'Unrecognized option: ' + o)
+            usage()
+            sys.exit(2)
+            
+    if spec_prefix is None or output_file is None:
+        logging.error( 'Incorrect arguments!')
+        usage()
+        sys.exit(2)
+
+    model_prefix = './data/tosca_model'
+    meta_model = './data/meta_model/meta_tosca_schema.yaml'
+        
+    for ms in ['map', 'enrich', 'supplement']:
+            
+        builder = ToscaBuilder()
+        
+        builder.import_schema(meta_model)
+        builder.import_spec(spec_prefix+'/dcae-event-proc/dcae-event-proc-cdap-' + ms+ '\\' + ms+ '_spec.json')
+        builder.create_node_type()
+        builder.export_schema(model_prefix+'/' + ms + '/schema.yaml')
+        builder.import_schema(model_prefix+'/' + ms + '/schema.yaml')
+        builder.create_model(ms)
+        builder.export_model(model_prefix+'/' + ms + '/template.yaml')
+        builder.create_translate(ms)
+        builder.export_translation(model_prefix+'/' + ms + '/translate.yaml')
+        
+    workbook = ToscaWorkBook()
+    
+    workbook._import_dir(model_prefix)
+    workbook._import_dir('./data/shared_model/')
+    workbook._use('map','NO_PREFIX')
+    workbook._use('supplement','NO_PREFIX')
+    workbook._use('enrich','NO_PREFIX')
+    
+    if value_file is not None: 
+        try: 
+            with open(value_file) as data_file:
+                data = json.load(data_file)
+                for ms in ['map', 'enrich', 'supplement']:
+#                    if data.has_key(ms):
+                    if ms in data:
+                        prop_sec = data[ms]
+                        for key in prop_sec.keys():
+                            workbook._assign(ms, key, prop_sec[key])
+        except err :
+            logging.error( "Unable to read " +value_file)
+            logging.error( str(err))
+    workbook._add_shared_node([{'dcae.capabilities.cdapHost':'cdap_host'}, {'dcae.capabilities.dockerHost': 'docker_host'}, {'dcae.capabilities.composition.host': 'composition_virtual'}])
+    
+    workbook._assign('supplement', 'stream_publish_0', 'map')
+    workbook._assign('enrich', 'stream_publish_0', 'supplement')
+         
+    workbook.tran_db = workbook.db
+         
+    workbook._export_yaml('event_proc.yaml', 'no_expand,main')
+    workbook._export_yaml(output_file, 'cloudify,main')
+    
+if __name__ == "__main__":
+    main()
+\ No newline at end of file
diff --git a/app/model_create.py b/app/model_create.py
new file mode 100644
index 0000000..97e6ff4
--- /dev/null
+++ b/app/model_create.py
@@ -0,0 +1,100 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+from toscalib.tosca_workbook import ToscaWorkBook
+from toscalib.tosca_builder import ToscaBuilder
+
+import getopt, sys, json, os, base64, logging
+
+def usage():
+    print('OPTIONS:')
+    print('\t-h|--help: print this help message')
+    print('\t-i|--input: The PATH to spec file')
+    print('\t-o|--output: the folder for the output model ')
+    print('\t-n|--name: the name of the service')
+    print('\t-t|--import: the PATH to import file')
+    print('\t-m|--meta: the PATH to meta model file (default: ./data/meta_model/meta_tosca_schema.yaml')
+
+    
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "hi:o:n:t:m:", ["help", "input=", "output=", "name=", "import=", "meta="])
+    except getopt.GetoptError as err:
+        # print help information and exit:
+        logging.error(str(err)) # will print something like "option -a not recognized"
+        usage()
+        sys.exit(2)
+
+    spec_file = None
+    output_file = './data/tosca_model/temp'
+    name = None
+    meta_model = './data/meta_model/meta_tosca_schema.yaml'
+    import_file = None
+
+    for o, a in opts:
+        if  o in ("-h", "--help"):
+            usage()
+            sys.exit()
+        elif o in ("-i", "--input"):
+            spec_file = a
+        elif o in ("-o", "--output"):
+            output_file = a
+        elif o in ("-n", "--name"):
+            name = a
+        elif o in ("-t", "--import"):
+            import_file = a
+        elif o in ("-m", "--meta"):
+            meta_model = a
+        else:
+            logging.error('Unrecognized option: ' + o)
+            usage()
+            sys.exit(2)
+            
+    if spec_file is None:
+        logging.error('Incorrect arguments!')
+        usage()
+        sys.exit(2)
+
+    if output_file is None:
+        model_prefix = './data/tosca_model'
+    else:
+        filename = output_file + '/schema.yaml'
+        dirname = os.path.dirname(filename)           
+        try:
+            os.stat(dirname)
+        except:
+            os.mkdir(dirname) 
+        model_prefix = output_file
+        
+                    
+    builder = ToscaBuilder()
+        
+    builder.import_schema(meta_model)
+    if spec_file in ['stdin', '-']:
+        builder.import_spec_str(json.load(sys.stdin))
+    else:
+        builder.import_spec(spec_file)
+    if import_file is not None:
+        builder.import_import(import_file)
+    
+    if name is None:
+        name = builder.spec_import.name
+    
+    builder.create_node_type(name)
+    schema_str = builder.export_schema(model_prefix+ '/schema.yaml')
+    builder.import_schema(model_prefix+ '/schema.yaml')
+    builder.create_model(name)
+    template_str = builder.export_model(model_prefix+ '/template.yaml')
+    builder.create_translate(name)
+    translate_str = builder.export_translation(model_prefix+ '/translate.yaml')    
+    
+    if spec_file in ['stdin', '-']:
+        ret = {}
+        ret['schema'] = base64.encodestring(schema_str)
+        ret['template'] = base64.encodestring(template_str)
+        ret['translate'] = base64.encodestring(translate_str) 
+        
+        print (json.dumps(ret))
+
+if __name__ == "__main__":
+    main()
+\ No newline at end of file
diff --git a/app/policy_create.py b/app/policy_create.py
new file mode 100644
index 0000000..9e89157
--- /dev/null
+++ b/app/policy_create.py
@@ -0,0 +1,72 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+from toscalib.tosca_workbook import ToscaWorkBook
+from toscalib.tosca_builder import ToscaBuilder
+
+import getopt, sys, json, os, logging
+
+def usage():
+    print('OPTIONS:')
+    print('\t-h|--help: print this help message')
+    print('\t-i|--input: The PATH to spec file')
+    print('\t-o|--output: the output file name')
+    print('\t-n|--name: the name of the service')
+
+    
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "hi:o:n:", ["help", "input=", "output=", "name="])
+    except getopt.GetoptError as err:
+        logging.error( str(err)) # will print something like "option -a not recognized"
+        usage()
+        sys.exit(2)
+
+    spec_file = None
+    output_file = None
+    name = None
+    
+    for o, a in opts:
+        if  o in ("-h", "--help"):
+            usage()
+            sys.exit()
+        elif o in ("-i", "--input"):
+            spec_file = a
+        elif o in ("-o", "--output"):
+            output_file = a
+        elif o in ("-n", "--name"):
+            name = a
+        else:
+            logging.error( 'Unrecognized option: ' + o)
+            usage()
+            sys.exit(2)
+            
+    if spec_file is None or output_file is None:
+        logging.error( 'Incorrect arguments!')
+        usage()
+        sys.exit(2)
+
+    dirname = os.path.dirname(output_file)           
+    
+    if dirname is not None and len(dirname) > 0:
+        try:
+            os.stat(dirname)
+        except:
+            os.mkdir(dirname) 
+
+    meta_model = './data/meta_model/meta_policy_schema.yaml'
+                    
+    builder = ToscaBuilder()
+    
+    builder.import_schema(meta_model)
+    builder.import_spec(spec_file)
+    if name is None:
+        name = builder.spec_import.name
+    if builder._using_policy() is False:
+        logging.warning( 'NO policy is defined in the spec')
+        return
+    builder.create_policy()
+    builder.export_policy(output_file)
+
+if __name__ == "__main__":
+    main()
+\ No newline at end of file
diff --git a/app/requirements.txt b/app/requirements.txt
new file mode 100644
index 0000000..cb7ff9f
--- /dev/null
+++ b/app/requirements.txt
@@ -0,0 +1,11 @@
+PyYAML==3.11
+argparse==1.4.0
+dateutils==0.6.6
+python-dateutil==2.5.3
+pytz==2016.6.1
+requests==2.13.0
+six==1.10.0
+virtualenv==12.1.1
+utils
+web.py==0.40.dev0
+
diff --git a/app/simple_compose.py b/app/simple_compose.py
new file mode 100644
index 0000000..8dc9561
--- /dev/null
+++ b/app/simple_compose.py
@@ -0,0 +1,24 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+from toscalib.tosca_workbook import ToscaWorkBook
+    
+workbook = ToscaWorkBook()
+
+workbook._import_dir('./data/tosca_model/')
+workbook._import_dir('./data/shared_model/')
+
+workbook._use('foi', 'NO_PREFIX')
+workbook._assign('policy_0', 'policy_id', 'something_filled_by_CLAMP')
+
+workbook._export_yaml('test_template.yaml', 'noexpand,main,rawfunc')
+
+workbook._add_shared_node([{'dcae.capabilities.dockerHost': 'docker_host'}, {'dcae.capabilities.composition.host': 'composition_virtual'}])
+ 
+workbook._load_translation_db('./data/tosca_model/')
+workbook._load_translation_db('./data/shared_model/')
+
+workbook._export_yaml('./data/blueprint/foi.yaml', 'cloudify,main')
+#workbook._export_yaml('test_template2.yaml', 'noexpand,main,rawfunc')
+
+
diff --git a/app/tosca_server.py b/app/tosca_server.py
new file mode 100644
index 0000000..0836d3a
--- /dev/null
+++ b/app/tosca_server.py
@@ -0,0 +1,532 @@
+'''
+Created on Apr 8, 2016
+
+@author: Shu Shi
+'''
+#!/usr/bin/env python
+import web
+import json, os, sys
+import base64
+from toscalib.tosca_workbook import ToscaWorkBook
+from toscalib.tosca_builder import ToscaBuilder
+from toscalib.templates.database import ToscaDB
+from version import __version__
+
+
+# class fe_get_itembyid:
+#     def GET(self):
+#         item_id = web.input()
+#         print( 'get_itembyid is called with input: ' + str(item_id))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})
+#     
+# class fe_get_template:
+#     def GET(self):
+#         temp_id = web.input()
+#         print( 'get_template is called with input: ' + str(temp_id))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})    
+#     
+# class fe_get_type:
+#     def GET(self):
+#         type_name = web.input()
+#         print( 'get_type is called with input: ' + str(type_name))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})    
+#     
+# class fe_get_compositioncreate:
+#     def GET(self):
+#         webinput = web.input(cid='unknown_cid')
+#         print( 'get_compositioncreate is called with input: ' + str(webinput))
+#         cid = webinput.cid
+#         
+#         workbook_db = ToscaDB()
+#         
+#         if cid not in workbook_db:
+#             workbook_db[cid] = ToscaWorkBook() 
+# 
+#         ret_json = workbook_db[cid].toJson()
+#         ret_json['cid'] = cid
+#         
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         
+#         print( 'get_compositioncreate returns:' + ret_json)
+#         return json.dumps(ret_json)    
+# 
+# class fe_get_ice:
+#     def GET(self):
+#         input_list = web.input()
+#         print( 'get_ice is called with input: ' + str(input_list))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})        
+#     
+# class fe_post_compimg:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_compimg is called with input: ' + str(cid))
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_compimg input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})        
+#     
+# class fe_post_composition_commit:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_composition_commit is called with input: ' + str(cid))
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_commit input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})   
+#     
+# class fe_post_composition_set_nodepolicies:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_composition_set_nodepolicies is called with input: ' + str(cid))
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_set_nodepolicies input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})   
+#     
+# class fe_post_composition_add_node:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         webinput = web.input(cid='unknown_cid')
+#         print( 'post_composition_add_node is called with input: ' + str(webinput))
+#         cid = webinput.cid
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_add_node input json data: ' + str(in_data))
+#         
+#         workbook_db = ToscaDB()
+#         if cid not in workbook_db:
+#             workbook_db[cid] = ToscaWorkBook() 
+# 
+#         if 'type' in in_data:
+#             if 'name' in in_data['type']:
+#                 print( 'add node type: ' + in_data['type']['name'])
+#                 new_node = workbook_db[cid]._use(in_data['type']['name'])
+#                 new_node.fe_json = in_data
+#                 if 'nid' in in_data:
+#                     new_node.fe_nid = in_data['nid']
+#             else:
+#                 print( 'in_data has type but no name')
+#         else:
+#             print( 'in_data has no type')
+#             
+#         
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         
+#         return json.dumps(in_data)   
+# 
+# class fe_post_composition_update_nodes:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         webinput = web.input(cid='unknown_cid')
+#         print( 'post_composition_update_nodes is called with input: ' + str(webinput))
+#         cid = webinput.cid
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_update_nodes input json data: ' + str(in_data))
+#          
+#         workbook_db = ToscaDB()
+#        
+#         if cid not in workbook_db:
+#             workbook_db[cid] = ToscaWorkBook() 
+# 
+#         for in_item in in_data:
+#             if 'nid' in in_item :
+#                 for node in workbook_db[cid].template.node_dict.itervalues():
+#                     if node.fe_nid == in_data['nid']:
+#                         node.fe_json.update(in_item)
+#                         break
+#             else:
+#                 print( 'one item has no nid')
+# 
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})   
+# 
+# class fe_post_composition_delete_node:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_composition_delete_nodes is called with input: ' + str(cid))
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_delete_nodes input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})   
+# 
+# class fe_post_composition_add_relation:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_composition_add_relation is called with input: ' + str(cid))
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_add_relation input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})   
+# 
+# class fe_post_composition_delete_relation:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_composition_delete_relation is called with input: ' + str(cid))
+#         in_data = json.loads(web.data())
+#         print( 'post_composition_delete_relation input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})   
+#     
+# class fe_post_composition_add_inputs:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_composition_add_inputs is called with input: ' + str(cid))
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_add_inputs input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})  
+#     
+# class fe_post_composition_add_outputs:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_composition_add_outputs is called with input: ' + str(cid))
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_add_outputs input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})  
+#     
+# class fe_post_composition_set_node_properties:
+#     def OPTIONS(self):
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return ''
+#     def POST(self):
+#         cid = web.input()
+#         print( 'post_composition_set_node_properties is called with input: ' + str(cid))
+#         try:
+#             in_data = json.loads(web.data())
+#         except ValueError as e:
+#             in_data = web.data()
+#         print( 'post_composition_set_node_properties input json data: ' + str(in_data))
+#         web.header('Content-Type', 'application/json')
+#         web.header('Access-Control-Allow-Origin', '*')
+#         web.header('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token')
+#         return json.dumps({})  
+#     
+# class upload:
+#     def POST(self, dir):
+# #        data = json.loads(web.data())
+# #        pyDict = {'one':1,'two':2}
+# #        web.header('Content-Type', 'application/json')
+# #        return json.dumps(pyDict)
+#         return 'OK'
+#     
+# class import_file:
+#     def GET(self):
+#         user_data = web.input(dir='')
+#         file_dir = user_data.dir
+#         if 'name' not in user_data:
+#             return 'Error: input has no file name'
+#         file_name = user_data.name
+#         workbook = ToscaWorkBook()
+#         workbook._import( file_dir +'/'+ file_name)
+#         return 'OK'
+#     
+# class use:
+#     def GET(self):
+#         user_data = web.input()
+#         if 'type' not in user_data or 'name' not in user_data:
+#             return 'Error: input has no type or name'
+#         use_type = user_data['type']
+#         name = user_data['name']
+#         
+#         workbook = ToscaWorkBook()
+# 
+#         workbook._use(name)
+#         return 'OK'
+#     
+# class assign:
+#     def GET(self):
+#         user_data = web.input()
+#         if 'src_node') is False or user_data.has_key('value') is False:
+#             return 'Error: input has no src_node or value'
+#         src = user_data.src_node
+#         dst_val = user_data.value
+#         
+#         sub2 = None
+#         if user_data.has_key('property'):
+#             sub = user_data.property
+#         elif user_data.has_key('capability'):
+#             sub = user_data.capability
+#             if user_data.has_key('capability_property') is False:
+#                 return "Error: input has capability but no capability_property"
+#             else:
+#                 sub2 = user_data.capability_property
+#         elif user_data.has_key('requirement'):
+#             sub = user_data.requirement
+#         
+#         workbook = ToscaWorkBook()
+# 
+#         if sub2 is None:
+#             workbook._assign(src, sub, dst_val)
+#         else:
+#             workbook._assign(src, sub, sub2, dst_val)
+# 
+#         return 'OK'
+#     
+# class clear:
+#     def GET(self):
+#         workbook = ToscaWorkBook()
+# 
+#         workbook._reset()
+#         return 'OK'
+# 
+# class show:
+#     def GET(self):
+#         user_data = web.input(level='details')
+#         workbook = ToscaWorkBook()
+# 
+#         if user_data.level == 'details':         
+#             return workbook._show_details()
+#         else:
+#             return workbook._show_abstract()
+#     
+# class export:
+#     def GET(self):
+#         user_data = web.input(type='tosca', translation='off')
+#         workbook = ToscaWorkBook()
+# 
+#         if user_data.translation == 'on':
+#             if user_data.has_key('translation_lib'):
+#                 tran_lib = user_data.translation_lib
+#                 workbook._load_translation_db(tran_lib)
+# 
+#         if user_data.type == 'tosca':
+#             return workbook._export_yaml_web()
+#         elif user_data.type == 'heat':
+#             return 
+#         else:
+#             return 'Error in export type: only tosca or heat are supported'
+        
+class translate_template:
+    def POST(self):
+        try:
+            in_data = json.loads(web.data().decode('utf-8'))
+        except ValueError as e:
+            in_data = web.data()
+        print( 'translate_template input json data: ' + str(in_data))
+        
+        workbook = ToscaWorkBook()
+        workbook._import_dir('./data/shared_model/')
+#        workbook._load_translation_db('./data/shared_model/')
+        
+        if 'models' in in_data:
+            in_model = in_data['models']
+            if type(in_model) != list:
+                print( 'models in the input should be a list type')
+            for model_entry in in_model:
+                for key in ['schema', 'template', 'translate']:
+                    if key in model_entry:
+                        workbook._import_yml_str(base64.b64decode(model_entry[key]))
+        
+        if 'template' in in_data:
+            in_temp = in_data['template']
+            workbook._translate_template_yaml_str(base64.b64decode(in_temp))
+            workbook._add_shared_node([{'dcae.capabilities.cdapHost':'cdap_host'}, {'dcae.capabilities.dockerHost': 'docker_host'}, {'dcae.capabilities.composition.host': 'composition_virtual'}])
+                        
+        ret = workbook._export_yaml_web('cloudify,main')
+        print(ret)
+        return ret
+    
+class model_create:
+    def POST(self):
+        try:
+            in_data = json.loads(web.data().decode('utf-8'))
+        except ValueError as e:
+            in_data = web.data()
+        print( 'model_create input json data: ' + str(in_data))
+        
+        ret = {}
+        if 'spec' in in_data:
+            spec_str = in_data['spec']
+            model_prefix = './data/tosca_model'
+            meta_model = './data/meta_model/meta_tosca_schema.yaml'
+            
+            builder = ToscaBuilder()
+        
+            builder.import_schema(meta_model)
+            builder.import_spec_str(spec_str)
+            name = builder.spec_import.name
+            builder.create_node_type()
+
+            filename = model_prefix + '/'+ name + '/schema.yaml'
+            dirname = os.path.dirname(filename)           
+            try:
+                os.stat(dirname)
+            except:
+                os.mkdir(dirname)      
+                        
+            schema_str = builder.export_schema(model_prefix+'/' + name + '/schema.yaml')
+            builder.import_schema(model_prefix+'/' + name + '/schema.yaml')
+            builder.create_model(name)
+            template_str = builder.export_model(model_prefix+'/' + name + '/template.yaml')
+            builder.create_translate(name)
+            translate_str = builder.export_translation(model_prefix+'/' + name + '/translate.yaml')
+        
+            ret['schema'] = (base64.encodestring(bytes(schema_str, 'utf-8'))).decode('utf-8')
+            ret['template'] = base64.encodestring(bytes(template_str, 'utf-8')).decode('utf-8')
+            ret['translate'] = base64.encodestring(bytes(translate_str, 'utf-8')).decode('utf-8')
+        
+        return json.dumps(ret)
+
+
+# Story 318043 - The TOSCA Lab server should expose API for healthcheck with response:
+# {
+#   "healthCheckComponent": "TOSCA_LAB",
+#   "healthCheckStatus": "<UP / DOWN>",
+#   "version": "<component version>",
+#   "description": "<OK or error description>"
+# }
+class health_check:
+    def GET(self):
+        ret = dict()
+        ret['healthCheckComponent'] = "TOSCA_LAB"
+        ret['healthCheckStatus'] = "UP"
+        ret['version'] = __version__
+        ret['description'] = "OK"
+        print ('TOSCA_LAB got healthcheck request and returns' + str(ret))
+        return json.dumps(ret)
+        
+            
+class MyApplication(web.application):
+    def run(self, port=8080, *middleware):
+        func = self.wsgifunc(*middleware)
+        return web.httpserver.runsimple(func, ('0.0.0.0', port))
+
+urls = (
+    '/upload/(.*)', 'upload',
+    '/import', 'import_file',   #/import?dir=xxx&name=xxx
+    '/use', 'use',              #/use?type=xxx&name=xxx
+    '/assign', 'assign',        #/assign?src_node=xxx&[property|capability|requrement]=xxx&[capability_property=xxx]&value]xxx
+    '/clear', 'clear',          #/clear
+    '/show', 'show',            #/show?[level=abstract/details]
+    '/export', 'export',         #/export?[type=tosca/heat]&[translation=[on|off]]&[translation_lib=xxx]
+    '/itembyid', 'fe_get_itembyid',
+    '/template', 'fe_get_template',
+    '/type', 'fe_get_type',
+    '/compositioncreate', 'fe_get_compositioncreate',
+    '/ice.html', 'fe_get_ice',
+    '/compimg', 'fe_post_compimg',
+    '/composition.commit', 'fe_post_composition_commit',
+    '/composition.setnodepolicies', 'fe_post_composition_set_nodepolicies',
+    '/composition.addnode', 'fe_post_composition_add_node',
+    '/composition.updatenodes', 'fe_post_composition_update_nodes',
+    '/composition.deletenode', 'fe_post_composition_delete_node',
+    '/composition.addrelation', 'fe_post_composition_add_relation',
+    '/composition.deleterelation', 'fe_post_composition_delete_relation',
+    '/composition.addinputs', 'fe_post_composition_add_inputs',
+    '/composition.addoutputs', 'fe_post_composition_add_outputs',
+    '/composition.setnodeproperties', 'fe_post_composition_set_node_properties',
+    '/translate', 'translate_template',
+    '/model_create', 'model_create',
+    '/healthcheck', 'health_check')
+
+application = web.application(urls, globals(), autoreload=False).wsgifunc()
+
+
+if __name__ == "__main__":
+    app = MyApplication(urls, globals())
+    if len(sys.argv) > 1:
+        app.run(int(sys.argv[1]))
+    else:
+        app.run()
+
+
diff --git a/app/tosca_server.pyc b/app/tosca_server.pyc
new file mode 100644
index 0000000..89984f4
--- /dev/null
+++ b/app/tosca_server.pyc
diff --git a/app/toscalib/__init__.py b/app/toscalib/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/app/toscalib/__init__.py
diff --git a/app/toscalib/__init__.pyc b/app/toscalib/__init__.pyc
new file mode 100644
index 0000000..57447a6
--- /dev/null
+++ b/app/toscalib/__init__.pyc
diff --git a/app/toscalib/templates/__init__.py b/app/toscalib/templates/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/app/toscalib/templates/__init__.py
diff --git a/app/toscalib/templates/__init__.pyc b/app/toscalib/templates/__init__.pyc
new file mode 100644
index 0000000..a70f506
--- /dev/null
+++ b/app/toscalib/templates/__init__.pyc
diff --git a/app/toscalib/templates/capability_item.py b/app/toscalib/templates/capability_item.py
new file mode 100644
index 0000000..e96ee43
--- /dev/null
+++ b/app/toscalib/templates/capability_item.py
@@ -0,0 +1,73 @@
+from toscalib.templates.constant import *
+from toscalib.templates.property_item import PropertyItem
+import logging
+
+class CapabilityItem(object):
+    def __init__(self, definition):
+        self.name = definition.name
+        self.type = definition.type
+        self.definition = definition
+        self.properties = {}
+        self.id = PropertyItem(definition.id)
+        self.sub_pointer = None
+        self.parent_node = None
+        for prop in definition.properties.keys():
+            self.properties[prop] = PropertyItem(definition.properties[prop])
+        
+    def _parse_pre_defined_content(self, content):
+        if content is None:
+            return
+#        if content.has_key(CAP_PROPERTIES):
+        if CAP_PROPERTIES in content:
+            prop_sec = content[CAP_PROPERTIES]
+            for prop_name in prop_sec.keys():
+                prop_item = self._get_property_item(prop_name)
+                if prop_item is not None:
+                    prop_item._assign(prop_sec[prop_name])
+
+    def _propagate_substitution_value(self):
+        converge = True
+        for prop_item in iter(self.properties.values()):
+            converge = converge and prop_item._propagate_substitution_value()
+        
+        if self.sub_pointer is None:
+            return converge
+        
+        if self.id.value is None:
+            old_val = None
+        else:
+            old_val = self.id.value._get_value()[0]
+        
+        if isinstance(self.sub_pointer, PropertyItem):
+            if self.sub_pointer.value is None:
+                logging.warning( 'Something is wrong, the cap id mapping target'+ self.sub_pointer.name+ ' should have a value!')
+                return converge
+            self.id._direct_assign(self.sub_pointer.value)
+        from toscalib.templates.node import Node
+        if isinstance(self.sub_pointer, Node):
+            if self.sub_pointer.id is None or self.sub_pointer.id.value is None:
+                logging.warning( 'Something is wrong, the cap id mapping target'+ self.sub_pointer.name+ ' should have a value!')
+                return converge
+            self.id._direct_assign(self.sub_pointer.id.value)
+        
+        if self.id.value is None:
+            new_val = None
+        else:      
+            new_val = self.id.value._get_value()[0]
+        return converge and (old_val == new_val)
+
+    def _get_property_item(self, prop_name):
+#        if self.properties.has_key(prop_name):
+        if prop_name in self.properties:
+            return self.properties[prop_name]
+        else:
+            logging.warning('Capability: '+ self.name+ ' of type: '+ self.type+ ' has no property: '+ prop_name)
+            return None
+    
+    def _validate_capability(self, cap_name):
+        return self.definition._validate_capability(cap_name)
+            
+    def _update_parent_node(self, parent):
+        self.parent_node = parent
+        for prop in iter(self.properties.values()):
+            prop._update_parent_node(parent)
diff --git a/app/toscalib/templates/capability_item.pyc b/app/toscalib/templates/capability_item.pyc
new file mode 100644
index 0000000..3a7d971
--- /dev/null
+++ b/app/toscalib/templates/capability_item.pyc
diff --git a/app/toscalib/templates/constant.py b/app/toscalib/templates/constant.py
new file mode 100644
index 0000000..101abaa
--- /dev/null
+++ b/app/toscalib/templates/constant.py
@@ -0,0 +1,82 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+YMO_PREFIX=r'.._YAMLORDER_'
+
+TRUE_VALUES = ('True', 'TRUE', 'true', 'yes', 'Yes', 'YES', '1')
+
+TEMPLATE_SECTIONS = (VERSION, METADATA, DESCRIPTION, DSL, 
+                     REPO, IMPORT, ARTIFACT_TYPE, DATA_TYPE, CAPABILITY_TYPE,
+                     INTERFACE_TYPE, RELATIONSHIP_TYPE, NODE_TYPE, GROUP_TYPE,
+                     POLICY_TYPE,  TOPOLOGY) = \
+                    ('tosca_definitions_version', 'metadata', 'description', 'dsl_definitions',
+                     'repositories', 'imports', 'artifact_types', 'data_types', 'capability_types',
+                     'interface_types', 'relationship_types', 'node_types', 'group_types',
+                     'policy_types', 'topology_template' )
+                    
+YAML_ORDER_TEMPLATE_SECTIONS = (YMO_VERSION, YMO_METADATA, YMO_DESCRIPTION, YMO_DSL, 
+                     YMO_REPO, YMO_IMPORT, YMO_ARTIFACT_TYPE, YMO_DATA_TYPE, YMO_CAPABILITY_TYPE,
+                     YMO_INTERFACE_TYPE, YMO_RELATIONSHIP_TYPE, YMO_NODE_TYPE, YMO_GROUP_TYPE,
+                     YMO_POLICY_TYPE,  YMO_TOPOLOGY) = \
+                    ('00_YAMLORDER_tosca_definitions_version', '02_YAMLORDER_metadata', '01_YAMLORDER_description', '03_YAMLORDER_dsl_definitions',
+                     '04_YAMLORDER_repositories', '05_YAMLORDER_imports', '06_YAMLORDER_artifact_types', '07_YAMLORDER_data_types', '08_YAMLORDER_capability_types',
+                     '09_YAMLORDER_interface_types', '10_YAMLORDER_relationship_types', '11_YAMLORDER_node_types', '12_YAMLORDER_group_types',
+                     '13_YAMLORDER_policy_types', '14_YAMLORDER_topology_template' )
+
+# Topology template key names
+TOPOLOGY_SECTIONS = (TOPO_DESCRIPTION, TOPO_INPUTS, TOPO_NODE_TEMPLATES,
+            TOPO_RELATIONSHIP_TEMPLATES, TOPO_OUTPUTS, TOPO_GROUPS,
+            TOPO_SUBSTITUION_MAPPINGS) = \
+           ('description', 'inputs', 'node_templates',
+            'relationship_templates', 'outputs', 'groups',
+            'substitution_mappings')
+           
+YAML_ORDER_TOPOLOGY_SECTIONS = (YMO_TOPO_DESCRIPTION, YMO_TOPO_INPUTS, YMO_TOPO_NODE_TEMPLATES,
+            YMO_TOPO_RELATIONSHIP_TEMPLATES, YMO_TOPO_OUTPUTS, YMO_TOPO_GROUPS,
+            YMO_TOPO_SUBSTITUION_MAPPINGS) = \
+           ('10_YAMLORDER_description', '11_YAMLORDER_inputs', '13_YAMLORDER_node_templates',
+            '14_YAMLORDER_relationship_templates', '16_YAMLORDER_outputs', '15_YAMLORDER_groups',
+            '12_YAMLORDER_substitution_mappings')
+
+SUBSTITUTION_SECTION = (SUB_NODE_TYPE, SUB_PROPERTY, SUB_ATTRIBUTE, SUB_REQUIREMENT, SUB_CAPABILITY, SUB_CAP_PROPERTY, SUB_CAP_ID, SUB_REQ_ID, SUB_INPUT, SUB_OUTPUT) = \
+                ('node_type', 'properties', 'attributes', 'requirements', 'capabilities', 'properties', 'id', 'id', 'INPUT', 'OUTPUT')
+                
+YAML_ORDER_SUBSTITUTION_SECTION = (YMO_SUB_NODE_TYPE, YMO_SUB_PROPERTY, YMO_SUB_REQUIREMENT, YMO_SUB_CAPABILITY) = \
+                ('00_YAMLORDER_node_type', '01_YAMLORDER_properties', '03_YAMLORDER_requirements', '02_YAMLORDER_capabilities')
+                
+REQUIREMENT_SECTION = (REQ_NODE, REQ_RELATIONSHIP, REQ_CAPABILITY, REQ_OCCURRENCE, REQ_FILTER) = \
+                ('node', 'relationship', 'capability', 'occurrences', 'node_filter') 
+                
+YAML_ORDER_REQUIREMENOD_ASSIGNMENOD_SECTION = (YMO_REQ_NODE, YMO_REQ_RELATIONSHIP, YMO_REQ_CAPABILITY, YMO_REQ_OCCURRENCE, YMO_REQ_FILTER) = \
+                ('01_YAMLORDER_node', '02_YAMLORDER_relationship', '00_YAMLORDER_capability', '04_YAMLORDER_occurrences', '03_YAMLORDER_node_filter') 
+
+NODE_SECTION = (NOD_DERIVED_FROM, NOD_TYPE, NOD_PROPERTIES, NOD_ATTRIBUTES, NOD_REQUIREMENTS,
+            NOD_INTERFACES, NOD_CAPABILITIES, NOD_ARTIFACTS, NOD_DESCRIPTION) = \
+               ('derived_from', 'type', 'properties', 'attributes', 'requirements',
+                'interfaces', 'capabilities', 'artifacts', 'description')
+               
+YAML_ORDER_NODETYPE_DEFINITION = (YMO_NOD_DERIVED_FROM, YMO_NOD_TYPE, YMO_NOD_PROPERTIES, YMO_NOD_ATTRIBUTES, YMO_NOD_REQUIREMENTS, YMO_NOD_RELATIONSHIPS,
+            YMO_NOD_INTERFACES, YMO_NOD_CAPABILITIES, YMO_NOD_ARTIFACTS, YMO_NOD_DESCRIPTION) = \
+               ('00_YAMLORDER_derived_from', '00_YAMLORDER_type', '01_YAMLORDER_properties', '03_YAMLORDER_attributes', '05_YAMLORDER_requirements', '05_YAMLORDER_relationships',
+                '06_YAMLORDER_interfaces', '04_YAMLORDER_capabilities', '07_YAMLORDER_artifacts', '02_YAMLORDER_description')  
+
+CAPABILITY_SECTION = (CAP_DERIVED_FROM, CAP_TYPE, CAP_PROPERTIES, CAP_ATTRIBUTES, 
+                      CAP_VERSION, CAP_DESCEIPTION, CAP_SOURCE ) = \
+               ('derived_from', 'type', 'properties', 'attributes', 
+                'version', 'description', 'valid_source_type')
+               
+               
+PROPERTY_SECTION = (PROP_TYPE, PROP_REQUIRED, PROP_DEFAULT, PROP_DESCRIPTION, 
+                    PROP_STATUS, PROP_ENTRY, PROP_CONSTRAINT) = \
+                ('type', 'required', 'default', 'description', 
+                 'status', 'entry_schema', 'constraints')
+                
+YAML_ORDER_PROPERTY_SECTION = (YMO_PROP_TYPE, YMO_PROP_REQUIRED, YMO_PROP_DEFAULT, YMO_PROP_DESCRIPTION, 
+                    YMO_PROP_STATUS, YMO_PROP_ENTRY, YMO_PROP_CONSTRAINT) = \
+                ('00_YAMLORDER_type', '01_YAMLORDER_required', '03_YAMLORDER_default', '02_YAMLORDER_description', 
+                 '04_YAMLORDER_status', '05_YAMLORDER_entry_schema', '06_YAMLORDER_constraints')  
+
+
+YAML_ORDER_INTERFACE_SECTION = (YMO_INT_TYPE, YMO_INT_INPUTS, YMO_OP_DESCRIPTION, YMO_OP_IMPLEMENTATION, YMO_OP_EXECUTOR, YMO_OP_INPUTS) = \
+                ('00_YAMLORDER_type', '01_YAMLORDER_inputs', '02_YAMLORDER_description', 
+                 '03_YAMLORDER_implementation', '04_YAMLORDER_executor', '05_YAMLORDER_inputs')                  
diff --git a/app/toscalib/templates/constant.pyc b/app/toscalib/templates/constant.pyc
new file mode 100644
index 0000000..6335388
--- /dev/null
+++ b/app/toscalib/templates/constant.pyc
diff --git a/app/toscalib/templates/database.py b/app/toscalib/templates/database.py
new file mode 100644
index 0000000..7e21148
--- /dev/null
+++ b/app/toscalib/templates/database.py
@@ -0,0 +1,113 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+from toscalib.templates.constant import *
+import logging
+
+class ToscaDB(object):
+    """ The database that stores all node types and TEMPLATES """
+    def __init__(self):
+        self.NODE_TYPES = {}
+        self.CAPABILITY_TYPES = {}
+        self.RELATIONSHIP_TYPES = {}
+        self.DATA_TYPES = {}
+        self.TEMPLATES = {}
+        
+    def _import_node_type(self, new_type):
+        if new_type is None:
+            return
+#        if self.NODE_TYPES.has_key(new_type.name) == True:
+        if new_type.name in self.NODE_TYPES:
+            logging.debug( 'Node type: '+ new_type.name+ ' already defined and will be overwritten')
+        self.NODE_TYPES[new_type.name]=new_type
+            
+    def _import_capability_type(self, new_type):
+        if new_type is None:
+            return
+#        if self.CAPABILITY_TYPES.has_key(new_type.name) == True:
+        if new_type.name in self.CAPABILITY_TYPES:
+            logging.debug( 'Capability type: '+ new_type.name+ ' already defined and will be overwritten')
+
+        self.CAPABILITY_TYPES[new_type.name]=new_type
+
+    def _import_relationship_type(self, new_type):
+        if new_type is None:
+            return
+#        if self.RELATIONSHIP_TYPES.has_key(new_type.name) == True:
+        if new_type.name in self.RELATIONSHIP_TYPES:
+            logging.debug( 'Relationship type: '+ new_type.name+ ' already defined and will be overwritten')
+
+        self.RELATIONSHIP_TYPES[new_type.name]=new_type
+
+    def _import_data_type(self, new_type):
+        if new_type is None:
+            return
+#        if self.DATA_TYPES.has_key(new_type.name) == True:
+        if new_type.name in self.DATA_TYPES:
+            logging.debug( 'Data type: '+ new_type.name+ ' already defined and will be overwritten')
+        self.DATA_TYPES[new_type.name]=new_type
+
+    def _import_template(self, new_template):
+        if new_template is None:
+            return
+#        if self.TEMPLATES.has_key(new_template.name) == False:
+        if new_template.name not in self.TEMPLATES :
+            self.TEMPLATES[new_template.name]= new_template        
+    
+    def _parse_objects(self):
+        logging.debug( 'parsing database')
+#        for objs in self.NODE_TYPES.itervalues():
+        for objs in iter(self.NODE_TYPES.values()):
+            objs._parse_content(self)
+#        for objs in self.CAPABILITY_TYPES.itervalues():
+        for objs in iter(self.CAPABILITY_TYPES.values()):
+            objs._parse_content(self)
+#        for objs in self.DATA_TYPES.itervalues():
+        for objs in iter(self.DATA_TYPES.values()):
+            objs._parse_content(self)
+#        for objs in self.RELATIONSHIP_TYPES.itervalues():
+        for objs in iter(self.RELATIONSHIP_TYPES.values()):
+            objs._parse_content(self)
+#        for objs in self.TEMPLATES.itervalues():
+        for objs in iter(self.TEMPLATES.values()):
+            objs._parse_content(self)
+            
+            
+    def _prepare_schema(self):
+        schema_output = {}
+        data_sec = {}
+        for key in self.DATA_TYPES.keys():
+            objs = self.DATA_TYPES[key]
+            data_sec[key] = objs.raw_content
+        node_sec = {}
+        for key in self.NODE_TYPES.keys():
+            objs = self.NODE_TYPES[key]
+            if objs.raw_content is None:
+                objs._create_rawcontent()
+            node_sec[key]=objs.raw_content
+        cap_sec = {}
+        for key in self.CAPABILITY_TYPES.keys():
+            objs = self.CAPABILITY_TYPES[key]
+            cap_sec[key]=objs.raw_content
+        rel_sec = {}
+        for key in self.RELATIONSHIP_TYPES.keys():
+            objs = self.RELATIONSHIP_TYPES[key]
+            rel_sec[key]=objs.raw_content
+            
+        if len(data_sec) > 0:
+            schema_output[YMO_DATA_TYPE] = data_sec
+        if len(node_sec) > 0:
+            schema_output[YMO_NODE_TYPE] = node_sec
+        if len(cap_sec) > 0:
+            schema_output[YMO_CAPABILITY_TYPE] = cap_sec
+        if len(rel_sec) > 0:
+            schema_output[YMO_RELATIONSHIP_TYPE] = rel_sec
+        
+        schema_output[YMO_VERSION]= 'tosca_simple_yaml_1_0_0'
+        
+        return schema_output
+            
+    
+            
+            
+            
+\ No newline at end of file
diff --git a/app/toscalib/templates/database.pyc b/app/toscalib/templates/database.pyc
new file mode 100644
index 0000000..e7f651f
--- /dev/null
+++ b/app/toscalib/templates/database.pyc
diff --git a/app/toscalib/templates/heat_constants.py b/app/toscalib/templates/heat_constants.py
new file mode 100644
index 0000000..365d38f
--- /dev/null
+++ b/app/toscalib/templates/heat_constants.py
@@ -0,0 +1,7 @@
+HOT_TEMPLATE = (HOT_VERSION, HOT_DESCRIPTION, HOT_PARAMETERS, HOT_RESOURCES, 
+                YMO_HOT_VERSION, YMO_HOT_DESCRIPTION, YMO_HOT_PARAMETERS, YMO_HOT_RESOURCES ) = \
+               ('heat_template_version', 'description', 'parameters', 'resources', 
+                '00_YAMLORDER_heat_template_version', '01_YAMLORDER_description', 
+                '02_YAMLORDER_parameters', '03_YAMLORDER_resources')
+               
+HOT_VERSION_NUM = '2013-05-23'
+\ No newline at end of file
diff --git a/app/toscalib/templates/heat_constants.pyc b/app/toscalib/templates/heat_constants.pyc
new file mode 100644
index 0000000..379bc4e
--- /dev/null
+++ b/app/toscalib/templates/heat_constants.pyc
diff --git a/app/toscalib/templates/interface_item.py b/app/toscalib/templates/interface_item.py
new file mode 100644
index 0000000..9fd7fa9
--- /dev/null
+++ b/app/toscalib/templates/interface_item.py
@@ -0,0 +1,80 @@
+from toscalib.templates.property_item import PropertyItem
+from toscalib.templates.operation_item import OperationItem
+from toscalib.types.property import PropertyDefinition
+from toscalib.templates.constant import *
+import logging
+
+class InterfaceItem(object):
+    def __init__(self, definition, name = None, content = None):
+        if definition is not None:
+            self.name = definition.name
+            self.type = definition.type
+            self.definition = definition
+            self.inputs = {}
+            self.operations = {}
+            self.parent_node = None
+            for prop in definition.inputs.keys():
+                self.inputs[prop] = PropertyItem(definition.inputs[prop])
+            for oper in definition.operations.keys():
+                self.operations[oper] = OperationItem(definition.operations[oper])
+        else:
+            self.name = name
+            self.type = None
+            self.definition = None
+            self.inputs = {}
+            self.operations = {}
+            self.parent_node = None
+        
+        self._parse_pre_defined_content(content)
+        
+    def _parse_pre_defined_content(self, content):
+        if content is None:
+            return
+        
+        for key_name in content.keys():         
+            if key_name == 'type':
+                if self.type is not None and self.type != content[key_name]:
+                    logging.warning( 'interface: '+ self.name+ 'type is different in definition: '+ self.type+ ' overwritten here to '+ self.raw_content[key_name])
+                self.type = content[key_name]
+                continue
+            if key_name == 'inputs':
+                input_sec = content['inputs']
+                for input_item in input_sec.keys():
+                    self.inputs[input_item] = PropertyItem(PropertyDefinition(input_item))
+                    self.inputs[input_item]._assign(input_sec[input_item])
+                continue
+            
+#            if self.operations.has_key(key_name):
+            if key_name in self.operations:
+                self.operations[key_name]._parse_pre_defined_content(content[key_name])
+            else:
+                self.operations[key_name] = OperationItem(None, key_name, content[key_name]) 
+            
+    def _update_parent_node(self, parent):
+        self.parent_node = parent
+        for prop in iter(self.inputs.values()):
+            prop._update_parent_node(parent)
+        for ops in iter(self.operations.values()):
+            ops._update_parent_node(parent)
+
+    def _prepare_output(self, tags=''):
+        output = {}
+        if 'cloudify' not in tags:
+            if self.type is not None:
+                output[YMO_INT_TYPE] = self.type
+            if len(self.inputs) > 0: 
+                inputs = {}
+                for prop_name in self.inputs.keys():
+                    prop_item = self.inputs[prop_name]
+                    if prop_item.value is None:
+                        prop_value = None
+                    else:
+                        prop_value = prop_item.value._get_value(tags)[0]
+                    inputs[prop_name] = prop_value
+                output[YMO_INT_INPUTS] = inputs
+        if len(self.operations) > 0:
+            for op_name in self.operations.keys():
+                output[op_name] = self.operations[op_name]._prepare_output(tags)
+ 
+        return output
+    
+\ No newline at end of file
diff --git a/app/toscalib/templates/interface_item.pyc b/app/toscalib/templates/interface_item.pyc
new file mode 100644
index 0000000..20d9f8c
--- /dev/null
+++ b/app/toscalib/templates/interface_item.pyc
diff --git a/app/toscalib/templates/node.py b/app/toscalib/templates/node.py
new file mode 100644
index 0000000..8a07a49
--- /dev/null
+++ b/app/toscalib/templates/node.py
@@ -0,0 +1,389 @@
+from toscalib.templates.constant import *
+from toscalib.types.node import NodeType
+from toscalib.templates.requirement_item import RequirementItem
+from toscalib.templates.property_item import PropertyItem
+from toscalib.templates.capability_item import CapabilityItem
+from toscalib.utils import tosca_import, tosca_heat
+
+import copy, re, logging
+from toscalib.templates.interface_item import InterfaceItem
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+
+class Node(object):
+    def __init__(self, template, node_name, node_type):
+        self.template = template
+        self.name = node_name
+        self.id = PropertyItem(node_type.id)   
+        self_id_str = {} 
+        self_id_str['get_attribute']= [node_name, 'id'] 
+        self.id._assign(self_id_str)
+        
+        self.mapping_template = None
+        self.tran_template = None
+        
+        self.fe_json = None
+        self.fe_nid = None
+         
+        if node_type is None:
+            logging.warning( 'Empty node type')
+            return
+        elif isinstance(node_type, NodeType) is False:
+            logging.warning( 'Invalid NodeType passed to Node: '+ node_name+ 'construction')
+            return
+        else:
+            self._instatiateWithType(node_type)
+
+#Instantiate the node type, when substitution mapping is attached, create the new template for it
+    def _instatiateWithType(self, node_type):
+        self.type = node_type.name
+        self.type_obj = node_type
+        
+        self.properties = {}
+        for prop in node_type.properties.keys():
+            self.properties[prop] = PropertyItem(node_type.properties[prop])
+            
+        self.attributes = {}
+        for attr in node_type.attributes.keys():
+            self.attributes[attr] = PropertyItem(node_type.attributes[attr])
+        
+        self.requirements = []
+        for req in node_type.requirements:
+            self.requirements.append(RequirementItem(req))
+            
+        self.capabilities = {}
+        for cap in node_type.capabilities.keys():
+            self.capabilities[cap] = CapabilityItem(node_type.capabilities[cap])
+            
+        self.interfaces = {}
+        for intf in node_type.interfaces.keys():
+            self.interfaces[intf] = InterfaceItem(node_type.interfaces[intf])
+
+        if node_type.mapping_template is not None:
+            from toscalib.templates.topology import  ToscaTopology
+            self.mapping_template = copy.deepcopy(node_type.mapping_template)
+            self.mapping_template._update_prefix(self.name + '_')
+            self.mapping_template._verify_substitution(self)
+#             for sub_rule in node_type.mapping_template.sub_rules:
+#                 sub_rule._update_pointer(self, self.mapping_template)
+
+        self._update_parent_node()
+        
+#used to parse node template structure written in a template
+#Assign values if needed
+#For requirement fulfillment, add pending mode to check whether the value is a node template or type      
+    def _parse_pre_defined_content(self, content):
+#        if content.has_key(NOD_PROPERTIES):
+        if NOD_PROPERTIES in content:
+            prop_sec = content[NOD_PROPERTIES]
+            if prop_sec is not None:
+                for prop_name in prop_sec.keys():
+                    prop_item = self._get_property_item(prop_name)
+                    if prop_item is not None:
+                        prop_item._assign(prop_sec[prop_name])
+                        if prop_sec[prop_name] == '__GET_NODE_NAME__':
+                            prop_item._assign(self.name)
+                        
+#        if content.has_key(NOD_REQUIREMENTS):
+        if NOD_REQUIREMENTS in content:
+            req_sec = content[NOD_REQUIREMENTS]
+            if req_sec is not None:                
+                for req in req_sec:
+                    req_item_name, req_item_value = tosca_import._parse_requirement_name_and_value(req)
+#TODO: the same requirement name can only appear once!!
+                    req_item = self._get_requirement_item_first(req_item_name)
+                    if req_item is not None:
+                        req_item._parse_pre_defined_content(req_item_value) 
+                    else:
+                        logging.warning( 'Requirement '+ req_item_name +'not defined in Node '+ self.name + ' of type '+ self.type)
+
+#        if content.has_key(NOD_CAPABILITIES):
+        if NOD_CAPABILITIES in content:
+            cap_sec = content[NOD_CAPABILITIES]
+            if cap_sec is not None:
+                for cap_name in cap_sec.keys():
+                    cap_item = self._get_capability_item(cap_name)
+                    if cap_item is not None: 
+                        cap_item._parse_pre_defined_content(cap_sec[cap_name])
+                        
+#        if content.has_key(NOD_INTERFACES):
+        if NOD_INTERFACES in content:
+            interface_sec = content[NOD_INTERFACES]
+            if interface_sec is not None:
+                for interface_name in interface_sec.keys():
+                    interface_item = self._get_interface_item(interface_name)
+                    if interface_item is not None:
+                        interface_item._parse_pre_defined_content(interface_sec[interface_name])
+                    else:
+                        self.interfaces[interface_name] = InterfaceItem(None, interface_name, interface_sec[interface_name])  
+         
+        self._update_parent_node()   
+    
+    def _get_property_item(self, prop_name):
+#        if self.properties.has_key(prop_name):
+        if prop_name in self.properties:
+            return self.properties[prop_name]
+        else:
+            logging.warning('Node: '+ self.name+ ' of type: '+ self.type+ ' has no property: '+ prop_name)
+            return None
+
+    def _get_attribute_item(self, attr_name):
+#        if self.attributes.has_key(attr_name):
+        if attr_name in self.attributes:
+            return self.attributes[attr_name]
+        else:
+            logging.warning('Node: '+ self.name+ ' of type: '+ self.type+ ' has no attribute: '+ attr_name)
+            return None
+        
+    def _get_interface_item(self, interface_name):
+#        if self.interfaces.has_key(interface_name):
+        if interface_name in self.interfaces:
+            return self.interfaces[interface_name]
+        else:
+            logging.warning( 'Node: '+ self.name+ ' of type: '+ self.type+ ' has no interface: '+ interface_name)
+            return None    
+        
+    def _get_capability_item(self, cap_name):
+#        if self.capabilities.has_key(cap_name):
+        if cap_name in self.capabilities:
+            return self.capabilities[cap_name]
+        else:
+            #logging.debug('Node: '+ self.name+ ' of type: '+ self.type+ ' has no capability: '+ cap_name)
+            return None
+        
+    def _get_capability_property(self, cap_name, prop_name):
+        cap_item = self._get_capability_item(cap_name)
+        if cap_item is not None:
+            return cap_item._get_property_item(prop_name)
+        else:
+            #logging.debug( 'Node: '+ self.name+ ' of type: '+ self.type+ ' has no capability: '+ cap_name)
+            return None
+        
+    def _get_requirement_item_first(self, req_name):
+        for req_item in self.requirements:
+            if req_item.name == req_name:
+                return req_item
+        logging.warning( 'Node: '+ self.name+ ' of type: '+ self.type+ ' has no requirement: '+ req_name)
+        return None
+        
+    def _verify_requirements(self, node_dict):
+        for req in self.requirements:
+            req._verify_requirement(node_dict)
+     
+    def _verify_functions(self):
+        if self.id.value is not None:
+            self.id.value._update_function_reference(self.template, self, self.id)
+        for prop_item in iter(self.properties.values()):
+            if prop_item.value is not None:
+                prop_item.value._update_function_reference(self.template, self, prop_item)     
+        for cap_item in iter(self.capabilities.values()):
+            for cap_item_prop in iter(cap_item.properties.values()):
+                if cap_item_prop.value is not None:
+                    cap_item_prop.value._update_function_reference(self.template, self, cap_item_prop)  
+        for interface_item in iter(self.interfaces.values()):
+            for interface_item_input in iter(interface_item.inputs.values()):
+                if interface_item_input.value is not None: 
+                    interface_item_input.value._update_function_reference(self.template, self, interface_item_input)
+            for operation_item in iter(interface_item.operations.values()):
+                for input_item in iter(operation_item.inputs.values()):
+                    if input_item.value is not None:
+                        input_item.value._update_function_reference(self.template, self, input_item)
+    
+    def _update_parent_node(self):
+        for prop in iter(self.properties.values()):
+            prop._update_parent_node(self)
+        for cap in iter(self.capabilities.values()):
+            cap._update_parent_node(self)
+        for req in self.requirements:
+            req._update_parent_node(self)
+        for interface in iter(self.interfaces.values()):
+            interface._update_parent_node(self)
+        
+                
+    def  _update_prefix(self, prefix):
+        if self.name == 'NO_PREFIX':
+            self.name = prefix[:len(prefix)-1]
+        else:
+            self.name = prefix + self.name
+        self.id.value._update_prefix(prefix)
+        
+        for prop_item in iter(self.properties.values()):
+            if prop_item.value is not None:
+                prop_item.value._update_prefix(prefix)
+        for cap_item in iter(self.capabilities.values()):
+            for cap_item_prop in iter(cap_item.properties.values()):
+                if cap_item_prop.value is not None:
+                    cap_item_prop.value._update_prefix(prefix)
+        for interface_item in iter(self.interfaces.values()):
+            for interface_item_input in iter(interface_item.inputs.values()):
+                if interface_item_input.value is not None: 
+                    interface_item_input.value._update_prefix(prefix)
+            for operation_item in iter(interface_item.operations.values()):
+                for input_item in iter(operation_item.inputs.values()):
+                    if input_item.value is not None:
+                        input_item.value._update_prefix(prefix)
+       
+        for req in self.requirements:
+            req._update_prefix(prefix)
+    
+        self._update_parent_node()
+
+    def _verify_req_node(self, req_type, req_cap, req_filter):
+        if req_type is not None and self.type_obj._verify_req_type(req_type) is False:
+            logging.warning( 'Type matching failed')
+            return False
+
+        if req_cap is not None:
+            cap_found = None
+            for cap_item in iter(self.capabilities.values()):
+                if cap_item._validate_capability(req_cap) is True:
+                    cap_found = cap_item
+                    break
+            if cap_found is None:
+                logging.warning( 'Capability matching failed')
+                return False
+            
+        return self._verify_node_filter(req_filter)
+    
+    def _verify_node_filter(self, req_filter):
+        return True
+    
+    def _propagate_substitution_value(self):
+        converge = True
+        for prop_item in iter(self.properties.values()):
+            converge = converge and prop_item._propagate_substitution_value()
+        for req_item in self.requirements:
+            converge = converge and req_item._propagate_substitution_value()
+        for cap_item in iter(self.capabilities.values()):
+            converge = converge and cap_item._propagate_substitution_value()
+        for attr_item in iter(self.attributes.values()):
+            converge = converge and attr_item._propagate_attr_substitution_value()
+
+        
+        if self.mapping_template is not None:
+            self.mapping_template._propagate_substitution_value()
+        if self.tran_template is not None:
+            self.tran_template._propagate_substitution_value()
+        
+        return converge
+    
+    def _prepare_extra_imports(self, tags = ''):
+        if 'noexpand' in tags:
+            return []
+        if self.tran_template is not None:
+            return self.tran_template._prepare_extra_imports(tags)
+        if self.mapping_template is not None:
+            return self.mapping_template._prepare_extra_imports(tags)
+        return []
+    
+    def _prepare_output(self, tags=''):
+        if 'noexpand' not in tags:
+            newtags = tags.replace('main', 'part')
+            if self.tran_template is not None:
+                return self.tran_template._prepare_output(newtags)
+            if self.mapping_template is not None:
+                return self.mapping_template._prepare_output(newtags)
+        output = {}
+        if 'heat' in tags:
+            heat_type = re.sub('tosca.heat.', '', self.type)
+            heat_type = re.sub('\.', '::', heat_type)
+            output[YMO_NOD_TYPE] = heat_type
+        else:
+            output[YMO_NOD_TYPE] = self.type
+        prop_out = {}
+        for prop in self.properties.keys():
+            prop_item = self.properties[prop]
+#             if prop_item.required is False and prop_item.used is not True and prop_item.filled is not True:
+            if prop_item.required is False and prop_item.filled is not True:
+                continue
+            if prop_item.filled is not True or prop_item.value is None:
+                prop_value = None
+            else:
+                prop_value = prop_item.value._get_value(tags)[0]
+            if prop_item.required is False and prop_value in [None, [], {}]:
+                continue
+            else:            
+                prop_out[prop] = prop_value
+        cap_out={}
+        for cap in iter(self.capabilities.values()):
+            cap_item = {}
+            for cap_prop in iter(cap.properties.values()):
+                if cap_prop.filled is True:
+                    cap_item[cap_prop.name] = cap_prop.value._get_value(tags)[0]
+            if len(cap_item) > 0:
+                cap_out[cap.name] = {'properties': cap_item}
+
+        req_out = []            
+        for req in self.requirements:
+            if req.filled is True:
+                req_item = dict()
+                if 'cloudify' in tags:
+                    if req.relationship is not None :
+                        req_item['type'] = req.relationship
+                    else:                    
+                        req_item['type'] = 'cloudify.relationships.connected_to'
+                    req_item['target'] = req.str_value
+                else:
+                    req_item[req.name] = req.str_value
+                req_out.append(req_item)
+            elif req.filter is not None and 'cloudify' not in tags:
+                req_item = {}
+                if req.req_capability is not None:
+                    req_item[YMO_REQ_CAPABILITY] = req.req_capability
+                if req.req_type is not None:
+                    req_item[YMO_REQ_NODE] = req.req_type
+                if req.relationship is not None:
+                    req_item[YMO_REQ_RELATIONSHIP] = req.relationship
+                req_item[YMO_REQ_FILTER] = req.filter
+                req_out.append({req.name:req_item})
+        int_out = {}
+        for interface_name in self.interfaces.keys():
+            int_out[interface_name] = self.interfaces[interface_name]._prepare_output(tags) 
+            
+        if len(prop_out) > 0:
+            output[YMO_NOD_PROPERTIES]=prop_out
+        if len(req_out) > 0 and 'java_sim' not in tags:
+            if 'cloudify' in tags:
+                output[YMO_NOD_RELATIONSHIPS] = req_out
+            else:
+                output[YMO_NOD_REQUIREMENTS] = req_out
+        if len(cap_out) > 0 and 'cloudify' not in tags:
+            output[YMO_NOD_CAPABILITIES] = cap_out
+        if len(int_out) > 0 :
+            output[YMO_NOD_INTERFACES] = int_out
+        final_out = {}
+        final_out[self.name] = output
+        return final_out
+                   
+    def _prepare_heat_output(self, parameters_type, parameters_val):
+        if self.mapping_template is not None:
+            return self.mapping_template._prepare_heat_output(parameters_type, parameters_val, True)
+        else:
+            if tosca_heat._type_validate(self.type) is not True:
+                return None
+            output = {}
+            output[YMO_NOD_TYPE] = tosca_heat._type_translate(self.type)
+            prop_out = {}
+            for prop_item in iter(self.properties.values()):
+                if prop_item.filled:
+                    prop_out[prop_item.name] = prop_item.value
+                else:
+                    input_name = self.name + '_' + prop_item.name
+                    prop_out[prop_item.name] = '{ get_param: ' + input_name + ' }'
+                    input_type = {}
+                    input_type[input_name] = prop_item.type
+                    input_val = {}
+                    input_val[input_name] = prop_item.value
+                    parameters_type.update(input_type)
+                    parameters_val.udpate(input_val)
+            if len(prop_out) > 0:
+                output[YMO_NOD_PROPERTIES] = prop_out
+            final_out = {}
+            final_out[self.name] = output
+            return final_out
+             
+             
+    def toJson(self):
+        return self.fe_json   
+\ No newline at end of file
diff --git a/app/toscalib/templates/node.pyc b/app/toscalib/templates/node.pyc
new file mode 100644
index 0000000..3d780b7
--- /dev/null
+++ b/app/toscalib/templates/node.pyc
diff --git a/app/toscalib/templates/operation_item.py b/app/toscalib/templates/operation_item.py
new file mode 100644
index 0000000..8bc2612
--- /dev/null
+++ b/app/toscalib/templates/operation_item.py
@@ -0,0 +1,65 @@
+from toscalib.templates.property_item import PropertyItem
+from toscalib.types.property import PropertyDefinition
+from toscalib.templates.constant import *
+
+
+class OperationItem(object):
+    def __init__(self, definition, name = None, content = None):
+        if definition is not None:
+            self.name = definition.name
+            self.implementation = definition.implementation
+            self.definition = definition
+            self.inputs = {}
+            self.parent_node = None
+
+            for prop in definition.inputs.keys():
+                self.inputs[prop] = PropertyItem(definition.inputs[prop])
+        else:
+            self.name = name
+            self.implementation = None
+            self.definition = None
+            self.inputs = {}
+            self.parent_node = None
+        
+        if content is not None: 
+            self._parse_pre_defined_content(content)
+        
+    def _parse_pre_defined_content(self, content):
+        if content is None:
+            return
+
+        if type(content) is not dict:
+            self.implementation = content
+            return
+        
+        for key_name in content.keys():         
+            if key_name == 'implementation':
+                self.implementation = content[key_name]
+            if key_name == 'inputs':
+                input_sec = content['inputs']
+                for input_item in input_sec.keys():
+                    self.inputs[input_item] = PropertyItem(PropertyDefinition(input_item))
+                    self.inputs[input_item]._assign(input_sec[input_item])
+            
+    def _update_parent_node(self, parent):
+        self.parent_node = parent
+        for prop in iter(self.inputs.values()):
+            prop._update_parent_node(parent)
+        
+    def _prepare_output(self, tags=''):
+        output = {}
+#         if self.implementation is not None:
+#             output[YMO_OP_IMPLEMENTATION] = self.implementation
+#             if 'cloudify' in tags:
+#                 output[YMO_OP_EXECUTOR] = 'central_deployment_agent'
+        if len(self.inputs) > 0: 
+            inputs = {}
+            for prop_name in self.inputs.keys():
+                prop_item = self.inputs[prop_name]
+                if prop_item.value is None:
+                    prop_value = None
+                else:
+                    prop_value = prop_item.value._get_value(tags)[0]
+                inputs[prop_name] = prop_value
+            output[YMO_OP_INPUTS] = inputs
+        return output
diff --git a/app/toscalib/templates/operation_item.pyc b/app/toscalib/templates/operation_item.pyc
new file mode 100644
index 0000000..1d35b40
--- /dev/null
+++ b/app/toscalib/templates/operation_item.pyc
diff --git a/app/toscalib/templates/property_item.py b/app/toscalib/templates/property_item.py
new file mode 100644
index 0000000..dc6aea7
--- /dev/null
+++ b/app/toscalib/templates/property_item.py
@@ -0,0 +1,95 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+from toscalib.templates.constant import *
+import ast, logging
+
+class PropertyItem(object):
+    def __init__(self, definition):
+        self.name = definition.name
+        self.type_obj = definition.type_obj
+        self.filled = False
+        self.definition = definition
+        self.value = None
+        self.required = definition.required
+        self.sub_pointer = None
+        self.used = True
+        self.parent_node = None
+    
+    def _assign(self, value):
+#         from toscalib.templates.capability_item import CapabilityItem
+        from toscalib.templates.value import Value
+        if value is None:
+            return False
+#         elif isinstance(value, CapabilityItem):
+#             self.value = value
+#             self.filled = True
+        else:
+            self.value = Value(self.type_obj, value)
+#             formatted_value = self.type._format_value(value) 
+            if self.value is None:
+                logging.warning( 'Value can not be assigned: validation failed!')
+            else:
+                self.filled = True
+        
+#         if self.sub_pointer is not None:
+#             self.sub_pointer._assign(value)
+        
+        return True
+
+    def _direct_assign(self, value):
+        self.value = value
+        if value is not None:
+            self.filled = True
+            
+    def _update_prefix(self, prefix):
+        self.name = prefix + self.name
+        
+    def _update_parent_node(self, parent):
+        self.parent_node = parent
+
+    def _propagate_substitution_value(self):
+        if self.sub_pointer is None:
+            return True
+        if self.value is not None:
+#            self.sub_pointer._direct_assign(self.value)
+            self.sub_pointer._assign(self.value._get_value()[0])
+            
+        return True
+    
+    def _propagate_attr_substitution_value(self):
+        if self.sub_pointer is None or hasattr(self.sub_pointer, 'value') is False:
+            return True
+        self._direct_assign(self.sub_pointer.value)        
+        return True   
+     
+    def _prepare_input_type_output(self, tags):
+        out_details= {}
+        out_details[YMO_PROP_TYPE] = self.type_obj.name
+        if hasattr(self.definition, 'default') is True and self.definition.default is not None:
+            if 'w_default' in tags:
+                return {}
+            out_details[YMO_PROP_DEFAULT] = self.definition.default
+            
+        out_val = {}
+        out_val[self.name] =out_details
+        return out_val
+
+    def _prepare_output_type_output(self):
+        out_val = {}
+        val_body = self.value._get_value()[0]
+        out_val[self.name] =dict(value=val_body)
+        return out_val
+    
+    def _prepare_heat_output(self):
+        type_out = {}
+        type_out[self.name] =dict(type=self.type.name)
+        val_out = {}
+        if self.filled:
+            val_out[self.name] = self.value
+        else:
+            val_out[self.name] = None
+        
+        return type_out, val_out
+        
diff --git a/app/toscalib/templates/property_item.pyc b/app/toscalib/templates/property_item.pyc
new file mode 100644
index 0000000..96d7b86
--- /dev/null
+++ b/app/toscalib/templates/property_item.pyc
diff --git a/app/toscalib/templates/requirement_item.py b/app/toscalib/templates/requirement_item.py
new file mode 100644
index 0000000..19c9844
--- /dev/null
+++ b/app/toscalib/templates/requirement_item.py
@@ -0,0 +1,116 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+from toscalib.templates.constant import *
+from toscalib.templates.property_item import PropertyItem
+import logging
+
+class RequirementItem(object):
+    def __init__(self, definition):
+        self.name = definition.name
+        self.value = None
+        self.str_value = None
+        self.cap_match = None
+        self.filled = False
+        self.pending = False
+        
+        self.req_capability = definition.req_capability        
+        self.relationship = definition.relationship
+        self.req_type = definition.req_type
+        self.filter = None
+        self.sub_pointer = None
+        self.parent_node = None
+
+
+    def _assign(self, value):
+        if value is None:
+            logging.warning( 'Assign None to fulfill requirement')
+            return False
+        
+        for cap_item in iter(value.capabilities.values()):
+            if cap_item._validate_capability(self.req_capability) is True:
+                self.cap_match = cap_item
+                break
+        if self.cap_match is None:
+            logging.warning( 'No matching capabilities in requirement assignment')
+            return False
+        else:
+            self.value = value
+            self.str_value = value.name
+            self.filled = True
+        
+            return True
+    
+    def _propagate_substitution_value(self):
+        if self.sub_pointer is None:
+            return True
+        if self.filled is not True:
+            return True
+
+        if isinstance(self.sub_pointer, RequirementItem):
+            if self.cap_match.sub_pointer is None:
+                self.sub_pointer._assign(self.value)
+            else:
+                self.sub_pointer._assign(self.cap_match.sub_pointer.parent_node)
+        elif isinstance(self.sub_pointer, PropertyItem):
+            if self.cap_match.id.value is not None:
+                self.sub_pointer._direct_assign(self.cap_match.id.value)
+            
+        return True    
+        
+    
+    def _verify_requirement(self, node_dict):
+        if self.filled is True:
+#            if node_dict.has_key(self.str_value):
+            if self.str_value in node_dict:
+                self._assign(node_dict[self.str_value])
+            else:
+                logging.warning( 'Error! the node requires \''+ self.str_value+ '\' not defined in the template!')
+                self.str_value = None
+                self.filled = False
+        if self.pending is True:
+#            if node_dict.has_key(self.str_value):
+            if self.str_value in node_dict:
+                self._assign(node_dict[self.str_value])
+                self.pending = None
+            else:
+                self.req_type = self.str_value
+                self.str_value = None
+                self.pending = None
+                
+    def _verify_node(self, node):
+        if node._verify_req_node(self.req_type, self.req_capability, self.filter) is False:
+            logging.warning( 'requirement matching failed')
+            return False
+        
+        return True
+        
+    
+    def _update_prefix(self, prefix):
+        if self.filled is True:
+            self.str_value = prefix + self.str_value        
+            
+    def _update_parent_node(self, parent):
+        self.parent_node = parent    
+        
+    def _parse_pre_defined_content(self, content):
+        if type(content) is str:
+            self.str_value = content
+            self.filled = True
+        elif type(content) is dict:
+#            if content.has_key(REQ_NODE):
+            if REQ_NODE in content:
+                self.str_value = content[REQ_NODE]
+                self.pending = True
+#            if content.has_key(REQ_CAPABILITY):
+            if REQ_CAPABILITY in content:
+                self.req_capability = content[REQ_CAPABILITY]
+#            if content.has_key(REQ_RELATIONSHIP):
+            if REQ_RELATIONSHIP in content:
+                self.relationship = content[REQ_RELATIONSHIP]
+#            if content.has_key(REQ_FILTER):
+            if REQ_FILTER in content:
+                self.filter = content[REQ_FILTER]
+        else:
+            logging.warning( 'Can not parse requirement assignment for '+self.name)
diff --git a/app/toscalib/templates/requirement_item.pyc b/app/toscalib/templates/requirement_item.pyc
new file mode 100644
index 0000000..1cb307e
--- /dev/null
+++ b/app/toscalib/templates/requirement_item.pyc
diff --git a/app/toscalib/templates/substitution_rule.py b/app/toscalib/templates/substitution_rule.py
new file mode 100644
index 0000000..fda8e50
--- /dev/null
+++ b/app/toscalib/templates/substitution_rule.py
@@ -0,0 +1,179 @@
+from toscalib.templates.constant import *
+import logging
+
+
+class SubstitutionRule (object):
+    def __init__(self, type, item_name, prop_name, value):
+        self.type = type
+        self.item = item_name
+        self.property = prop_name
+        self.value = value
+        
+    def _update_pointer(self, src_node, dst_template):
+        if type(self.value) is not list and len(self.value) < 1:
+            logging.warning( 'Incorrect mapping rule for property '+ self.property+ ': '+ self.value)
+            return
+        
+        if self.type == SUB_PROPERTY:
+            if self.value[0] == SUB_INPUT:
+#                if hasattr(dst_template, 'inputs') and dst_template.inputs.has_key(self.value[1]):
+                if hasattr(dst_template, 'inputs') and self.value[1] in dst_template.inputs:
+                    if src_node is not None:
+                        src_node.properties[self.property].sub_pointer = dst_template.inputs[self.value[1]]
+                        if src_node.properties[self.property].required is True or src_node.properties[self.property].filled is True:
+                            dst_template.inputs[self.value[1]].used = True
+                elif src_node is not None and src_node.properties[self.property].required is True:
+                    logging.warning( 'Incorrect mapping rule for property '+ self.property+ ': no input named '+ self.value[1])
+#            elif dst_template.node_dict.has_key(self.value[0]):
+            elif self.value[0] in dst_template.node_dict:
+                target_node = dst_template.node_dict[self.value[0]]
+                target_prop_item = target_node._get_property_item(self.value[1])
+                if target_prop_item is not None: 
+                    if src_node is not None:
+                        src_prop_item = src_node._get_property_item(self.property)
+                        if src_prop_item.required is True or src_prop_item.filled is True:
+                            target_prop_item.used = True
+                        if src_prop_item is not None:
+                            src_prop_item.sub_pointer = target_prop_item
+                else:
+                    logging.warning( 'Incorrect mapping rule for property '+ self.property+ ': no property named '+ self.value[1]+ ' in node '+ self.value[0])
+            else:
+                logging.warning('Incorrect mapping rule for property '+ self.property+ ': no node named '+ self.value[0])
+        
+        elif self.type == SUB_ATTRIBUTE:
+            if self.value[0] == SUB_OUTPUT:
+#                if hasattr(dst_template, 'outputs') and dst_template.outputs.has_key(self.value[1]):
+                if hasattr(dst_template, 'outputs') and self.value[1] in dst_template.outputs:
+                    if src_node is not None:
+                        src_node.attributes[self.property].sub_pointer = dst_template.outputs[self.value[1]]
+                else: 
+                    logging.warning( 'Incorrect mapping rule for attribute '+ self.property+ ': no output named '+ self.value[1])
+        
+        elif self.type == SUB_CAPABILITY:
+            if self.property is None:
+#                if dst_template.node_dict.has_key(self.value[0]):
+                if self.value[0] in dst_template.node_dict:
+                    target_node = dst_template.node_dict[self.value[0]]
+                    target_cap_item = target_node._get_capability_item(self.value[1])
+                    if target_cap_item is not None:
+                        if src_node is not None:
+                            src_cap_item = src_node._get_capability_item(self.item)
+                            if src_cap_item is not None:
+                                src_cap_item.sub_pointer = target_cap_item
+                                for prop_name in src_cap_item.properties.keys():
+                                    src_cap_item.properties[prop_name].sub_pointer = target_cap_item.properties[prop_name]
+                    else:
+                        logging.warning( 'Incorrect mapping rule for capability '+ self.item+ ': no capability named '+ self.value[1]+ ' in node '+ self.value[0])
+                else:
+                    logging.warning( 'Incorrect mapping rule for capability '+ self.item+ ': no node named '+ self.value[0])
+            elif self.property == SUB_CAP_ID:
+                if self.value[0] == SUB_OUTPUT:
+#                    if hasattr(dst_template, 'outputs') and dst_template.outputs.has_key(self.value[1]):
+                    if hasattr(dst_template, 'outputs') and self.value[1] in dst_template.outputs:
+                        target_node = dst_template.outputs[self.value[1]]
+                        if src_node is not None:
+                            src_cap_item = src_node._get_capability_item(self.item)
+                            if src_cap_item is not None:
+                                src_cap_item.sub_pointer = target_node
+#                elif dst_template.node_dict.has_key(self.value[0]):
+                elif self.value[0] in dst_template.node_dict:
+                    target_node = dst_template.node_dict[self.value[0]]
+                    if len(self.value) < 2:
+                        target_item = target_node
+#                    elif target_node.capabilities.has_key(self.value[1]) and len(self.value) > 1:
+                    elif len(self.value) > 1 and self.value[1] in target_node.capabilities :
+                        target_item = target_node._get_capability_property(self.value[1], self.value[2])
+                    elif self.value[1] in target_node.properties:
+                        target_item = target_node._get_property_item(self.value[1])
+                    else:
+                        target_item = None
+                        logging.warning( 'Incorrect mapping rule for capability '+ self.item+ ': no capability/property named '+ self.value[1]+ ' in node '+ self.value[0])
+
+                    if target_item is not None and src_node is not None:
+                        src_cap_item = src_node._get_capability_item(self.item)
+                        if src_cap_item is not None:
+                            src_cap_item.sub_pointer = target_item
+            else:
+                if self.value[0] == SUB_INPUT:
+#                    if hasattr(dst_template, 'inputs') and dst_template.inputs.has_key(self.value[1]):
+                    if hasattr(dst_template, 'inputs') and self.value[1] in dst_template.inputs:
+                        if src_node is not None:
+                            src_cap_prop_item = src_node._get_capability_property(self.item, self.property)
+                            src_cap_prop_item.sub_pointer = dst_template.inputs[self.value[1]]
+                            if src_cap_prop_item.required is True or src_cap_prop_item.filled is True:
+                                dst_template.inputs[self.value[1]].used = True
+                    else:
+                        logging.warning( 'Incorrect mapping rule for capability '+ self.item+ ': no input named '+ self.value[1])
+#                elif dst_template.node_dict.has_key(self.value[0]):
+                elif self.value[0] in dst_template.node_dict:
+                    target_node = dst_template.node_dict[self.value[0]]
+
+#                    if target_node.capabilities.has_key(self.value[1]):
+                    if self.value[1] in target_node.capabilities:
+                        target_cap_property = target_node._get_capability_property(self.value[1], self.value[2])
+                        if target_cap_property is not None:
+                            if src_node is not None:
+                                src_cap_prop_item = src_node._get_capability_property(self.item, self.property)
+                                if src_cap_prop_item is not None:
+                                    src_cap_prop_item.sub_pointer = target_cap_property
+                        else:
+                            logging.warning( 'Incorrect mapping rule for capability '+ self.item+ ': no property named '+ self.value[2]+ ' in capability '+ self.value[0]+ '->'+ self.value[1])
+#                    elif target_node.properties.has_key(self.value[1]):
+                    elif self.value[1] in target_node.properties:
+                        target_prop_item = target_node._get_property_item(self.value[1])
+                        if src_node is not None:
+                            src_cap_prop_item = src_node._get_capability_property(self.item, self.property)
+                            if src_cap_prop_item is not None:
+                                src_cap_prop_item.sub_pointer = target_prop_item
+                    else:
+                        logging.warning( 'Incorrect mapping rule for capability '+ self.item+ ': no capability/property named '+ self.value[1]+ ' in node '+ self.value[0])
+                else:
+                    logging.warning( 'Incorrect mapping rule for capability '+ self.item+ ': no node named '+ self.value[0])
+        
+        elif self.type == SUB_REQUIREMENT:
+            if self.property is None:
+#                if dst_template.node_dict.has_key(self.value[0]):
+                if self.value[0] in dst_template.node_dict:
+                    target_node = dst_template.node_dict[self.value[0]]
+                    target_req_item = target_node._get_requirement_item_first(self.value[1])
+                    if target_req_item is not None:
+                        if src_node is not None:
+                            src_req_item = src_node._get_requirement_item_first(self.item)
+                            if src_req_item is not None:
+                                src_req_item.sub_pointer = target_req_item
+                    else:
+                        logging.warning( 'Incorrect mapping rule for requirement '+ self.item+ ': no requirement named '+ self.value[1]+ ' in node '+ self.value[0])
+                else:
+                    logging.warning( 'Incorrect mapping rule for requirement '+ self.item+ ': no node named '+ self.value[0])
+            elif self.property == SUB_REQ_ID:
+                if self.value[0] == SUB_INPUT:
+#                    if hasattr(dst_template, 'inputs') and dst_template.inputs.has_key(self.value[1]):
+                    if hasattr(dst_template, 'inputs') and self.value[1] in dst_template.inputs:
+                        if src_node is not None:
+                            src_req_item = src_node._get_requirement_item_first(self.item)
+                            if src_req_item is not None:
+                                src_req_item.sub_pointer = dst_template.inputs[self.value[1]]
+                                dst_template.inputs[self.value[1]].used = True
+                    else:
+                        logging.warning( 'Incorrect mapping rule for property '+ self.property+ ': no input named '+ self.value[1])
+
+#                elif dst_template.node_dict.has_key(self.value[0]):
+                elif self.value[0] in dst_template.node_dict:
+                    target_node = dst_template.node_dict[self.value[0]]
+                    target_prop_item = target_node._get_property_item(self.value[1])
+                    if target_prop_item is not None:
+                        if src_node is not None:
+                            src_req_item = src_node._get_requirement_item_first(self.item)
+                            if src_req_item is not None:
+                                src_req_item.sub_pointer = target_prop_item
+                    else:
+                        logging.warning( 'Incorrect mapping rule for requirement '+ self.item+ ': no property named '+ self.value[1]+ ' in node '+ self.value[0])
+                else:
+                    logging.warning( 'Incorrect mapping rule for requirement '+ self.item+ ': no node named '+ self.value[0])
+            else:
+                logging.warning( 'Incorrect mapping rule for requirement '+ self.item+ ': wrong property name '+ self.property)
+                
+        else:
+            logging.warning('Incorrect mapping rule type: '+ self.type)
+                
+        
diff --git a/app/toscalib/templates/substitution_rule.pyc b/app/toscalib/templates/substitution_rule.pyc
new file mode 100644
index 0000000..0d4ad19
--- /dev/null
+++ b/app/toscalib/templates/substitution_rule.pyc
diff --git a/app/toscalib/templates/topology.py b/app/toscalib/templates/topology.py
new file mode 100644
index 0000000..f8c00ed
--- /dev/null
+++ b/app/toscalib/templates/topology.py
@@ -0,0 +1,419 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+from toscalib.templates.constant import *
+from toscalib.templates.heat_constants import *
+from toscalib.templates.substitution_rule import SubstitutionRule
+from toscalib.types.property import PropertyDefinition
+from toscalib.templates.property_item import PropertyItem
+from toscalib.templates.heat_constants import HOT_VERSION_NUM
+import copy, logging
+
+class ToscaTopology(object):
+    def __init__(self, name, metadata_section=None, content_section=None):
+        self.name = name
+        self.metadata = metadata_section
+        self.raw_content = content_section
+        self.db  = None
+
+        self.node_dict = {}
+        self.inputs = {}
+        self.aux_inputs = {}
+        self.outputs = {}
+        self.sub_rules = []
+
+        self.node_index = 0
+        self.temp_index = 0
+        
+        self.extra_imports = []
+        
+    def _parse_content(self, db):
+        if self.db is not None:
+            return
+        
+        self.db = db
+        
+        if self.raw_content is None:
+            return
+        
+#        if self.raw_content.has_key(TOPO_INPUTS):
+        if TOPO_INPUTS in self.raw_content:
+            self._parse_input(db, self.raw_content[TOPO_INPUTS])
+        
+#        if self.raw_content.has_key(TOPO_NODE_TEMPLATES):
+        if TOPO_NODE_TEMPLATES in self.raw_content:
+            self._parse_node_template(db, self.raw_content[TOPO_NODE_TEMPLATES])
+        else:
+            logging.warning( 'Topology template: ' + self.name+ ' has NO node templates!')
+        
+#        if self.raw_content.has_key(TOPO_OUTPUTS):
+        if TOPO_OUTPUTS in self.raw_content:
+            self._parse_output(db, self.raw_content[TOPO_OUTPUTS])
+            
+#        if self.raw_content.has_key(TOPO_SUBSTITUION_MAPPINGS):
+        if TOPO_SUBSTITUION_MAPPINGS in self.raw_content:
+            self._parse_substitution(db, self.raw_content[TOPO_SUBSTITUION_MAPPINGS])
+        else:
+            self.sub_type = None        
+        self._verify_substitution() 
+        self._update_function_pointer()   
+        
+    def _parse_substitution(self, db, sub_sec):
+#        if sub_sec.has_key(SUB_NODE_TYPE):
+        if SUB_NODE_TYPE in sub_sec:
+            self.sub_type = sub_sec[SUB_NODE_TYPE]
+#            if db.NODE_TYPES.has_key(self.sub_type):
+            if self.sub_type in db.NODE_TYPES:
+                db.NODE_TYPES[self.sub_type].mapping_template = self
+        else:
+            logging.warning( 'substitution mapping section does not have node_type defined')
+            return  
+                 
+#        if sub_sec.has_key(SUB_PROPERTY):
+#            sub_prop = sub_sec[SUB_PROPERTY]
+#            for sub_prop_name in sub_prop.keys():
+#                self.sub_rules.append(SubstitutionRule(SUB_PROPERTY, None, sub_prop_name, sub_prop[sub_prop_name]))
+ 
+        for sub_prop in db.NODE_TYPES[self.sub_type].properties.keys():
+#            if self.inputs.has_key(sub_prop):
+            if sub_prop in self.inputs:
+                self.sub_rules.append(SubstitutionRule(SUB_PROPERTY, None, sub_prop, [SUB_INPUT, sub_prop]))
+
+        for sub_attr in db.NODE_TYPES[self.sub_type].attributes.keys():
+#            if self.outputs.has_key(sub_attr):
+            if sub_attr in self.outputs:
+                self.sub_rules.append(SubstitutionRule(SUB_ATTRIBUTE, None, sub_attr, [SUB_OUTPUT, sub_attr]))
+                   
+#        if sub_sec.has_key(SUB_CAPABILITY):
+        if SUB_CAPABILITY in sub_sec:
+            sub_cap = sub_sec[SUB_CAPABILITY]
+            for sub_cap_name in sub_cap.keys():
+                sub_cap_item = sub_cap[sub_cap_name]
+                #standard capability mapping rule
+                if type(sub_cap_item) is not dict: 
+                    self.sub_rules.append(SubstitutionRule(SUB_CAPABILITY, sub_cap_name, None, sub_cap_item))
+                #self-proposed capability mapping rules 
+                else: 
+#                    if sub_cap_item.has_key(SUB_CAP_ID):
+                    if SUB_CAP_ID in sub_cap_item:
+                        self.sub_rules.append(SubstitutionRule(SUB_CAPABILITY, sub_cap_name, SUB_CAP_ID, sub_cap_item[SUB_CAP_ID]))
+#                    if sub_cap_item.has_key(SUB_CAP_PROPERTY):
+                    if SUB_CAP_PROPERTY in sub_cap_item:
+                        sub_cap_item_prop = sub_cap_item[SUB_CAP_PROPERTY] 
+                        for sub_cap_item_prop_name in sub_cap_item_prop.keys():
+                            self.sub_rules.append(SubstitutionRule(SUB_CAPABILITY, sub_cap_name, sub_cap_item_prop_name, sub_cap_item_prop[sub_cap_item_prop_name]))
+        
+#        if sub_sec.has_key(SUB_REQUIREMENT):
+        if SUB_REQUIREMENT in sub_sec:
+            sub_req = sub_sec[SUB_REQUIREMENT]
+            for sub_req_name in sub_req.keys():
+                sub_req_item = sub_req[sub_req_name]
+            #standard requirement mapping rule
+                if type(sub_req_item) is not dict: 
+                    self.sub_rules.append(SubstitutionRule(SUB_REQUIREMENT, sub_req_name, None, sub_req_item))
+            #self-proposed requirement mapping rules 
+                else: 
+#                    if sub_req_item.has_key(SUB_REQ_ID):   
+                    if SUB_REQ_ID in sub_req_item:   
+                        self.sub_rules.append(SubstitutionRule(SUB_REQUIREMENT, sub_req_name, SUB_REQ_ID, sub_req_item[SUB_REQ_ID]))
+                    else:
+                        logging.warning( 'Incorrect substitution mapping rules')
+    
+    def _verify_substitution(self, target_node=None):
+        for rule in self.sub_rules:
+            rule._update_pointer(target_node, self)       
+    
+    def _parse_input(self, db, input_sec):
+        for input_name in input_sec.keys():
+            input_def = PropertyDefinition(input_name, input_sec[input_name])
+            input_def._parse_content(db)
+            self.inputs[input_name] = PropertyItem(input_def)
+
+    def _parse_output(self, db, output_sec):
+        for output_name in output_sec.keys():
+            output_def = PropertyDefinition(output_name)
+#            output_def._parse_content(db)
+            self.outputs[output_name] = PropertyItem(output_def)
+#            if output_sec[output_name].has_key('value'):
+            if 'value' in output_sec[output_name]:
+                self.outputs[output_name]._assign(output_sec[output_name]['value'])
+              
+    def _parse_node_template(self, db, template_sec):
+        self.node_dict = {}
+        for name in template_sec.keys():
+#            if template_sec[name].has_key(NOD_TYPE):
+            if NOD_TYPE in template_sec[name]:
+                node_type_name = template_sec[name][NOD_TYPE]
+            else:
+                logging.warning( 'Invalid template: node section has no type')
+                continue
+            
+#            if db.NODE_TYPES.has_key(node_type_name) is False:
+            if node_type_name not in db.NODE_TYPES:
+                logging.warning( 'Invalid template: node type: '+ str(node_type_name)+ ' not defined or imported')
+                continue
+                
+            from toscalib.templates.node import Node
+            new_node = Node(self, name, db.NODE_TYPES[node_type_name])
+            new_node._parse_pre_defined_content(template_sec[name])
+
+            self._add_node(new_node)
+        
+        for node in iter(self.node_dict.values()):
+            node._verify_requirements(self.node_dict)
+            node._verify_functions()
+
+            
+        self.edge_list = self._create_edges()
+        
+    def _create_edges(self):
+        edges = []
+        for node in iter(self.node_dict.values()):
+            for req in node.requirements:
+                if req.filled is True:
+                    new_edge = (node, self.node_dict[req.str_value])
+                    logging.debug( 'edge created: '+ new_edge[0].name+ ' --> '+ new_edge[1].name)
+                    edges.append(new_edge)
+        return edges
+
+    def _update_function_pointer(self):   
+        for node in iter(self.node_dict.values()):
+            #node._verify_requirements(self.node_dict)
+            node._verify_functions()
+        for output in iter(self.outputs.values()):
+            if output.value is not None:
+                output.value._update_function_reference(self)
+
+    def _update_translation_function_pointer(self):
+        for node in iter(self.node_dict.values()):
+            if node.tran_template is not None:
+                node.tran_template._update_function_pointer()
+    
+    def _update_prefix(self, prefix):
+        exist_key_list = list(self.node_dict.keys())
+        for node_key in exist_key_list:
+            if node_key == 'NO_PREFIX':
+                new_node_key = prefix[:len(prefix)-1]
+            else:
+                new_node_key = prefix + node_key
+            node = self.node_dict.pop(node_key)
+            node._update_prefix(prefix)
+            self.node_dict[new_node_key] = node
+            
+        exist_key_list = list(self.inputs.keys())
+        for item_key in exist_key_list:
+            new_item_key = prefix + item_key
+            item = self.inputs.pop(item_key)
+            item._update_prefix(prefix)
+            self.inputs[new_item_key] = item
+            
+        exist_key_list = list(self.outputs.keys())
+        for item_key in exist_key_list:
+            ###don't update output name prefix here
+            ###temporary solution for cloudify generation
+            ###but still need to update pointer for the value
+            new_item_key = prefix + item_key
+            #item = self.outputs.pop(item_key)
+            #item._update_prefix(prefix)
+            item = self.outputs[item_key]
+            item.value._update_prefix(prefix)   
+            item.value._update_function_reference(self)
+            #self.outputs[new_item_key] = item
+        
+        #self._update_function_pointer()
+
+            
+    def _update_used_tag_for_translation(self):
+        for item in iter(self.inputs.values()):
+            item.used = False
+        for node_item in iter(self.node_dict.values()):
+            for prop_item in iter(node_item.properties.values()):
+                prop_item.used = False
+            
+    def _add_node(self, new_node):
+        if new_node is None:
+            return
+        self.node_dict[new_node.name] = new_node
+        
+    def _propagate_substitution_value(self):
+        converge = False
+        while converge is not True:
+            converge = True
+            for node_item in iter(self.node_dict.values()):
+                converge = converge and node_item._propagate_substitution_value() 
+            
+     
+    def _auto_generate_aux_inputs(self):
+        for node_name in self.node_dict.keys():
+            node = self.node_dict[node_name]
+            for prop_name in  node.properties.keys():
+                prop_item = node.properties[prop_name]
+                if prop_item.value is None or prop_item.filled is False:
+                    new_input_name = node_name + '_' + prop_name
+#                    while self.inputs.has_key(new_input_name) or self.aux_inputs.has_key(new_input_name):
+                    while new_input_name in self.inputs or new_input_name in self.aux_inputs:
+                        new_input_name = new_input_name + '_'
+                    def_item = copy.deepcopy(prop_item.definition)
+                    def_item.name = new_input_name
+                    self.aux_inputs[new_input_name] = PropertyItem(def_item)
+                    fun_item = {}
+                    fun_item['get_input'] = new_input_name
+                    prop_item._assign(fun_item)
+                    prop_item.value._update_function_reference(self)
+                
+    def _prepare_node_types(self):
+        for node_type in iter(self.db.NODE_TYPES.values()):
+            node_type.used = False
+            
+        for node in iter(self.node_dict.values()):
+            node_type = node.type_obj
+            while node_type is not None:
+                self.db.NODE_TYPES[node_type.name].used = True
+                node_type = node_type.parent
+    
+    def _prepare_node_types_output(self, tags=''):
+        self._prepare_node_types()
+        node_type = {}
+        if 'noexpand' not in tags:
+            for node in iter(self.node_dict.values()):
+                if node.tran_template is not None: 
+                    node_type.update(node.tran_template._prepare_node_types_output(tags))
+        if len(node_type) < 1:
+            for ntype in iter(self.db.NODE_TYPES.values()):
+                if ntype.used is False:
+                    continue
+                type_content = copy.deepcopy(ntype.raw_content)
+                if 'cloudify' in tags:
+                    if ntype.name == 'cloudify.nodes.Root':
+                        continue
+                    
+                    type_content.pop('capabilities', None)
+                    type_content.pop('requirements', None)
+                    type_content.pop('attributes', None)
+                else: 
+                    if ntype.name == 'tosca.nodes.Root':
+                        continue
+
+                node_type[ntype.name] = type_content
+                
+        return node_type
+            
+    def _prepare_extra_imports(self, tags):
+        if 'cloudify' in tags:
+            ret_val = []
+            for item in self.extra_imports:
+                ret_val += list(item.values())
+            return ret_val
+        else:
+            return self.extra_imports
+           
+    def _prepare_output(self, tags=''):
+
+        output ={} 
+        import_sec = []
+        
+        if 'cloudify' in tags:
+            output[YMO_VERSION]= 'cloudify_dsl_1_3'
+            for item in self.extra_imports:
+                import_sec += list(item.values()) 
+            #import_sec.append('http://www.getcloudify.org/spec/cloudify/3.4/types.yaml')
+        else:
+            import_sec += self.extra_imports 
+            output[YMO_VERSION]= 'tosca_simple_yaml_1_0_0'
+        
+        if 'import_schema' in tags: 
+            output[YMO_IMPORT] = [{'schema': 'schema.yaml'}]
+            
+        if self.metadata is not None and 'java_sim' not in tags:
+            output[YMO_METADATA] = self.metadata
+        topo_sec = {}
+        node_temp = {}
+        for node in iter(self.node_dict.values()):
+            node_temp.update(node._prepare_output(tags))
+            import_sec += node._prepare_extra_imports(tags)
+            
+        if 'part' in tags: 
+            return node_temp
+        
+        if len(node_temp.keys())> 0:
+            topo_sec[YMO_TOPO_NODE_TEMPLATES] = node_temp
+       
+        input_sec = {}
+        for name in self.inputs.keys():
+            input_sec.update(self.inputs[name]._prepare_input_type_output(tags))
+        for name in self.aux_inputs.keys():
+            input_sec.update(self.aux_inputs[name]._prepare_input_type_output(tags))
+        if (len(input_sec.keys())> 0) and 'java_sim' not in tags:
+            topo_sec[YMO_TOPO_INPUTS] = input_sec
+        output_sec = {}
+        for name in self.outputs.keys():
+            output_sec.update(self.outputs[name]._prepare_output_type_output())
+        if (len(output_sec.keys())> 0) and 'java_sim' not in tags:
+            topo_sec[YMO_TOPO_OUTPUTS] = output_sec
+            
+            
+        if 'w_sub' in tags and self.sub_type is not None:
+            sub_sec = {}
+            sub_sec[YMO_SUB_NODE_TYPE] = self.sub_type
+            sub_cap = {}
+            sub_req = {}
+            for sub_rule in self.sub_rules:
+                if sub_rule.type is SUB_CAPABILITY:
+                    sub_cap[sub_rule.item] = sub_rule.value
+                if sub_rule.type is SUB_REQUIREMENT:
+                    sub_req[sub_rule.item] = sub_rule.value
+            sub_sec[YMO_SUB_CAPABILITY] = sub_cap
+            sub_sec[YMO_SUB_REQUIREMENT] = sub_req
+            
+            topo_sec[YMO_TOPO_SUBSTITUION_MAPPINGS] = sub_sec 
+    
+        if 'cloudify' in tags:
+            output.update(topo_sec)
+        else:
+            output[YMO_TOPOLOGY] = topo_sec
+        
+        if 'nodetype' in tags and 'java_sim' not in tags:
+            output[YMO_NODE_TYPE] = self._prepare_node_types_output(tags)
+        
+        if len(import_sec) > 0:
+            output[YMO_IMPORT] = import_sec
+
+        
+        return output
+        
+        
+    def _prepare_heat_output(self, parameters_type = {}, parameters_val = {}, stripped = False):
+        output = {}
+        env_output = {}
+        output[YMO_HOT_VERSION] = HOT_VERSION_NUM  
+
+        for input_item in iter(self.inputs.values()):
+            out1, out2 = input_item._prepare_heat_output()
+            parameters_type.update(out1)
+            parameters_val.update(out2)
+        resources = {}
+        for node in iter(self.node_dict.values()):
+            resources.udpate(node._prepare_heat_output(parameters_type, parameters_val))
+            
+        output[YMO_HOT_PARAMETERS] = parameters_type
+        output[YMO_HOT_RESOURCES]  = resources
+        env_output[YMO_HOT_PARAMETERS] = parameters_val
+        
+        if stripped is True: 
+            return resources
+        else:
+            return output, env_output
+        
+        
+    def toJson(self):
+        ret_json = {}
+        tmp_json = {}
+        for node in iter(self.node_dict.values()):
+            tmp_json[node.name] = node.toJson()
+        ret_json['nodes'] = tmp_json
+        ret_json['relations'] = {}
+        ret_json['inputs'] = {}
+        ret_json['outputs'] = {}
+        return ret_json
+          
+\ No newline at end of file
diff --git a/app/toscalib/templates/topology.pyc b/app/toscalib/templates/topology.pyc
new file mode 100644
index 0000000..3b03399
--- /dev/null
+++ b/app/toscalib/templates/topology.pyc
diff --git a/app/toscalib/templates/value.py b/app/toscalib/templates/value.py
new file mode 100644
index 0000000..fee0ceb
--- /dev/null
+++ b/app/toscalib/templates/value.py
@@ -0,0 +1,266 @@
+from toscalib.types.data import TYP_LIST, TYP_MAP, TYP_STR, DataType
+from toscalib.templates.property_item import PropertyItem
+import copy, logging
+
+FUNCTIONS = (GET_INPUT, GET_PROPERTY, GET_ATTRIBUTE, GET_OPERATION, GET_NODES, GET_ARTIFACT, CONCAT) = \
+            ('get_input', 'get_property', 'get_attribute', 'get_operation_output', 'get_nodes_of_type', 'get_artifact', 'concat')
+            
+VALUE_STATE = (VALID_VALUE, FUNCTION, NULL) = \
+            (1, 2, 3)
+
+def _is_function(value):
+    if type(value) is not dict:
+        return None
+    if len(value.keys()) != 1:
+        return None
+    key = list(value.keys())[0]
+    if key not in FUNCTIONS:
+        return None
+    
+    if key == GET_INPUT:
+        out_value = FunctionValue(key)
+        out_value.target_property = value[key]
+        return out_value
+    elif key == CONCAT:
+        out_value = FunctionValue(key)
+        value_list = value[key]
+        if type(value_list) is not list:
+            return None
+        out_value.extra_data = []
+        for value_item in value_list:
+            out_value.extra_data.append(Value(DataType(TYP_STR), value_item))
+        return out_value
+    else:
+        out_value = FunctionValue(key)
+        value_list = value[key]
+        if type(value_list) is not list:
+            return None        
+        out_value.extra_data = value_list
+                
+        return out_value
+    
+        
+class FunctionValue(object):
+    def __init__(self, func_type):
+        self.type = func_type
+        self.target_property = None
+        self.extra_data = []
+        self.value_from_node = None
+        self.value_from_item = None
+        self.result = None
+        
+    def _update_prefix(self, prefix):
+        if self.type == GET_INPUT:
+            self.target_property = prefix + self.target_property
+        elif (self.type == GET_PROPERTY or self.type == GET_ATTRIBUTE):
+            if self.extra_data is not None and len(self.extra_data) > 1 and self.extra_data[0] != 'SELF':
+                if self.extra_data[0] == 'NO_PREFIX':
+                    self.extra_data[0] = prefix[:len(prefix)-1]
+                else:
+                    self.extra_data[0] = prefix + self.extra_data[0]
+        elif self.type == CONCAT:
+            for item in self.extra_data:
+                if item.function is not None: 
+                    item._update_prefix(prefix)
+                
+    def _update_function_reference(self, temp, self_node = None, self_item = None):
+        if self.type == GET_INPUT:
+#            if temp.inputs.has_key(self.target_property):
+            if self.target_property in temp.inputs:
+                self.value_from_item = temp.inputs[self.target_property]
+                return
+#            elif temp.aux_inputs.has_key(self.target_property):
+            elif self.target_property in temp.aux_inputs:
+                self.value_from_item = temp.aux_inputs[self.target_property]
+                return
+            else: 
+                logging.debug( 'get_input function points to a non-existent input, autofill'+ self.target_property)
+                def_item = copy.deepcopy(self_item.definition)
+                def_item.name = self.target_property
+                temp.inputs[self.target_property] = PropertyItem(def_item)
+                self.value_from_item = temp.inputs[self.target_property]
+                return 
+        elif self.type == GET_PROPERTY:
+            if self.extra_data is None or len(self.extra_data) < 2:
+                logging.warning('Error, get_property has not enough parameters '+ self.extra_data)
+                return 
+#            if self.extra_data[0] != 'SELF' and temp.node_dict.has_key(self.extra_data[0]) is False:
+            if self.extra_data[0] != 'SELF' and self.extra_data[0] not in temp.node_dict:
+                logging.warning( 'Error, get_property from unrecognized node '+ self.extra_data[0])
+                return 
+            
+            if self.extra_data[0] == 'SELF':
+                node_item = self_node
+            else:
+                node_item = temp.node_dict[self.extra_data[0]]
+            self.value_from_node = node_item
+            
+            if len(self.extra_data) == 2:
+                self.value_from_item = node_item._get_property_item(self.extra_data[1])
+                return
+            elif len(self.extra_data) == 3: 
+                self.value_from_item = node_item._get_capability_property(self.extra_data[1], self.extra_data[2])
+                if self.value_from_item is not None:
+                    return
+                req_item = node_item._get_requirement_item_first(self.extra_data[1])
+                if req_item is None:
+                    return
+                new_node_item = req_item.value
+                if new_node_item is None:
+                    self.value_from_node = None
+                    return
+                self.value_from_node = new_node_item
+#                if req_item.cap_match.properties.has_key(self.extra_data[2]):
+                if self.extra_data[2] in req_item.cap_match.properties:
+                    self.value_from_item = req_item.cap_match.properties[self.extra_data[2]]
+                else:
+                    self.value_from_item = new_node_item._get_property_item(self.extra_data[2])
+                 
+            else:
+                logging.warning( 'Too many parameters for get_property function '+ self.extra_data)
+        elif self.type == GET_ATTRIBUTE:
+            if self.extra_data is None or len(self.extra_data) < 2:
+                logging.error( 'Error, get_attribute has not enough parameters '+ self.extra_data)
+                return 
+#            if self.extra_data[0] != 'SELF' and temp.node_dict.has_key(self.extra_data[0]) is False:
+            if self.extra_data[0] != 'SELF' and self.extra_data[0]  not in temp.node_dict:
+                logging.error( 'Error, get_attribute from unrecognized node '+ self.extra_data[0])
+                return 
+            
+            if self.extra_data[0] == 'SELF':
+                node_item = self_node
+            else:
+                node_item = temp.node_dict[self.extra_data[0]]
+            
+            self.value_from_node = node_item            
+            
+            if len(self.extra_data) > 3:
+                logging.warning( 'Too many parameters for get_attribute function '+ self.extra_data)
+                return
+            if self.extra_data[1] == 'id':
+                self.value_from_item = node_item.id
+            else:
+                self.value_from_item = node_item._get_attribute_item(self.extra_data[1])
+            
+            if self.value_from_item is not None:
+                return
+            req_item = node_item._get_requirement_item_first(self.extra_data[1])
+            if req_item is None:
+                return
+            new_node_item = req_item.value
+            if new_node_item is None:
+                self.value_from_node = None
+                return
+            self.value_from_node = new_node_item
+            self.value_from_item = new_node_item._get_attribute_item(self.extra_data[2]) 
+            return
+        
+        elif self.type == CONCAT:
+            for item in self.extra_data:
+                if item.function is not None: 
+                    item._update_function_reference(temp, self_node)
+        else:
+            logging.warning( 'Function '+ self.type+ ' is not supported')
+            return
+        
+    def _calculate_function_result(self, tags= '' ):
+        if 'func' in tags:
+            return self._get_function_representation(tags), FUNCTION
+        
+        if self.type == CONCAT:
+            function_ret = VALID_VALUE
+            function_str = ""
+            for item in self.extra_data:
+                item_str, item_value = item._get_value(tags)
+                if item_value is FUNCTION:
+                    function_ret = FUNCTION
+                    break
+                elif item_str is not None:
+                    function_str = function_str + item_str
+            if function_ret == FUNCTION:
+                return self._get_function_representation(tags), FUNCTION
+            else:
+                return function_str, function_ret
+        
+        if 'w_default' in tags and self.type == GET_INPUT and self.value_from_item is not None and hasattr(self.value_from_item.definition, 'default') is True and self.value_from_item.definition.default is not None:
+            return self.value_from_item.definition.default, VALID_VALUE
+            
+        if self.value_from_item is None or self.value_from_item.value is None or self.value_from_item.value.function == self:
+            return self._get_function_representation(tags), FUNCTION
+        else:
+            return self.value_from_item.value._get_value(tags)
+        
+    def _get_value(self, tags = ''):
+        return self._calculate_function_result(tags)
+        
+    def _get_function_representation(self, tags=''):
+        if self.type == GET_INPUT:
+            out_str = {}
+            out_str[self.type]= self.target_property
+        elif self.type == GET_PROPERTY:
+            out_str = {}
+            if self.value_from_node is  None or 'rawfunc' in tags:
+                out_val = copy.deepcopy(self.extra_data)
+            else:
+                out_val = []
+                out_val.append(self.value_from_node.name)
+                out_val.append(self.extra_data[len(self.extra_data)-1])
+               
+            out_str[self.type] = out_val
+        elif self.type == GET_ATTRIBUTE:
+            out_str = {}
+            if self.value_from_node is None or 'rawfunc' in tags:
+                out_val = copy.deepcopy(self.extra_data)              
+            else:
+                out_val = []
+                out_val.append(self.value_from_node.name)
+                out_val.append(self.extra_data[len(self.extra_data)-1])
+            if self.extra_data[1] == 'id' and 'heat' in tags:
+                out_str['get_id'] = out_val[0]
+            else:
+                out_str[self.type] = out_val
+        elif self.type == CONCAT:
+            out_str = {}
+            out_list = []
+            for item in self.extra_data:
+                item_str, item_value = item._get_value(tags)
+                out_list.append(item_str)
+            out_str[self.type] = out_list
+        else:
+            out_str = {}
+            out_str[self.type]=  copy.deepcopy(self.extra_data)
+        return out_str
+    
+    def _get_function_result(self):
+        return self.result
+        
+class Value(object):
+    def __init__(self, prop_type, value):
+        self.type = prop_type.name
+        self.type_obj = copy.deepcopy(prop_type)
+        self.raw_value = value
+        self.value = None
+        self.function = _is_function(value)
+        
+        if self.function is None:
+            self.value = self.type_obj._format_value(value)
+    
+    def _update_function_reference(self, temp, self_node = None, self_item = None):
+        if self.value is not None:
+            self.type_obj._update_function_reference(temp, self.value, self_node, self_item)
+        if self.function is not None:
+            self.function._update_function_reference(temp, self_node, self_item)
+            
+    def _update_prefix(self, prefix):
+        if self.value is not None:
+            self.type_obj._update_prefix(prefix, self.value)
+        if self.function is not None: 
+            self.function._update_prefix(prefix)
+    
+    def _get_value(self, tags = ''):
+        if self.function is not None:
+            return self.function._get_value(tags)
+        if self.value is not None:
+            return self.type_obj._get_value(self.value, tags)
+        
+        
+\ No newline at end of file
diff --git a/app/toscalib/templates/value.pyc b/app/toscalib/templates/value.pyc
new file mode 100644
index 0000000..00f27d7
--- /dev/null
+++ b/app/toscalib/templates/value.pyc
diff --git a/app/toscalib/tosca_builder.py b/app/toscalib/tosca_builder.py
new file mode 100644
index 0000000..e6fb28e
--- /dev/null
+++ b/app/toscalib/tosca_builder.py
@@ -0,0 +1,1071 @@
+from toscalib.templates.database import ToscaDB
+from toscalib.utils import tosca_import, tosca_export, tosca_operate
+from toscalib.types.node import NodeType
+
+import copy
+import json
+import yaml
+import uuid
+import logging
+from toscalib.types.property import PropertyDefinition
+from toscalib.types.capability import CapabilityDefinition
+from toscalib.types.requirement import RequirementDefinition
+from toscalib.types.data import DataType, TYP_INT, TYP_STR, TYP_ANY, TYP_MAP, TYP_FLT, TYP_LIST
+from toscalib.templates import topology
+from toscalib.templates.topology import ToscaTopology
+from toscalib.tosca_workbook import DEFAULT_TEMPLATE_NAME
+from distutils.ccompiler import new_compiler
+from toscalib.templates.property_item import PropertyItem
+from toscalib.templates.substitution_rule import SubstitutionRule
+from toscalib.templates.constant import *
+from array import array
+
+
+
+class SpecImporter(object):
+    def __init__(self, ):
+        self.name = None
+        self.type = None
+        self.image = None
+        
+        self.streams_subscribes = []
+        self.streams_publishes = []
+        self.service_calls = []
+        self.service_provides = []
+        
+        self.parameters = []
+        self.aux_para = {}
+        self.policy_para = {}
+    
+    def _add_parameters(self, para_array, tag):
+        for entry in para_array:
+            if type(entry) is dict:
+                entry['tag'] = tag
+                self.parameters.append(entry)
+#                if entry.has_key('policy_editable') and entry['policy_editable'] is True:
+                if 'policy_editable' in entry and entry['policy_editable'] is True:
+#                    if entry.has_key('policy_group'):
+                    if 'policy_group'  in entry:
+                        policy_group = entry['policy_group']
+                    else:
+                        policy_group = 'default_group'
+#                    if self.policy_para.has_key(policy_group) is False:
+                    if policy_group not in self.policy_para:
+                        self.policy_para[policy_group] = []
+                    self.policy_para[policy_group].append(entry)
+                
+
+    def _add_string_para(self, para_name, para_value, tag):
+        entry = {}
+        entry['name'] = para_name
+        entry['value'] = para_value
+        entry['type'] = 'string'
+        entry['tag'] = tag
+        self.parameters.append(entry)                
+                
+    def _import(self, spec_name, aux_name = None):
+        with open(spec_name, 'r') as data_file:
+            data = json.load(data_file)
+            self._import_spec_str(data)
+            
+        if aux_name is None:
+            return
+        
+        with open(aux_name) as data_file:
+            data = json.load(data_file)
+            self._import_aux_str(data)
+            
+    def _import_spec_str(self, data):
+
+#        if data.has_key('self'):
+        if 'self' in data:
+            data_sec = data['self']
+#            if data_sec.has_key('name'):
+            if 'name' in data_sec:
+                self.name = data_sec['name']
+#            if data_sec.has_key('component_type'):
+            if 'component_type' in data_sec:
+                self.type = data_sec['component_type']
+        
+        for key in data.keys():
+            if key == 'self':
+                continue
+            elif key == 'streams':
+                data_sec = data[key]
+#                if data_sec.has_key('subscribes'):
+                if 'subscribes' in data_sec:
+                    self.streams_subscribes = data_sec['subscribes']
+#                if data_sec.has_key('publishes'):
+                if 'publishes' in data_sec:
+                    self.streams_publishes = data_sec['publishes']
+            elif key == 'services':
+                data_sec = data[key]
+#                if data_sec.has_key('calls'):
+                if 'calls' in data_sec:
+                    self.service_calls = data_sec['calls']
+#                if data_sec.has_key('provides'):
+                if 'provides' in data_sec:
+                    self.service_provides = data_sec['provides']
+            elif key == 'parameters':
+                if self.type == 'docker':
+                    self._add_parameters(data[key], 'docker')
+                elif self.type == 'cdap':
+                    data_sec = data[key]
+#                    if data_sec.has_key('app_config'):
+                    if 'app_config' in data_sec:
+                        self._add_parameters(data_sec['app_config'], 'app_config')
+#                    if data_sec.has_key('program_preferences'):
+                    if 'program_preferences' in data_sec:
+                        prog_pref_sec = data_sec['program_preferences']
+                        index = 0
+                        for prog_pref_entry in prog_pref_sec:
+#                            if prog_pref_entry.has_key('program_type'):
+                            if 'program_type' in prog_pref_entry:
+                                self._add_string_para('program_type', prog_pref_entry['program_type'], 'program_preferences_'+str(index))
+#                            if prog_pref_entry.has_key('program_id'):
+                            if 'program_id' in prog_pref_entry:
+                                self._add_string_para('program_id', prog_pref_entry['program_id'], 'program_preferences_'+str(index))
+#                            if prog_pref_entry.has_key('program_pref'):
+                            if 'program_pref' in prog_pref_entry:
+                                self._add_parameters(prog_pref_entry['program_pref'], 'program_preferences_'+str(index))
+#                    if data_sec.has_key('app_preferences'):
+                    if 'app_preferences'  in data_sec:
+                        self._add_parameters(data_sec['app_preferences'], 'app_preferences')
+            elif key == 'auxilary':
+                self.aux_para.update(data[key])
+            elif key == 'artifacts':
+                for item in data[key]:
+#                    if item.has_key('type') and item['type'] == 'jar':
+                    if 'type' in item and item['type'] == 'jar':
+                        self.image = item['uri']
+#                    if item.has_key('type') and item['type'] == 'docker image':
+                    if 'type' in item and item['type'] == 'docker image':
+                        self.image = item['uri']
+                    
+    def _import_aux_str(self, data):        
+        self.aux_para.update(data)
+        
+    
+
+class ToscaBuilder(object):
+    def __init__(self):
+        self.name = None
+        self.new_type_name = None
+        self.cloudify_type = None
+        self.imported_files = []
+        self.db = ToscaDB()
+        self.spec_import = SpecImporter()
+        self.image = None
+        self.service_component_type = None
+        self.imports = []
+        
+    def clear_DB(self):
+        self.db = ToscaDB()
+       
+    def import_spec(self, spec_name, aux_name = None):
+        self.spec_import._import(spec_name, aux_name)
+        self.set_image(self.spec_import.image)
+    
+    def import_spec_str(self, spec_str):
+        self.spec_import._import_spec_str(spec_str)
+        self.set_image(self.spec_import.image)
+        
+            
+    def import_schema(self, filename):
+        self.db = ToscaDB()
+        self.imported_files = []
+        self.db = tosca_import._file_import(self.imported_files, filename, self.db)
+        
+    def import_import(self, filename):
+        with open(filename) as data_file:
+            try: 
+                self.imports = yaml.load(data_file)
+            except yaml.YAMLError as exc:
+                logging.warning( 'input file can not be loaded as YAML, try JSON')
+                try:
+                    self.imports = json.load(data_file)
+                except:
+                    logging.error( 'input file can not be loaded as JSON either')
+                    exit(1)
+        if type(self.imports) is not list:
+            logging.error( 'import file must be a list')
+            exit(1)            
+        
+    def set_image(self, img):
+        self.image = img
+        
+    def set_service_component_type (self, type):
+        self.service_component_type = type
+        
+    
+    def _using_dmaap(self):
+        for stream in self.spec_import.streams_subscribes:
+#            if stream.has_key('type') and stream['type'] in ['message router', 'message_router', 'data router', 'data_router'] :
+            if 'type' in stream  and stream['type'] in ['message router', 'message_router', 'data router', 'data_router'] :
+                return True
+        for stream in self.spec_import.streams_publishes:
+#            if stream.has_key('type') and stream['type'] in ['message router', 'message_router', 'data router', 'data_router'] :
+            if 'type' in stream and stream['type'] in ['message router', 'message_router', 'data router', 'data_router'] :
+                return True
+        return False       
+    
+    def _using_policy(self):
+        if len(self.spec_import.policy_para) > 0:
+            return True
+        else:
+            return False     
+    
+    def create_node_type(self, name = None):
+        if self.spec_import.type == "docker":
+            parent_type_name = 'tosca.dcae.nodes.dockerApp'
+            if self._using_dmaap():
+                self.cloudify_type = self.db.NODE_TYPES['dcae.nodes.DockerContainerForComponentsUsingDmaap']
+            else:
+                self.cloudify_type = self.db.NODE_TYPES['dcae.nodes.DockerContainerForComponents']
+
+        elif self.spec_import.type == 'cdap':
+            parent_type_name = 'tosca.dcae.nodes.cdapApp'
+            self.cloudify_type = self.db.NODE_TYPES['dcae.nodes.MicroService.cdap']
+            
+        if name is None:
+            self.new_type_name = parent_type_name + '.'+self.spec_import.name
+        else:
+            self.new_type_name = parent_type_name + '.' + name
+            
+        new_type = NodeType(self.new_type_name, '')
+        new_type.parent_type = parent_type_name;
+        new_type.parent = self.db.NODE_TYPES[parent_type_name]
+        
+#             if new_type.parent is not None:
+#                 new_type.properties = copy.deepcopy(new_type.parent.properties)
+#                 new_type.attributes = copy.deepcopy(new_type.parent.attributes)
+#                 new_type.capabilities = copy.deepcopy(new_type.parent.capabilities)
+#                 new_type.requirements = copy.deepcopy(new_type.parent.requ)
+#             else:
+#                 new_type.properties = {}
+#                 new_type.attributes = {}
+#                 new_type.capabilities = {}
+        
+        for para in self.spec_import.parameters:
+#             new_prop = PropertyDefinition(para['tag']+'_'+para['name'])
+            new_prop = PropertyDefinition(para['name'])
+#            if para.has_key('type'):
+            if 'type' in para:
+                para_key = 'type'
+                if para[para_key] == 'integer':
+                    new_prop.type = TYP_INT
+                elif para[para_key] == 'float':
+                    new_prop.type = TYP_FLT
+#                elif para[para_key] == 'string' or para.has_key('value') is False:
+#                elif para[para_key] == 'string' or 'value'not in para:
+                else:
+                    new_prop.type = TYP_STR
+#                 else:
+#                     if type(para['value']) is list:
+#                         new_prop.type = TYP_LIST
+#                     elif type(para['value']) is dict:
+#                         new_prop.type = TYP_MAP
+#                     else:
+#                         new_prop.type = TYP_STR
+                new_prop.type_obj = DataType(new_prop.type)
+
+            new_prop.parsed = True            
+            new_prop._create_rawcontent()
+            if 'constraints' in para:
+                new_prop.raw_content[YMO_PROP_CONSTRAINT] = para['constraints']
+                
+            new_type.properties[new_prop.name] = new_prop
+            
+        stream_subscribe_http =     {'type': 'dcae.capabilities.stream.subscribe'}
+        stream_dmaap_mr_publish =   {'capability': 'dcae.capabilities.dmmap.topic', 'relationship': 'dcae.relationships.publish_events' }
+        stream_dmaap_mr_subscribe = {'capability': 'dcae.capabilities.dmmap.topic', 'relationship': 'dcae.relationships.subscribe_to_events' }
+        stream_dmaap_dr_publish =   {'capability': 'dcae.capabilities.dmmap.feed', 'relationship': 'dcae.relationships.publish_files' }
+        stream_dmaap_dr_subscribe = {'capability': 'dcae.capabilities.dmmap.feed', 'relationship': 'dcae.relationships.subscribe_to_files' }
+        stream_publish_http =       {'capability': 'dcae.capabilities.stream.subscribe', 'relationship': 'dcae.relationships.rework_connected_to' }
+        service_provide_content =   {'type': 'dcae.capabilities.service.provide'}
+        service_call_content =      {'capability': 'dcae.capabilities.service.provide', 'relationship': 'dcae.relationships.rework_connected_to' }
+        policy_req =                {'capability': 'dcae.capabilities.policy', 'relationship': 'cloudify.relationships.depends_on'}
+        
+        index = 0
+        for stream in self.spec_import.streams_subscribes:
+#            if stream.has_key('format') is False:
+            if 'format' not in stream:
+                continue
+            if stream['type'] == 'http':
+#                 if stream.has_key('config_key'):
+#                     new_cap_name = stream['config_key']
+#                 else:
+#                    new_cap_name = "stream_subscribe_"+str(index)
+                new_cap_name = "stream_subscribe_"+str(index)
+                new_cap = CapabilityDefinition(new_cap_name, copy.deepcopy(stream_subscribe_http))
+                new_cap._parse_content(self.db)
+                new_type.capabilities[new_cap.name] = new_cap
+                self.cloudify_type.capabilities[new_cap.name] = copy.deepcopy(new_cap)
+            elif stream['type'] in ['message router', 'message_router', 'data router', 'data_router'] :
+#                 if stream.has_key('config_key'):
+#                     new_req_name = stream['config_key']
+#                 else:
+#                     new_req_name = "stream_subscribe_"+str(index)
+                new_req_name = "stream_subscribe_"+str(index)
+                tmp_content={}
+                if stream['type'] in ['message router', 'message_router'] :
+                    tmp_content[new_req_name] = copy.deepcopy(stream_dmaap_mr_subscribe)
+                else:
+                    tmp_content[new_req_name] = copy.deepcopy(stream_dmaap_dr_subscribe)
+                new_req = RequirementDefinition(tmp_content)
+                new_req._parse_content(self.db)
+                new_type.requirements.append(new_req)
+                self.cloudify_type.requirements.append(copy.deepcopy(new_req))
+            else:
+                continue
+
+
+#             new_prop = PropertyDefinition(new_cap_name + '_route')
+#             new_prop.type = TYP_STR
+#             new_prop.type_obj = DataType(new_prop.type)
+#             new_type.properties[new_prop.name] = new_prop
+            index += 1
+        
+        index = 0
+        for service in self.spec_import.service_provides:
+#            if service.has_key('config_key'):
+            if 'config_key' in service:
+                new_cap_name = service['config_key']
+            else:   
+                new_cap_name = "service_provide_"+str(index)
+            new_cap = CapabilityDefinition(new_cap_name, copy.deepcopy(service_provide_content))
+            new_cap._parse_content(self.db)
+            new_type.capabilities[new_cap.name] = new_cap
+            self.cloudify_type.capabilities[new_cap.name] = copy.deepcopy(new_cap)
+            
+#             new_prop = PropertyDefinition(new_cap_name + '_service_name')
+#             new_prop.type = TYP_STR
+#             new_prop.type_obj = DataType(new_prop.type)
+#             new_type.properties[new_prop.name] = new_prop
+#             new_prop = PropertyDefinition(new_cap_name + '_service_endpoint')
+#             new_prop.type = TYP_STR
+#             new_prop.type_obj = DataType(new_prop.type)
+#             new_type.properties[new_prop.name] = new_prop
+#             new_prop = PropertyDefinition(new_cap_name + '_verb')
+#             new_prop.type = TYP_STR
+#             new_prop.type_obj = DataType(new_prop.type)
+#             new_type.properties[new_prop.name] = new_prop
+            index += 1
+            
+        index = 0
+        for stream in self.spec_import.streams_publishes:
+#            if stream.has_key('format') is False:
+            if 'format' not in stream:
+                continue
+            if stream['type'] == 'http':
+#                 if stream.has_key('config_key'):
+#                     new_req_name = stream['config_key']
+#                 else:
+#                     new_req_name = "stream_publish_"+str(index)
+                new_req_name = "stream_publish_"+str(index)
+                tmp_content={}
+                tmp_content[new_req_name] = copy.deepcopy(stream_publish_http)
+                new_req = RequirementDefinition(tmp_content)
+                new_req._parse_content(self.db)
+                new_type.requirements.append(new_req)
+                self.cloudify_type.requirements.append(copy.deepcopy(new_req))
+            elif stream['type'] in ['message router', 'message_router', 'data router', 'data_router'] :
+#                 if stream.has_key('config_key'):
+#                     new_req_name = stream['config_key']
+#                 else:
+#                     new_req_name = "stream_publish_"+str(index)
+                new_req_name = "stream_publish_"+str(index)
+                tmp_content={}
+                if stream['type'] in ['message router', 'message_router'] :
+                    tmp_content[new_req_name] = copy.deepcopy(stream_dmaap_mr_publish)
+                else:
+                    tmp_content[new_req_name] = copy.deepcopy(stream_dmaap_dr_publish)
+                new_req = RequirementDefinition(tmp_content)
+                new_req._parse_content(self.db)
+                new_type.requirements.append(new_req)
+                self.cloudify_type.requirements.append(copy.deepcopy(new_req))
+            else:
+                continue
+            
+#             new_prop = PropertyDefinition(new_req_name + '_key')
+#             new_prop.type = TYP_STR
+#             new_prop.type_obj = DataType(new_prop.type)
+#             new_type.properties[new_prop.name] = new_prop
+            index += 1
+            
+        index = 0
+        for service in self.spec_import.service_calls:
+#            if service.has_key('config_key'):
+            if 'config_key' in service:
+                new_req_name = service['config_key']
+            else:   
+                new_req_name = "service_call_"+str(index)
+            tmp_content={}
+            tmp_content[new_req_name] = copy.deepcopy(service_call_content)
+            new_req = RequirementDefinition(tmp_content)
+            new_req._parse_content(self.db)
+            new_type.requirements.append(new_req)
+            self.cloudify_type.requirements.append(copy.deepcopy(new_req))
+            index += 1
+                         
+        if self._using_policy() is True:
+#             self.create_policy(name)
+            for policy_group in self.spec_import.policy_para.keys():
+                if policy_group is 'default_group':
+                    new_req_name = "policy"
+                else:
+                    new_req_name = 'policy_' + policy_group
+                tmp_content={}
+                tmp_content[new_req_name] = copy.deepcopy(policy_req)
+                new_req = RequirementDefinition(tmp_content)
+                new_req._parse_content(self.db)
+                new_type.requirements.append(new_req)
+                self.cloudify_type.requirements.append(copy.deepcopy(new_req))
+
+        new_type.parsed = True
+        new_type._create_rawcontent()
+        self.db.NODE_TYPES[self.new_type_name] = new_type
+        self.cloudify_type._create_rawcontent()
+
+
+    def _create_property(self, entry):
+        raw_content = {}
+#        if entry.has_key('type'):
+        if 'type' in entry:
+            raw_content[YMO_PROP_TYPE] = entry['type']
+            if entry['type'] == 'number':
+                raw_content[YMO_PROP_TYPE] = TYP_INT
+        else:
+            raw_content[YMO_PROP_TYPE] = TYP_STR
+#        if entry.has_key('description') and len(entry['description']) > 0:
+        if 'description' in entry and len(entry['description']) > 0:
+            raw_content[YMO_PROP_DESCRIPTION] = entry['description']
+#         if entry.has_key('value'):
+#             raw_content[YMO_PROP_DEFAULT] = entry['value']
+#        if entry.has_key('constraints'):
+        if 'constraints' in entry:
+            raw_content[YMO_PROP_CONSTRAINT] = entry['constraints']
+#        if entry.has_key('entry_schema'):
+        if 'entry_schema' in entry:
+            raw_content[YMO_PROP_ENTRY] = entry['entry_schema']
+#        if entry.has_key('policy_schema'):
+        if 'policy_schema' in entry:
+            raw_content[YMO_PROP_ENTRY] = entry['policy_schema']
+            if raw_content[YMO_PROP_TYPE] is TYP_STR:
+                raw_content[YMO_PROP_TYPE] = TYP_MAP
+
+        return raw_content
+
+    def _create_data_type(self, name, type, para_array):
+        if len(para_array) < 1:
+            return None
+        
+        new_data_type = DataType(name)
+        new_data_type.type = type
+        new_data_type.properties = {}
+        for entry in para_array:
+            prop_name = entry['name']
+            new_data_type.properties[prop_name] = PropertyDefinition(prop_name)            
+            new_data_type.properties[prop_name].raw_content = self._create_property(entry)
+        
+        new_data_type._create_rawcontent()
+        return new_data_type
+
+    def _analyze_data_types(self, para_array, data_types):
+        if type(para_array) is not list:
+            return
+        for entry in para_array:
+#            if entry.has_key('entry_schema') is True:
+            if 'entry_schema' in entry:
+                new_data_name = 'policy.data.' + entry['name']
+                ret_para_array = self._analyze_data_types(entry['entry_schema'], data_types)
+#                if entry.has_key('type'):
+                if 'type' in entry:
+                    data_types[new_data_name]=self._create_data_type(new_data_name, entry['type'], ret_para_array)
+                else:
+                    data_types[new_data_name]=self._create_data_type(new_data_name, TYP_MAP, ret_para_array)
+                entry['entry_schema'] = {'type': new_data_name}
+#            elif entry.has_key('policy_schema') is True:
+            elif 'policy_schema' in entry:
+                new_data_name = 'policy.data.' + entry['name']
+                ret_para_array = self._analyze_data_types(entry['policy_schema'], data_types)
+#                if entry.has_key('type') and entry['type'] is not TYP_STR:
+                if 'type' in entry and entry['type'] is not TYP_STR:
+                    data_types[new_data_name]=self._create_data_type(new_data_name, entry['type'], ret_para_array)
+                else:
+                    data_types[new_data_name]=self._create_data_type(new_data_name, TYP_MAP, ret_para_array)
+                entry['policy_schema'] = {'type': new_data_name}
+            else:
+                continue
+            
+        return para_array
+
+    def create_policy(self):
+        parent_type_name = 'policy.nodes.Root'
+        name = self.spec_import.name
+            
+        for policy_group in self.spec_import.policy_para.keys():
+            if policy_group is 'default_group':
+                new_type_name = 'policy.nodes.'+name
+            else:
+                new_type_name = 'policy.nodes.'+policy_group
+                
+            new_type = NodeType(new_type_name, '')
+            new_type.parent_type = parent_type_name;
+            new_type.parent = self.db.NODE_TYPES[parent_type_name]
+            
+            self._analyze_data_types(self.spec_import.policy_para[policy_group], self.db.DATA_TYPES)
+            
+            for entry in self.spec_import.policy_para[policy_group]:
+                new_prop = PropertyDefinition(entry['name'])
+                new_prop.raw_content = self._create_property(entry)
+                new_prop.parsed = True            
+                new_type.properties[new_prop.name] = new_prop
+    
+            new_type.parsed = True
+            new_type._create_rawcontent()
+            self.db.NODE_TYPES[new_type_name] = new_type
+
+    def create_model(self, name):
+        self.template = ToscaTopology(DEFAULT_TEMPLATE_NAME)
+        self.template.metadata = {'template_name': name}
+        self.template.db = self.db
+
+        node = tosca_operate._create_new_node(self.template, self.new_type_name, name)
+#         self._assign_property_value(node, 'image', self.image)
+#        self._assign_property_value(node, 'service_component_type', self.spec_import.service_component_type)
+        
+        topic_index = 0;
+        
+        for prop_name in ['location_id']:
+            fuc_val_list = ['SELF', 'composition', prop_name]
+            fuc_val = {}
+            fuc_val['get_property'] = fuc_val_list
+            self._assign_property_value(node, prop_name, fuc_val)
+            
+        for para in self.spec_import.parameters:
+#            prop_item = node._get_property_item(para['tag']+'_'+para['name'])
+            prop_item = node._get_property_item(para['name'])
+            def_item = copy.deepcopy(prop_item.definition)
+#             input_name = node.name + '_' + def_item.name
+#             def_item.name = input_name
+#            if para.has_key('value'):
+            if 'value' in para:
+#                 def_item.default = para['value']
+                prop_item._assign(para['value'])
+#            if para.has_key('sourced_at_deployment') and para['sourced_at_deployment'] is True:
+            if 'sourced_at_deployment' in para and para['sourced_at_deployment'] is True:
+                input_name = prop_item.name
+                def_item = copy.deepcopy(prop_item.definition)
+                def_item.name = input_name
+#                if para.has_key('value'):
+                if 'value' in para:
+                    def_item.default = para['value']
+                self.template.aux_inputs[input_name] = PropertyItem(def_item)
+                fun_item = {}
+                fun_item['get_input'] = input_name
+                prop_item._assign(fun_item)
+#            if para.has_key('dependency'):
+            if 'dependency' in para:
+                fun_item = {}
+                fun_item['get_property'] = ['SELF', para['dependency']]
+                prop_item._assign(fun_item)
+            
+#             self.template.aux_inputs[input_name] = PropertyItem(def_item)
+#             fun_item = {}
+#             fun_item['get_input'] = input_name
+#             prop_item._assign(fun_item)
+        
+        if 'connected_broker_dns_name' in node.properties:
+            prop_item = node._get_property_item('connected_broker_dns_name')
+            if prop_item is not None: 
+                input_name = prop_item.name
+                def_item = copy.deepcopy(prop_item.definition)
+                def_item.name = input_name
+                self.template.aux_inputs[input_name] = PropertyItem(def_item)
+                fun_item = {}
+                fun_item['get_input'] = input_name
+                prop_item._assign(fun_item)
+            
+        index = 0
+        for stream in self.spec_import.streams_subscribes:
+#            if stream.has_key('format') is False:
+            if 'format' in stream is False:
+                continue
+            if stream['type'] == 'http':
+                new_cap_name = "stream_subscribe_"+str(index)
+#                if stream.has_key('format'):
+                if 'format' in stream:
+                    new_cap = node._get_capability_property(new_cap_name, 'format')
+                    new_cap._assign(stream['format'])                    
+#                if stream.has_key('version'):
+                if 'version' in stream:
+                    new_cap = node._get_capability_property(new_cap_name, 'version')
+                    new_cap._assign(stream['version'])
+#                if stream.has_key('route'):
+                if 'route' in stream:
+                    new_cap = node._get_capability_property(new_cap_name, 'route')
+                    new_cap._assign(stream['route'])
+#                         new_prop = node._get_property_item(new_cap_name+'_route')
+#                         new_prop._assign(stream['route'])
+            elif stream['type'] in ['message router', 'message_router', 'data router', 'data_router']:
+                new_req_name = "stream_subscribe_"+str(index)
+                new_req = node._get_requirement_item_first(new_req_name)
+                if stream['type'] in ['message router', 'message_router'] :
+                    new_topic_name = 'topic'+ str(topic_index)
+                    topic_index += 1
+                    new_topic_node = tosca_operate._create_new_node(self.template, 'tosca.dcae.nodes.dmaap.topic', new_topic_name)
+                else:
+                    new_topic_name = 'feed'+ str(topic_index)
+                    topic_index += 1
+                    new_topic_node = tosca_operate._create_new_node(self.template, 'tosca.dcae.nodes.dmaap.feed', new_topic_name)
+                new_req._assign(new_topic_node)
+                for prop_item in iter(new_topic_node.properties.values()):
+                    if prop_item.name == 'topic_name':
+#                        if stream.has_key('config_key'):
+#                            prop_item._assign(stream['config_key']+'-'+str(uuid.uuid4()))
+#                            prop_item._assign(stream['config_key'])
+#                        else:
+                            prop_item._assign('')
+                    elif prop_item.name == 'feed_name':
+#                        if stream.has_key('config_key'):
+#                            prop_item._assign(stream['config_key']+'-'+str(uuid.uuid4()))
+#                            prop_item._assign(stream['config_key'])
+#                        else:
+                            prop_item._assign("")                        
+                    elif prop_item.name == 'node_name':
+                        prop_item._assign('__GET_NODE_NAME__')
+                    elif prop_item.name == 'location':
+                        fun_item = {}
+                        fun_item['get_property'] = ['SELF', 'composition', 'location_id']
+                        prop_item._assign(fun_item)
+                    elif prop_item.required == True:
+                        input_name = new_topic_name + '_' + prop_item.name
+                        def_item = copy.deepcopy(prop_item.definition)
+                        def_item.name = input_name
+                        self.template.aux_inputs[input_name] = PropertyItem(def_item)
+                        fun_item = {}
+                        fun_item['get_input'] = input_name
+                        prop_item._assign(fun_item)
+                if stream['type'] in ['message router', 'message_router'] :
+                    for cap_prop_item in iter(new_topic_node._get_capability_item('topic').properties.values()):
+                        cap_prop_item._assign({'get_property': ['SELF', cap_prop_item.name]})
+                else:
+                    for cap_prop_item in iter(new_topic_node._get_capability_item('feed').properties.values()):
+                        cap_prop_item._assign({'get_property': ['SELF', cap_prop_item.name]})
+                       
+            index += 1
+
+        index = 0
+        for service in self.spec_import.service_provides:
+            new_cap_name = "service_provide_"+str(index)
+#            if service.has_key('request'):
+            if 'request' in service:
+                service_item = service['request']
+#                if service_item.has_key('format'):
+                if 'format' in service_item:
+                    new_cap = node._get_capability_property(new_cap_name, 'request_format')
+                    new_cap._assign(service_item['format'])                    
+#                if service_item.has_key('version'):
+                if 'version' in service_item:
+                    new_cap = node._get_capability_property(new_cap_name, 'request_version')
+                    new_cap._assign(service_item['version'])
+#            if service.has_key('response'):
+            if 'response' in service:
+                service_item = service['response']
+#                if service_item.has_key('format'):
+                if 'format' in service_item:
+                    new_cap = node._get_capability_property(new_cap_name, 'response_format')
+                    new_cap._assign(service_item['format'])                    
+#                if service_item.has_key('version'):
+                if 'version' in service_item:
+                    new_cap = node._get_capability_property(new_cap_name, 'response_version')
+                    new_cap._assign(service_item['version'])                
+#            if service.has_key('service_name'):
+            if 'service_name' in service:
+                new_cap = node._get_capability_property(new_cap_name, 'service_name')
+                new_cap._assign(service['service_name'])                    
+#                     new_prop = node._get_property_item(new_cap_name+'_service_name')
+#                     new_prop._assign(service['service_name'])
+#            if service.has_key('service_endpoint'):
+            if 'service_endpoint' in service:
+                new_cap = node._get_capability_property(new_cap_name, 'service_endpoint')
+                new_cap._assign(service['service_endpoint'])                    
+#                     new_prop = node._get_property_item(new_cap_name+'_service_endpoint')
+#                     new_prop._assign(service['service_endpoint'])
+#            if service.has_key('verb'):
+            if 'verb' in service:
+                new_cap = node._get_capability_property(new_cap_name, 'verb')
+                new_cap._assign(service['verb'])                    
+#                     new_prop = node._get_property_item(new_cap_name+'_verb')
+#                     new_prop._assign(service['verb'])
+            index += 1
+
+        
+        index = 0
+        for stream in self.spec_import.streams_publishes:
+#            if stream.has_key('format') is False:
+            if 'format' not in stream:
+                continue
+            if stream['type'] == 'http':
+                new_req_name = "stream_publish_"+str(index)
+                new_req = node._get_requirement_item_first(new_req_name)
+                items = []
+#                if stream.has_key('format'):
+                if 'format' in stream:
+                    items.append({'format':[{'equal': stream['format']}]})
+#                if stream.has_key('version'):
+                if 'version' in stream:
+                    items.append({'version':[{'equal': stream['version']}]})
+                new_req.filter = {'capabilities': [{'dcae.capabilities.stream.subscribe': {'properties': items}}]}
+            elif stream['type'] in ['message router', 'message_router', 'data router', 'data_router']:
+                new_req_name = "stream_publish_"+str(index)
+                new_req = node._get_requirement_item_first(new_req_name)
+                if stream['type'] in ['message router', 'message_router'] :
+                    new_topic_name = 'topic'+ str(topic_index)
+                    topic_index += 1
+                    new_topic_node = tosca_operate._create_new_node(self.template, 'tosca.dcae.nodes.dmaap.topic', new_topic_name)
+                else:
+                    new_topic_name = 'feed'+ str(topic_index)
+                    topic_index += 1
+                    new_topic_node = tosca_operate._create_new_node(self.template, 'tosca.dcae.nodes.dmaap.feed', new_topic_name)
+                new_req._assign(new_topic_node)
+                for prop_item in iter(new_topic_node.properties.values()):
+                    if prop_item.name == 'topic_name':
+#                        if stream.has_key('config_key'):
+#                            prop_item._assign(stream['config_key']+'-'+str(uuid.uuid4()))
+#                            prop_item._assign(stream['config_key'])
+#                        else:
+                            prop_item._assign("")
+                    elif prop_item.name == 'feed_name':
+#                        if stream.has_key('config_key'):
+#                            prop_item._assign(stream['config_key']+'-'+str(uuid.uuid4()))
+#                            prop_item._assign(stream['config_key'])
+#                        else:
+                            prop_item._assign("")                        
+                    elif prop_item.name == 'node_name':
+                        prop_item._assign('__GET_NODE_NAME__')
+                    elif prop_item.name == 'location':
+                        fun_item = {}
+                        fun_item['get_property'] = ['SELF', 'composition', 'location_id']
+                        prop_item._assign(fun_item)
+                    else:
+                        input_name = new_topic_name + '_' + prop_item.name
+                        def_item = copy.deepcopy(prop_item.definition)
+                        def_item.name = input_name
+                        self.template.aux_inputs[input_name] = PropertyItem(def_item)
+                        fun_item = {}
+                        fun_item['get_input'] = input_name
+                        prop_item._assign(fun_item)
+                if stream['type'] in ['message router', 'message_router'] :
+                    for cap_prop_item in iter(new_topic_node._get_capability_item('topic').properties.values()):
+                        cap_prop_item._assign({'get_property': ['SELF', cap_prop_item.name]})
+                else:
+                    for cap_prop_item in iter(new_topic_node._get_capability_item('feed').properties.values()):
+                        cap_prop_item._assign({'get_property': ['SELF', cap_prop_item.name]})
+
+            index += 1            
+        
+        if self._using_policy():
+            index = 0
+            for policy_group in self.spec_import.policy_para.keys():
+                if policy_group is 'default_group':
+                    req_name = 'policy'
+                    policy_type_name = 'policy.nodes.' + self.spec_import.name
+                else:
+                    req_name = 'policy_'+policy_group
+                    policy_type_name = 'policy.nodes.' + policy_group
+    
+                new_req = node._get_requirement_item_first(req_name)
+                policy_node_name = 'policy_' + str(index)
+                index += 1
+                new_policy_node = tosca_operate._create_new_node(self.template, 'tosca.dcae.nodes.policy', policy_node_name)
+                policy_name_item = new_policy_node._get_property_item('policy_name')
+                policy_name_item._assign(policy_type_name)
+                new_req._assign(new_policy_node)  
+    
+    
+    def create_translate(self, name):
+        self.template = ToscaTopology(DEFAULT_TEMPLATE_NAME)
+        self.template.metadata = {'template_name': name+"_translate"}
+        self.template.db = self.db
+        index = 0
+        for item in self.imports:
+            self.template.extra_imports.append({str(index): item})
+            index += 1
+        
+        if self.new_type_name not in self.db.NODE_TYPES:
+            logging.warning( 'error: new node type is not in db: ' + self.new_type_name)
+            return
+        
+        for input_def in iter(self.db.NODE_TYPES[self.new_type_name].properties.values()):
+            self.template.inputs[input_def.name] = PropertyItem(input_def)
+        
+        self.template.sub_type = self.new_type_name
+            
+        for cap_name in self.db.NODE_TYPES[self.new_type_name].capabilities.keys():
+            self.template.sub_rules.append(SubstitutionRule(SUB_CAPABILITY, cap_name, None, [name, cap_name]))
+            
+        for req_item in self.db.NODE_TYPES[self.new_type_name].requirements:
+            if req_item.name == 'host':
+                self.template.sub_rules.append(SubstitutionRule(SUB_REQUIREMENT, req_item.name, None, [name, 'host']))
+            elif req_item.name == 'composition':
+                continue
+            else:
+                self.template.sub_rules.append(SubstitutionRule(SUB_REQUIREMENT, req_item.name, None, [name, req_item.name]))
+                                                            
+        if self.cloudify_type is None:
+            logging.warning( 'cloudify_type should not be None!')
+            return 
+        
+        node = tosca_operate._create_new_node(self.template, self.cloudify_type.name, name)
+
+        for prop_name in node.properties.keys():
+            if prop_name == 'application_config':
+                fuc_val = {}
+                for entry in self.spec_import.parameters:
+                    if entry['tag'] == 'docker':
+                        tmp_fun = {}
+#                        tmp_fun['get_input'] = entry['tag']+'_' +entry['name']
+                        tmp_fun['get_input'] = entry['name']
+                        fuc_val[entry['name']] = tmp_fun
+
+                fuc_list = {}
+                index = 0
+                for stream in self.spec_import.streams_publishes:
+                    fuc_unit = {}
+                    req_name = "stream_publish_"+str(index)
+                    index += 1            
+                    if stream['type'] in ['message router', 'message_router']:
+                        fuc_unit['aaf_password'] = {'get_property': ['SELF', req_name, 'aaf_password' ]}
+                        fuc_unit['aaf_username'] = {'get_property': ['SELF', req_name, 'aaf_username' ]}
+                        fuc_unit['dmaap_info'] = {'concat': ['<<', {'get_property': ['SELF', req_name, 'node_name']}, '>>' ]}
+                        fuc_unit['type'] = stream['type'].replace(' ', '_')
+                    elif stream['type'] in ['data router', 'data_router']:
+                        fuc_unit['dmaap_info'] = {'concat': ['<<', {'get_property': ['SELF', req_name, 'node_name']}, '>>' ]}
+                        fuc_unit['type'] = stream['type'].replace(' ', '_')
+                    else:
+                        fuc_unit = {'concat': ['{{', {'get_property': ['SELF', req_name, 'node_name']}, '}}' ]}
+                    fuc_list.update({stream['config_key']: fuc_unit})
+                fuc_val['streams_publishes'] = fuc_list
+
+                fuc_list = {}
+                index = 0
+                for stream in self.spec_import.streams_subscribes:
+                    fuc_unit = {}
+                    req_name = "stream_subscribe_"+str(index)
+                    index += 1            
+                    if stream['type']  in ['message router', 'message_router']:
+                        fuc_unit['aaf_password'] = {'get_property': ['SELF', req_name, 'aaf_password' ]}
+                        fuc_unit['aaf_username'] = {'get_property': ['SELF', req_name, 'aaf_username' ]}
+                        fuc_unit['dmaap_info'] = {'concat': ['<<', {'get_property': ['SELF', req_name, 'node_name']}, '>>' ]}
+                        fuc_unit['type'] = stream['type'].replace(' ', '_')
+                    elif stream['type'] in ['data router', 'data_router']:
+                        fuc_unit['dmaap_info'] = {'concat': ['<<', {'get_property': ['SELF', req_name, 'node_name']}, '>>' ]}
+                        fuc_unit['type'] = stream['type'].replace(' ', '_')
+                    else:
+                        continue
+                    fuc_list.update({stream['config_key']: fuc_unit})
+                fuc_val['streams_subscribes'] = fuc_list
+                
+                fuc_list = {}
+                index = 0
+                for service in self.spec_import.service_calls:
+#                    if service.has_key('config_key'):
+                    if 'config_key' in service:
+                        req_name = service['config_key']
+                    else:
+                        req_name = 'service_call_' + str(index)
+                    index += 1
+#                    if service['type'] == 'http':
+                    fuc_unit = {'concat': ['{{', {'get_property': ['SELF', req_name, 'node_name']}, '}}' ]}
+#                    if service.has_key('config_key') is False:
+                    if 'config_key' not in service:
+                        logging.warning( 'service call section must have config_key!')
+                        continue
+                    fuc_list.update({service['config_key']: fuc_unit})
+                fuc_val['services_calls'] = fuc_list
+
+            elif prop_name in ['app_config', 'app_preferences']:
+                fuc_val = {}
+                for entry in self.spec_import.parameters:
+                    if entry['tag'] == prop_name:
+                        tmp_fun = {}
+#                         tmp_fun['get_input'] = entry['tag']+'_' +entry['name']
+                        tmp_fun['get_input'] = entry['name']
+                        fuc_val[entry['name']] = tmp_fun
+            elif prop_name == 'program_preferences':
+                fuc_val = []
+                last_tag = None
+                for entry in self.spec_import.parameters:
+                    if entry['tag'].startswith(prop_name):
+                        if entry['tag'] != last_tag:
+                            fuc_entry = {}
+                            fuc_unit = {}
+                            fuc_entry['program_pref'] = fuc_unit
+                            last_tag = entry['tag']
+                            fuc_val.append(fuc_entry)
+                        if entry['name'] in ['program_type', 'program_id']:
+                            tmp_fun = {}
+#                            tmp_fun['get_input'] = entry['tag']+'_' +entry['name']
+                            tmp_fun['get_input'] = entry['name']
+                            fuc_entry[entry['name']] = tmp_fun
+                        else:
+                            tmp_fun = {}
+#                            tmp_fun['get_input'] = entry['tag']+'_' +entry['name']
+                            tmp_fun['get_input'] = entry['name']
+                            fuc_unit[entry['name']] = tmp_fun
+            elif prop_name == 'service_endpoints':
+                fuc_val = []
+                index = 0
+                for service in self.spec_import.service_provides:
+                    fuc_entry={}
+                    cap_prefix = 'service_' + str(index)
+#@                    if service.has_key('service_name'):
+                    if 'service_name' in service:
+                        tmp_fun = {'get_input':cap_prefix + '_service_name'}
+                    else:
+                        tmp_fun = {}
+                    fuc_entry['service_name'] = tmp_fun
+#                    if service.has_key('service_endpoint'):
+                    if 'service_endpoint' in service:
+                        tmp_fun = {'get_input':cap_prefix + '_service_endpoint'}
+                    else:
+                        tmp_fun = {}
+                    fuc_entry['service_endpoint'] = tmp_fun
+#                    if service.has_key('verb'):
+                    if 'verb' in service:
+                        tmp_fun = {'get_input':cap_prefix + '_verb'}
+                    else:
+                        tmp_fun = {}
+                    fuc_entry['endpoint_method'] = tmp_fun
+                    fuc_val.append(fuc_entry)
+                    index += 1
+                    
+            elif prop_name == 'docker_config':
+                fuc_val = {}
+                for key in self.spec_import.aux_para.keys():
+                    fuc_val[key] = self.spec_import.aux_para[key]
+                    
+            elif prop_name == 'connections':
+                fuc_val = {}
+                fuc_entry = []
+                index = 0
+                for stream in self.spec_import.streams_publishes:
+                    if stream['type'] not in ['message router', 'message_router', 'data router', 'data_router']:
+                        continue
+                    fuc_unit = {}
+                    req_name = "stream_publish_"+str(index)
+                    fuc_unit['name'] = {'get_property': ['SELF', req_name, 'node_name' ]}
+#                    if stream.has_key('config_key'):
+                    if 'config_key' in stream:
+                        fuc_unit['config_key'] = stream['config_key']
+                    if stream['type'] in ['message router', 'message_router']:
+                        fuc_unit['client_role'] = {'get_property': ['SELF', req_name, 'client_role' ]}
+                        fuc_unit['aaf_username'] = {'get_property': ['SELF', req_name, 'aaf_username' ]}
+                        fuc_unit['aaf_password'] = {'get_property': ['SELF', req_name, 'aaf_password' ]}                        
+                    fuc_unit['location'] = {'get_property': ['SELF', req_name, 'location' ]}
+                    fuc_unit['type'] = stream['type'].replace(' ', '_')
+                    fuc_entry.append(fuc_unit)
+                    index += 1
+                fuc_val['streams_publishes'] = fuc_entry
+                fuc_entry = []
+                index = 0
+                for stream in self.spec_import.streams_subscribes:
+                    if stream['type'] not in ['message router', 'message_router', 'data router', 'data_router']:
+                        continue
+                    fuc_unit = {}
+                    req_name = "stream_subscribe_"+str(index)
+                    fuc_unit['name'] = {'get_property': ['SELF', req_name, 'node_name' ]}
+#                    if stream.has_key('config_key'):
+                    if 'config_key' in stream:
+                        fuc_unit['config_key'] = stream['config_key']
+                    if stream['type'] in ['message router', 'message_router']:
+                        fuc_unit['client_role'] = {'get_property': ['SELF', req_name, 'client_role' ]}
+                        fuc_unit['aaf_username'] = {'get_property': ['SELF', req_name, 'aaf_username' ]}
+                        fuc_unit['aaf_password'] = {'get_property': ['SELF', req_name, 'aaf_password' ]}                        
+                    fuc_unit['location'] = {'get_property': ['SELF', req_name, 'location' ]}
+                    fuc_unit['type'] = stream['type'].replace(' ', '_')
+                    fuc_entry.append(fuc_unit)
+                    index += 1
+                fuc_val['streams_subscribes'] = fuc_entry
+            
+            elif prop_name == 'streams_publishes':
+                fuc_val = []
+                index = 0
+                
+                for stream in self.spec_import.streams_publishes:
+                    if stream['type'] not in ['message router', 'message_router', 'data router', 'data_router']:
+                        continue
+                    fuc_unit = {}
+                    req_name = "stream_publish_"+str(index)
+                    fuc_unit['name'] = {'get_property': ['SELF', req_name, 'node_name' ]}
+                    if stream['type'] in ['message router', 'message_router']:
+                        fuc_unit['client_role'] = {'get_property': ['SELF', req_name, 'client_role' ]}
+                    fuc_unit['location'] = {'get_property': ['SELF', req_name, 'location' ]}
+                    fuc_unit['type'] = stream['type'].replace(' ', '_')
+                    fuc_val.append(fuc_unit)
+                    index += 1
+
+            elif prop_name == 'streams_subscribes':
+                fuc_val = []
+                index = 0
+                
+                for stream in self.spec_import.streams_subscribes:
+                    if stream['type'] not in ['message router', 'message_router', 'data router', 'data_router']:
+                        continue
+                    fuc_unit = {}
+                    req_name = "stream_subscribe_"+str(index)
+                    fuc_unit['name'] = {'get_property': ['SELF', req_name, 'node_name' ]}
+                    fuc_unit['location'] = {'get_property': ['SELF', req_name, 'location' ]}
+                    if stream['type'] in ['message router', 'message_router']:
+                        fuc_unit['client_role'] = {'get_property': ['SELF', req_name, 'client_role' ]}
+                    fuc_unit['type'] = stream['type'].replace(' ', '_')
+                    fuc_val.append(fuc_unit)
+                    index += 1
+
+                
+            elif self.spec_import.aux_para is not None and prop_name in self.spec_import.aux_para.keys():
+                fuc_val = self.spec_import.aux_para[prop_name]
+            elif prop_name == 'service_component_type':
+                if self.service_component_type is not None:
+                    fuc_val = self.service_component_type
+                elif self.spec_import.type == 'docker':
+                    fuc_val = self.spec_import.name
+                else:
+                    fuc_val = 'cdap_app_' + name
+            elif prop_name in ['image', 'jar_url']:
+                fuc_val = self.image
+            else:
+                fuc_val = {}
+                fuc_val['get_input'] = prop_name
+                                
+            self._assign_property_value(node, prop_name, fuc_val)
+        
+        if 'cdap' in self.cloudify_type.name:
+            interface_item = node._get_interface_item('cloudify.interfaces.lifecycle')
+            op_item = interface_item.operations['create']
+            input_item = op_item.inputs['connected_broker_dns_name']
+            input_item._assign({'get_input': 'connected_broker_dns_name'})
+        
+            
+    def _assign_property_value(self, node, property_name, value):
+#        if node.properties.has_key(property_name) is False:
+        if property_name not in node.properties:
+            logging.warning( 'No property with name '+ property_name+ ' in the node '+ node.name)
+            return False
+        return node.properties[property_name]._assign(value)
+
+    def export_policy(self, filename):
+        return tosca_export._yaml_export(filename, self.db._prepare_schema())
+        
+    def export_schema(self, filename):
+        return tosca_export._yaml_export(filename, self.db._prepare_schema())
+            
+    def export_model(self, filename):
+        return tosca_export._yaml_export(filename, self.template._prepare_output('main,import_schema'))
+    
+    def export_translation(self, filename):
+        return tosca_export._yaml_export(filename, self.template._prepare_output('main,import_schema,w_sub'))
+
+        
diff --git a/app/toscalib/tosca_builder.pyc b/app/toscalib/tosca_builder.pyc
new file mode 100644
index 0000000..082f41c
--- /dev/null
+++ b/app/toscalib/tosca_builder.pyc
diff --git a/app/toscalib/tosca_workbook.py b/app/toscalib/tosca_workbook.py
new file mode 100644
index 0000000..0fce630
--- /dev/null
+++ b/app/toscalib/tosca_workbook.py
@@ -0,0 +1,202 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+from toscalib.templates.database import ToscaDB
+from toscalib.utils import tosca_operate, tosca_import, tosca_print, tosca_export
+from toscalib.utils.tosca_import import import_context
+from toscalib.templates.topology import ToscaTopology
+from toscalib.utils.tosca_operate import _assign_property_value,\
+    _assign_requirement_value, _assign_capability_property_value
+import copy, logging
+
+DEFAULT_TEMPLATE_NAME='default'
+
+class ToscaWorkBook(object):
+    def __init__(self):
+        self.db = ToscaDB()
+        self.tran_db = ToscaDB()
+        self.template = ToscaTopology(DEFAULT_TEMPLATE_NAME)
+        self.template.db = self.db
+        self.imported_files = []
+        
+    def _reset(self):
+        self.template = ToscaTopology(DEFAULT_TEMPLATE_NAME)
+        self.template.db = self.db
+
+        
+    def _import(self, filename):
+        self.db = tosca_import._file_import(self.imported_files, filename, self.db)
+
+    def _import_dir(self, dirname):
+        self.db = tosca_import._dir_import(self.imported_files, dirname, self.db)
+        
+    def _import_yml_str(self, content):
+        self.db = tosca_import._yaml_str_import(content, self.db)
+        
+    def _load_translation_db(self, dir_name, prefix=''):
+        self.tran_db = tosca_import._dir_import([], dir_name, self.tran_db)
+    
+    def _load_translation_library(self):
+        if self.tran_db is None or len(self.tran_db.TEMPLATES) < 1:
+            return
+        
+        for node_item in iter(self.template.node_dict.values()):  
+            node_item.tran_template = None  
+            for tran_temp in iter(self.tran_db.TEMPLATES.values()):
+                if hasattr(tran_temp,'sub_type') and tran_temp.sub_type == node_item.type:
+                    node_item.tran_template = copy.deepcopy(tran_temp)
+                    node_item.tran_template._update_used_tag_for_translation()
+                    node_item.tran_template._verify_substitution(node_item)
+                    node_item.tran_template._update_prefix(node_item.name + '_')
+                    break
+    
+    def _use(self, type_name, node_name=None):
+        if type_name in self.db.NODE_TYPES.keys():
+            return tosca_operate._create_new_node(self.template, type_name, node_name)
+        elif type_name in self.db.TEMPLATES.keys():
+            return tosca_operate._create_new_template(self.template, type_name, node_name)
+        else:
+            logging.warning('Name: ' + type_name + ' is neither a type or a template. ')
+            return None
+    
+    def _assign(self, node_name, sub_name, value_1, value_2 = None):
+#        if self.template.node_dict.has_key(node_name) is False:
+        if node_name not in self.template.node_dict:
+            logging.warning('Unrecognized node name: ' + node_name)
+            return
+        node = self.template.node_dict[node_name]
+        if value_2 is not None:
+#            if  node.capabilities.has_key(sub_name):
+            if  sub_name in node.capabilities:
+                node_cap = node.capabilities[sub_name]
+#                if node_cap.properties.has_key(value_1):
+                if value_1 in node_cap.properties:
+                    _assign_capability_property_value(node, sub_name, value_1, value_2)
+                else:
+                    logging.warning( 'Unrecognized tag name: ' + value_1)
+            else:
+                logging('Unrecognized tag name: ' + sub_name)
+#        elif node.properties.has_key(sub_name):
+        elif sub_name in node.properties:
+            _assign_property_value(node, sub_name, value_1)
+        else:
+            req_found = False
+            for req in node.requirements:
+                if req.name == sub_name:
+                    req_found = req
+                    break
+            if req_found is False:
+                logging.warning( 'Unrecognized tag name: ' + sub_name)
+                return
+
+#            if self.template.node_dict.has_key(value_1):
+            if value_1 in self.template.node_dict:
+                _assign_requirement_value(node, sub_name, self.template.node_dict[value_1])
+            else:
+                logging.warning( 'Incorrect node name: ' + value_1 + ', a node name is needed to fulfill requirement')
+                return
+    
+    def _show_abstract(self):
+        return tosca_print._print_template(self.template, tosca_print.LEVEL_NODE_NAME)
+        
+    def _show_details(self):
+        return tosca_print._print_template(self.template, tosca_print.LEVEL_NODE_DETAILS)
+        
+    def _show_types(self):
+        return tosca_print._print_node_types(self.db)
+        
+    def _show_type(self, type_name):
+        if type_name in self.db.NODE_TYPES.keys():
+            tosca_print._print_node_type(self.db.NODE_TYPES[type_name])
+        else:
+            logging.warning( 'Node type: '+ type_name+ ' not found!')
+      
+    def _show_templates(self):
+        tosca_print._print_templates(self.db)
+              
+    def _show_template(self, temp_name):
+        if temp_name in self.db.TEMPLATES.keys():
+            tosca_print._print_template(self.db.TEMPLATES[temp_name])
+        else:
+            logging.warning( 'Template: '+ temp_name+ ' not found')
+            
+    def _translate_template_file(self, filename):
+        ctx = import_context()
+        self.db = tosca_import._single_template_file_import(filename, self.db, ctx)
+        temp_name = ctx.temp_name
+        
+        self._reset()
+        self.tran_db = self.db
+        self._use(temp_name, 'NO_PREFIX')
+        
+    def _translate_template_yaml_str(self, content):
+        ctx = import_context()
+        self.db = tosca_import._yaml_str_import(content, self.db, ctx)
+        temp_name = ctx.temp_name
+        
+        self._reset()
+        self.tran_db = self.db
+        self._use(temp_name, 'NO_PREFIX')
+        
+    def _add_shared_node(self, rel):
+        if rel is None or type(rel) is not list:
+            return
+        
+#        node_index = 0;
+        
+        for rel_entry in rel:
+            rel_name = list(rel_entry.keys())[0]
+            new_node_name = None
+#            temp_node_base= 'node_'
+
+            while True:
+                ret_node = self._find_open_requirement(rel_name)
+                if ret_node is None:
+                    break
+                if new_node_name == None:
+#                    while True:
+#                        temp_node_name = temp_node_base + str(node_index)
+#                        if self.template.node_dict.has_key(temp_node_name):
+#                            node_index += 1
+#                            continue
+#                        else:
+#                            break
+                    if self._use(rel_entry[rel_name], 'NO_PREFIX') == None:
+                        break
+                    new_node_name = True
+                self._assign(ret_node[0], ret_node[1], rel_entry[rel_name])
+                
+    def _find_open_requirement(self, cap_type):
+        for node in iter(self.template.node_dict.values()):
+            for req_item in node.requirements:
+                if req_item.filled is True:
+                    continue
+                if req_item.req_capability == cap_type:
+                    return [node.name, req_item.name]    
+        
+        
+        
+    
+    def _export_generic(self, tags=''):        
+        self.template._update_function_pointer()
+        self._load_translation_library()
+#        self.template._auto_generate_aux_inputs()
+        self.template._propagate_substitution_value()
+        self.template._update_translation_function_pointer()
+
+        return self.template._prepare_output(tags)
+
+    def _export_yaml(self, filename, tags='main,nodetype'):
+        return tosca_export._yaml_export(filename, self._export_generic(tags))
+    
+    def _export_yaml_web(self, tags= 'main,nodetype'):
+        return tosca_export._yaml_export('WEB', self._export_generic(tags))
+        
+    def _export_heat(self, filename):
+        tags ='heat,main'
+        return tosca_export._heat_export(filename, self._export_generic(tags))
+    
+    def toJson(self):
+        return self.template.toJson()
+    
+\ No newline at end of file
diff --git a/app/toscalib/tosca_workbook.pyc b/app/toscalib/tosca_workbook.pyc
new file mode 100644
index 0000000..a3ada52
--- /dev/null
+++ b/app/toscalib/tosca_workbook.pyc
diff --git a/app/toscalib/types/__init__.py b/app/toscalib/types/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/app/toscalib/types/__init__.py
diff --git a/app/toscalib/types/__init__.pyc b/app/toscalib/types/__init__.pyc
new file mode 100644
index 0000000..810f67d
--- /dev/null
+++ b/app/toscalib/types/__init__.pyc
diff --git a/app/toscalib/types/capability.py b/app/toscalib/types/capability.py
new file mode 100644
index 0000000..47d9238
--- /dev/null
+++ b/app/toscalib/types/capability.py
@@ -0,0 +1,144 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+from toscalib.templates.constant import *
+from toscalib.types.property import PropertyDefinition
+import copy,logging
+
+
+class CapabilityDefinition:
+    def __init__(self, name, content):
+        if name is None:
+            return None
+        self.name = name
+        self.type = None
+        self.type_obj = None
+        self.valid_source = None
+        self.parsed = False
+        self.id = PropertyDefinition('id')
+        self.raw_content = content
+        
+    def _parse_content(self, db):
+        if self.parsed:
+            return 
+        
+        self.id._parse_content(db)
+        
+        content = self.raw_content
+        
+        if content is None:
+            logging.warning( 'Capability definition'+ self.name+ ' is None!')
+            self.parsed = True
+            
+#        if content.has_key(CAP_TYPE):
+        if CAP_TYPE in content:
+            self.type = content[CAP_TYPE]
+#            if db.CAPABILITY_TYPES.has_key(self.type):
+            if self.type in db.CAPABILITY_TYPES:
+                self.type_obj = db.CAPABILITY_TYPES[self.type]
+                self.type_obj._parse_content(db)
+            elif self.type != 'tosca.capabilities.Root':
+                logging.warning( 'Capability type '+ self.type+ ' not imported or defined!')
+        else:
+            logging.warning( 'Capability definition '+ self.name+ ' has no type defined!')         
+        
+#        if content.has_key(CAP_SOURCE):
+        if CAP_SOURCE in content:
+            self.valid_source = content[CAP_SOURCE]
+        elif self.type_obj is not None :
+            self.valid_source = self.type_obj.valid_source
+            
+        if self.type_obj is not None:
+            self.properties = copy.deepcopy(self.type_obj.properties)
+        else:
+            self.properties = {}
+
+#        if content.has_key(CAP_PROPERTIES):
+        if CAP_PROPERTIES in content:
+            prop_sec = content[CAP_PROPERTIES]
+            for prop_name in prop_sec.keys():
+#                if self.properties.has_key(prop_name):
+                if prop_name in self.properties:
+#                     self.properties[prop_name].update(PropertyDefinition(prop_name, prop_sec[prop_name]))
+#                 else:
+                    logging.warning( 'Property name '+ prop_name+ ' has been defined in type definition, overwritten here!')
+                    self.properties[prop_name] = PropertyDefinition(prop_name, prop_sec[prop_name])
+                    self.properties[prop_name]._parse_content(db)
+        
+        self.parsed = True
+        pass
+
+    def _validate_capability(self, cap_name):
+        if self.type_obj is not None:
+            return self.type_obj._validate_capability(cap_name)
+        else:
+            return self.type == cap_name
+
+
+class CapabilityType:
+    def __init__(self, name, content):
+        if name is None or content is None:
+            return None
+        self.name = name        
+        self.parent_type = None
+        self.parent = None
+        self.valid_source = None
+        self.parsed = False
+        self.raw_content = content
+                
+    def _parse_content(self, db):
+        if self.parsed is True:
+            return
+        
+        content = self.raw_content
+        if content is None:
+            logging.warning( 'Capability type '+ self.name+ ' has None content')
+            return
+        
+#        if content.has_key(CAP_DERIVED_FROM):
+        if CAP_DERIVED_FROM in content:
+            self.parent_type = content[CAP_DERIVED_FROM]
+#            if db.CAPABILITY_TYPES.has_key(self.parent_type):
+            if self.parent_type  in db.CAPABILITY_TYPES:
+                self.parent = db.CAPABILITY_TYPES[self.parent_type]
+                self.parent._parse_content(db)
+            elif self.parent_type != 'tosca.capabilities.Root':
+                logging.warning( 'Capability type '+ self.parent_type+ ' not imported but defined!')
+        else:
+            logging.warning( 'Capability type '+ self.name+ ' has no parent type to derive from')
+            
+        if self.parent is not None:
+            self.properties = copy.deepcopy(self.parent.properties)
+        else:
+            self.properties = {}
+
+#        if content.has_key(CAP_PROPERTIES):
+        if CAP_PROPERTIES in content:
+            prop_sec = content[CAP_PROPERTIES]
+#            for prop_name in prop_sec.keys():
+            for prop_name in prop_sec.keys():
+#                if self.properties.has_key(prop_name):
+                if prop_name in self.properties:
+#                     self.properties[prop_name].update(PropertyDefinition(prop_name, prop_sec[prop_name]))
+#                 else:
+                    logging.warning( 'Property name '+ prop_name+ ' has been defined in parent type, overwritten here!')
+                self.properties[prop_name] = PropertyDefinition(prop_name, prop_sec[prop_name])
+                self.properties[prop_name]._parse_content(db)
+                    
+#        if content.has_key(CAP_SOURCE):
+        if CAP_SOURCE in content:
+            self.valid_source = content[CAP_SOURCE]
+                    
+        self.parsed = True
+        
+    def _validate_capability(self, cap_name):
+        if self.name == cap_name:
+            return True
+        if self.parent is not None:
+            return self.parent._validate_capability(cap_name)
+        else:
+            return False
+        
+
+                    
+\ No newline at end of file
diff --git a/app/toscalib/types/capability.pyc b/app/toscalib/types/capability.pyc
new file mode 100644
index 0000000..f79e142
--- /dev/null
+++ b/app/toscalib/types/capability.pyc
diff --git a/app/toscalib/types/constraints.py b/app/toscalib/types/constraints.py
new file mode 100644
index 0000000..ae2401d
--- /dev/null
+++ b/app/toscalib/types/constraints.py
@@ -0,0 +1,15 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+class PropertyConstraints(object):
+    def __init__(self, content):
+        self.raw_content = content
+    
+    def _parse_content(self):
+        pass
+    
+    def _validate(self, value):
+        return True
+    
+    
diff --git a/app/toscalib/types/constraints.pyc b/app/toscalib/types/constraints.pyc
new file mode 100644
index 0000000..514635a
--- /dev/null
+++ b/app/toscalib/types/constraints.pyc
diff --git a/app/toscalib/types/data.py b/app/toscalib/types/data.py
new file mode 100644
index 0000000..73496e2
--- /dev/null
+++ b/app/toscalib/types/data.py
@@ -0,0 +1,282 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+import ast
+import copy, logging
+from toscalib.templates.constant import *
+from toscalib.types.constraints import PropertyConstraints
+from toscalib.types.entry_schema import EntrySchema
+
+BUILT_IN_TYPES= (TYP_BOOL, TYP_INT, TYP_FLT, TYP_STR, TYP_MAP, TYP_LIST, TYP_VER, TYP_SIZE, TYP_TIME, TYP_FREQ, TYP_ANY) = \
+                ('boolean', 'integer', 'float', 'string', 'map', 'list', 'version', 'scalar-unit.size', 'scalar-unit.time', 'scalar-unit.frequency', 'output')                                          
+
+def _is_integer(value):
+    try: 
+        int(value)
+        return True
+    except ValueError:
+        return False   
+    
+def _is_float(value):
+    try: 
+        float(value)
+        return True;
+    except ValueError:
+        return False
+
+def _is_true(value):
+    if value is True:
+        return True
+    elif value in TRUE_VALUES:
+        return True
+    else:
+        return False 
+        
+             
+class DataType:
+    def __init__(self, name, content=None):
+        self.name = name
+        self.entry = EntrySchema(TYP_ANY)
+        self.contraints = None
+        self.used = False
+        self.parent_type = None
+        if content is None:
+            self.built_in = True
+            self.type = self.name
+            self.raw_content = None
+            self.parsed = False
+        else:
+            self.built_in = False
+            self.type = None
+            self.raw_content = content
+            self.parsed = False
+        
+    @classmethod
+    def _built_in_types(cls):
+        return BUILT_IN_TYPES
+    
+    def _parse_content(self, db):
+        if self.parsed is True:
+            return
+        
+        self.properties = {}
+
+        if self.raw_content is None:
+            self.parsed = True
+            self.entry._parse_content(db)        
+
+            return
+        
+#        if self.raw_content.has_key(NOD_DERIVED_FROM):
+        if NOD_DERIVED_FROM in self.raw_content:
+            self.parent_type = self.raw_content[NOD_DERIVED_FROM]
+#            if db.DATA_TYPES.has_key(self.parent_type):
+            if self.parent_type in db.DATA_TYPES:
+                self.parent = db.DATA_TYPES[self.parent_type]
+                self.parent._parse_content(db)
+                self.type = self.parent.type
+                self.properties = copy.deepcopy(self.parent.properties)
+
+            elif self.parent_type in BUILT_IN_TYPES:
+                self.type = self.parent_type
+            else:
+                self.type = None
+                logging.warning( 'Unrecognized data type: '+ self.parent_type)
+        else:
+            self.type = TYP_MAP
+            
+#        if self.raw_content.has_key(NOD_PROPERTIES):
+        if NOD_PROPERTIES in self.raw_content:
+            prop_sec = self.raw_content[NOD_PROPERTIES]
+            for prop_name in prop_sec.keys():
+                from toscalib.types.property import PropertyDefinition
+                self.properties[prop_name] = PropertyDefinition(prop_name, prop_sec[prop_name])
+                self.properties[prop_name]._parse_content(db)
+         
+#        if self.raw_content.has_key(PROP_CONSTRAINT):
+        if PROP_CONSTRAINT in self.raw_content:
+            self.constraints = PropertyConstraints(self.raw_content[PROP_CONSTRAINT])
+            self.constraints._parse_content()
+        else:
+            self.constraints = None
+        
+        self.entry._parse_content(db)        
+        
+        self.parsed = True
+        pass
+    
+    def _customozed_format_value(self, value):
+        if self.type == TYP_INT:
+            if _is_integer(value):
+                return int(value)
+            else:
+                return None
+        if self.type == TYP_FLT:
+            if _is_float(value):
+                return float(value)
+            else:
+                return None
+        if self.type == TYP_BOOL:
+            if _is_true(value):
+                return True
+            else:
+                return False
+        elif self.type == TYP_STR:
+            return value
+        elif self.type == TYP_LIST:
+            return self._parse_string_to_list(value)
+        elif self.type == TYP_MAP:
+            return self._parse_string_to_map(value, self.properties)
+               
+        else:
+        #TODO add support for version, scalar-unit
+            return value
+
+    
+    def _format_value(self, value):
+        if self.built_in is True:
+            if self.type == TYP_INT:
+                if _is_integer(value):
+                    return int(value)
+                else:
+                    return None
+            if self.type == TYP_BOOL:
+                if _is_true(value):
+                    return True
+                else:
+                    return False
+            elif self.type == TYP_STR:
+                return str(value)
+            elif self.type == TYP_LIST:
+                return self._parse_string_to_list(value)
+            elif self.type == TYP_MAP:
+                return self._parse_string_to_map(value)
+            elif self.type == TYP_ANY:
+                if type(value) is int:
+                    self.type = TYP_INT
+                    return value
+                if type(value) is bool:
+                    self.type = TYP_BOOL
+                    return value
+                if type(value) is list:
+                    self.type = TYP_LIST
+                    self.entry = EntrySchema(TYP_ANY)
+                    self.entry._parse_content(None)
+                    return self._parse_string_to_list(value)
+                if type(value) is dict:
+                    self.type = TYP_MAP
+                    self.entry = EntrySchema(TYP_ANY)
+                    self.entry._parse_content(None)
+                    return self._parse_string_to_map(value)        
+                self.type = TYP_STR
+                return str(value)
+        
+            else:
+            #TODO add support for version, scalar-unit
+                return value
+        else:
+            return self._customozed_format_value(value)  
+    
+    def _update_prefix(self, prefix, value):
+        if self.type == TYP_LIST:
+            for value_item in value:
+                value_item._update_prefix(prefix)
+        elif self.type == TYP_MAP:
+            for value_item in iter(value.values()):
+                value_item._update_prefix(prefix)
+        else:
+            return
+    
+    def _update_function_reference(self, temp, value, self_node = None, self_item= None):
+        if self.type == TYP_LIST:
+            for value_item in value:
+                value_item._update_function_reference(temp, self_node, self_item)
+        elif self.type == TYP_MAP:
+            for value_item in iter(value.values()):
+                value_item._update_function_reference(temp, self_node, self_item)
+        else:
+            return
+        
+    def _get_value(self, value, tags=''):
+        from toscalib.templates.value import VALID_VALUE, FUNCTION, NULL
+        if self.type == TYP_LIST:
+            out_str = []
+            real_value = VALID_VALUE
+            for value_item in value:
+                out_item, real_item = value_item._get_value(tags)
+                if real_item is NULL:
+                    continue
+
+                out_str.append(out_item)
+                if real_item is FUNCTION:
+                    real_value = real_item
+            return out_str, real_value
+        elif self.type == TYP_MAP:
+            out_str = {}
+            real_value = VALID_VALUE
+            for value_key in value.keys():
+                temp_out, real_item = value[value_key]._get_value(tags)
+                if real_item is NULL:
+                    continue
+                
+                out_str[value_key] = temp_out
+                if real_item is FUNCTION:
+                    real_value = real_item
+            return out_str, real_value
+        else:
+            return value, VALID_VALUE
+            
+    def _parse_string_to_list(self, value):
+        try: 
+            list_value = ast.literal_eval(str(value))
+            if type(list_value) is list:
+                out_list = []
+                for list_item in list_value:
+                    from toscalib.templates.value import Value
+                    out_list.append(Value(self.entry.type_obj, list_item))
+                return out_list
+            else:
+                logging.debug( 'List formatted string required for list type: ')
+                logging.debug('Value is 1: '+ value)
+                return None
+        except ValueError:
+            logging.error( 'List formatted string required for list type: ')
+            logging.error( 'Value is 2: '+ value)
+            return None
+     
+    def _parse_string_to_map(self, value, property_set = None):
+        try: 
+            map_value = ast.literal_eval(str(value))
+            if type(map_value) is dict:
+                out_map = {}
+                from toscalib.templates.value import Value
+
+                if property_set is None: 
+                    for key_item in map_value.keys():
+                        out_map[key_item] = Value(self.entry.type_obj, map_value[key_item])
+                    return out_map
+                else:
+                    for key_item in property_set.keys():
+                        if key_item in map_value.keys():
+                            out_map[key_item] = Value(property_set[key_item].type_obj, map_value[key_item])
+                    return out_map
+            else:
+                logging.debug( 'Map formatted string required for map type: ')
+                logging.debug( 'Value is 1: '+ value)
+                return None
+        except ValueError:
+            logging.error( 'Map formatted string required for map type: ')
+            logging.error( 'Value is 2: '+ value)
+            return None  
+        
+    def _create_rawcontent(self):
+        self.raw_content= {}
+        if self.parent_type is not None:
+            self.raw_content[YMO_NOD_DERIVED_FROM] = self.parent_type
+        prop_sec = {}
+        for prop_key in self.properties.keys():
+            if self.properties[prop_key].raw_content is  None:
+                self.properties[prop_key]._create_rawcontent()
+            prop_sec[prop_key] = self.properties[prop_key].raw_content
+        if len(prop_sec) > 0:
+            self.raw_content[YMO_NOD_PROPERTIES] = prop_sec    
diff --git a/app/toscalib/types/data.pyc b/app/toscalib/types/data.pyc
new file mode 100644
index 0000000..fd1388a
--- /dev/null
+++ b/app/toscalib/types/data.pyc
diff --git a/app/toscalib/types/entry_schema.py b/app/toscalib/types/entry_schema.py
new file mode 100644
index 0000000..6553875
--- /dev/null
+++ b/app/toscalib/types/entry_schema.py
@@ -0,0 +1,68 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+from toscalib.templates.constant import *
+from toscalib.types.constraints import PropertyConstraints
+import logging
+
+class EntrySchema(object):
+    def __init__(self, content):
+        self.type = None
+        self.type_obj = None
+        self.constraints = None
+        self.raw_content = content
+        self.parsed = False
+    
+    def _parse_content(self, db):
+        if self.parsed is True:
+            return
+        
+        if self.raw_content is None:
+            logging.warning( 'Construct None entry_schema section')
+            self.parsed = True
+            return
+        
+        if type(self.raw_content) is str:
+            self.type = self.raw_content
+            from toscalib.types.data import DataType
+            if self.type in DataType._built_in_types():
+                self.type_obj = DataType(self.type)
+#            elif db is None or db.DATA_TYPES.has_key(self.type) is False:
+            elif db is None or self.type not in db.DATA_TYPES:
+                logging.warning( 'Data type: '+ self.type+ ' not defined or imported!')
+                self.type_obj = None
+            else:
+                self.type_obj = db.DATA_TYPES[self.type]
+                self.type_obj._parse_content(db)
+            self.parsed = True
+            return
+            
+#        if self.raw_content.has_key(PROP_TYPE):
+        if PROP_TYPE in self.raw_content:
+            self.type = self.raw_content[PROP_TYPE]
+            from toscalib.types.data import DataType
+            if self.type in DataType._built_in_types():
+                self.type_obj = DataType(self.type)
+#            elif db is None or db.DATA_TYPES.has_key(self.type) is False:
+            elif db is None or self.type not in db.DATA_TYPES:
+                logging.warning( 'Data type: '+ self.type+ ' not defined or imported!')
+                self.type_obj = None
+            else:
+                self.type_obj = db.DATA_TYPES[self.type]
+                self.type_obj._parse_content(db)
+        
+#        if self.raw_content.has_key(PROP_CONSTRAINT):
+        if PROP_CONSTRAINT in self.raw_content:
+            self.constraints = PropertyConstraints(self.raw_content[PROP_CONSTRAINT])
+            self.constraints._parse_content()
+            
+        self.parsed = True
+        return
+    
+    def _format_value (self, value):
+        if self.type_obj is not None:
+            return self.type_obj._format_value(value)
+        else:
+            logging.warning( 'Invalid entry_schema type')
+            return value
+    
+\ No newline at end of file
diff --git a/app/toscalib/types/entry_schema.pyc b/app/toscalib/types/entry_schema.pyc
new file mode 100644
index 0000000..b9558f4
--- /dev/null
+++ b/app/toscalib/types/entry_schema.pyc
diff --git a/app/toscalib/types/interface.py b/app/toscalib/types/interface.py
new file mode 100644
index 0000000..7b1e6cf
--- /dev/null
+++ b/app/toscalib/types/interface.py
@@ -0,0 +1,37 @@
+from toscalib.types.property import PropertyDefinition
+from toscalib.types.operation import OperationDefinition
+
+
+class InterfaceDefinition(object):
+    def __init__(self, name, content = None):
+        self.name = name
+        self.raw_content = content
+        self.parsed = False
+        self.operations = {}
+        self.type = None
+        self.inputs = {}
+        
+    def _parse_content(self, db):
+        if self.parsed is True:
+            return
+        
+        if self.raw_content is None:
+            self.parsed = True
+            return
+
+        for key_name in self.raw_content.keys():         
+            if key_name == 'type':
+                self.type = self.raw_content[key_name]
+                continue
+            if key_name == 'inputs':
+                input_sec = self.raw_content['inputs']
+                for input_item in input_sec.keys():
+                    self.inputs[input_item] = PropertyDefinition(input_item, input_sec[input_item])
+                    self.inputs[input_item]._parse_content(db)
+                continue
+            self.operations[key_name] = OperationDefinition(self.name, key_name, self.raw_content[key_name])
+            self.operations[key_name]._parse_content(db)
+            
+        self.parsed = True
+        return
+    
diff --git a/app/toscalib/types/interface.pyc b/app/toscalib/types/interface.pyc
new file mode 100644
index 0000000..8766be3
--- /dev/null
+++ b/app/toscalib/types/interface.pyc
diff --git a/app/toscalib/types/node.py b/app/toscalib/types/node.py
new file mode 100644
index 0000000..249f713
--- /dev/null
+++ b/app/toscalib/types/node.py
@@ -0,0 +1,174 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+from toscalib.templates.constant import *
+from toscalib.types.property import PropertyDefinition
+from toscalib.types.requirement import RequirementDefinition
+from toscalib.types.capability import CapabilityDefinition
+import copy, logging
+from toscalib.types.interface import InterfaceDefinition
+
+            
+class NodeType(object):
+    def __init__(self, name, content):
+        if name is None or content is None:
+            return None
+        self.name = name
+        self.parent_type = None
+        self.parent = None
+        self.id = PropertyDefinition('id')
+        self.mapping_template = None
+        self.raw_content = content
+        self.used = False
+        self.parsed = False
+        self.properties = {}
+        self.attributes = {}
+        self.capabilities = {}
+        self.requirements = []
+        self.interfaces = {}
+        
+#         self._parse_content(content)
+        
+    def _parse_content(self, db):
+        if self.parsed is True:
+            return
+        
+        self.id._parse_content(db)
+        
+        if self.raw_content is None:
+            self.parsed = True
+            logging.warning( 'Parsing Node '+ self.name+ ', content is None')
+            return
+        
+#        if self.raw_content.has_key(NOD_DERIVED_FROM):
+        if NOD_DERIVED_FROM in self.raw_content:
+            self.parent_type = self.raw_content[NOD_DERIVED_FROM]
+#            if db.NODE_TYPES.has_key(self.parent_type):
+            if self.parent_type in db.NODE_TYPES:
+                self.parent = db.NODE_TYPES[self.parent_type]
+                self.parent._parse_content(db)
+            elif self.parent_type != 'tosca.nodes.Root':
+                logging.warning( 'Node '+ self.parent_type+ ' not imported but used!')
+        else:
+            logging.warning( 'Node type '+ self.name+ ' has no parent type to derive from')
+            
+        if self.parent is not None:
+            self.properties = copy.deepcopy(self.parent.properties)
+            self.attributes = copy.deepcopy(self.parent.attributes)
+
+#        if self.raw_content.has_key(NOD_PROPERTIES):
+        if NOD_PROPERTIES in self.raw_content:
+            prop_sec = self.raw_content[NOD_PROPERTIES]
+            for prop_name in prop_sec.keys():
+#                if self.properties.has_key(prop_name):
+                if prop_name in self.properties:
+#                     self.properties[prop_name].update(PropertyDefinition(prop_name, prop_sec[prop_name]))
+#                 else:
+                    logging.debug( 'Property name '+ prop_name+ ' has been defined in parent type, overwritten here!')
+                self.properties[prop_name] = PropertyDefinition(prop_name, prop_sec[prop_name])
+                self.properties[prop_name]._parse_content(db)
+
+#        if self.raw_content.has_key(NOD_ATTRIBUTES):
+        if NOD_ATTRIBUTES in self.raw_content:
+            attr_sec = self.raw_content[NOD_ATTRIBUTES]
+            for attr_name in attr_sec.keys():
+#                if self.attributes.has_key(attr_name):
+                if attr_name in self.attributes:
+#                     self.properties[prop_name].update(PropertyDefinition(prop_name, prop_sec[prop_name]))
+#                 else:
+                    logging.debug( 'Attribute name '+ attr_name+ ' has been defined in parent type, overwritten here!')
+                self.attributes[attr_name] = PropertyDefinition(attr_name, attr_sec[attr_name])
+                self.attributes[attr_name]._parse_content(db)
+                         
+        if self.parent is not None:
+            self.requirements = copy.deepcopy(self.parent.requirements)
+        
+#        if self.raw_content.has_key(NOD_REQUIREMENTS):
+        if NOD_REQUIREMENTS in self.raw_content:
+            req_sec = self.raw_content[NOD_REQUIREMENTS]
+            for req in req_sec:
+                req_item = RequirementDefinition(req)
+                req_item._parse_content(db)
+                if req_item.name is not None:
+                    self.requirements.append(req_item)
+         
+        if self.parent is not None:
+            self.capabilities = copy.deepcopy(self.parent.capabilities)
+        
+#        if self.raw_content.has_key(NOD_CAPABILITIES):
+        if NOD_CAPABILITIES in self.raw_content:
+            cap_sec = self.raw_content[NOD_CAPABILITIES]
+            for cap_name in cap_sec.keys():
+#                if self.capabilities.has_key(cap_name):
+                if cap_name in self.capabilities:
+                    logging.warning( 'Capability name '+ cap_name+ ' has been defined in parent type, overwritten here!')
+                self.capabilities[cap_name] = CapabilityDefinition(cap_name, cap_sec[cap_name])
+                self.capabilities[cap_name]._parse_content(db)
+     
+        self.parsed = True
+        
+        if self.parent is not None:
+            self.interfaces = copy.deepcopy(self.parent.interfaces)
+            
+#        if self.raw_content.has_key(NOD_INTERFACES):
+        if NOD_INTERFACES in self.raw_content:
+            interface_sec = self.raw_content[NOD_INTERFACES]
+            for interface_name in interface_sec.keys():
+#                if self.interfaces.has_key(interface_name):
+                if interface_name in self.interfaces:
+                    logging.warning( 'Interface name'+ interface_name+ 'has been definend in parenty type, overwritten here')
+                self.interfaces[interface_name] = InterfaceDefinition(interface_name, interface_sec[interface_name])
+                self.interfaces[interface_name]._parse_content(db)
+        
+    def _verify_req_type(self, req_type):
+        if self.name == req_type:
+            return True
+        if self.parent is not None:
+            return self.parent._verify_req_type(req_type)
+        else:
+            logging.warning( 'Type '+ self.parent_type+ ' is not imported or defined')
+            return self.parent_type == req_type
+                
+                
+    def _create_rawcontent(self):
+        self.raw_content= {}
+        if self.parent_type != None:
+            self.raw_content[YMO_NOD_DERIVED_FROM] = self.parent_type
+        else:
+            self.raw_content[YMO_NOD_DERIVED_FROM] = 'tosca.nodes.Root'
+        prop_sec = {}
+        for prop_key in self.properties.keys():
+            if self.properties[prop_key].raw_content is  None:
+                self.properties[prop_key]._create_rawcontent()
+            prop_sec[prop_key] = self.properties[prop_key].raw_content
+        if len(prop_sec) > 0:
+            self.raw_content[YMO_NOD_PROPERTIES] = prop_sec    
+        
+        attr_sec = {}
+        for prop_key in self.attributes.keys():
+            if self.attributes[prop_key].raw_content is  None:
+                self.attributes[prop_key]._create_rawcontent()
+            attr_sec[prop_key] = self.attributes[prop_key].raw_content   
+        if len(attr_sec)>0 :
+            self.raw_content[YMO_NOD_ATTRIBUTES] = attr_sec    
+            
+        cap_sec = {}
+        for cap_key in self.capabilities.keys():
+            cap_sec[cap_key] = self.capabilities[cap_key].raw_content   
+        if len(cap_sec)>0 :
+            self.raw_content[YMO_NOD_CAPABILITIES] = cap_sec
+    
+        req_sec = []
+        for req in self.requirements:
+            req_sec.append(req.raw_content)
+        if len(req_sec)>0 :
+            self.raw_content[YMO_NOD_REQUIREMENTS] = req_sec
+            
+        if len(self.interfaces) > 0:
+            int_sec = {}
+            for int_name in self.interfaces.keys():
+                int_sec[int_name] = self.interfaces[int_name].raw_content
+            self.raw_content[YMO_NOD_INTERFACES] = int_sec
+        
+            
+\ No newline at end of file
diff --git a/app/toscalib/types/node.pyc b/app/toscalib/types/node.pyc
new file mode 100644
index 0000000..a6ce858
--- /dev/null
+++ b/app/toscalib/types/node.pyc
diff --git a/app/toscalib/types/operation.py b/app/toscalib/types/operation.py
new file mode 100644
index 0000000..a7f38c7
--- /dev/null
+++ b/app/toscalib/types/operation.py
@@ -0,0 +1,36 @@
+from toscalib.types.property import PropertyDefinition
+
+
+class OperationDefinition(object):
+    def __init__(self, interface_name, name, content = None):
+        self.name = name
+        self.interface = interface_name
+        self.raw_content = content
+        self.parsed = False
+        self.implementation = None
+        self.inputs = {}
+        
+    def _parse_content(self, db):
+        if self.parsed is True:
+            return
+        
+        if self.raw_content is None:
+            self.parsed = True
+            return
+        
+        self.parsed = True
+
+        if type(self.raw_content) is not dict:
+            return
+            
+        for key_name in self.raw_content.keys():         
+            if key_name == 'implementation':
+                self.implementation = self.raw_content[key_name]
+            if key_name == 'inputs':
+                input_sec = self.raw_content['inputs']
+                for input_item in input_sec.keys():
+                    self.inputs[input_item] = PropertyDefinition(input_item, input_sec[input_item])
+                    self.inputs[input_item]._parse_content(db)
+            
+        return
+    
diff --git a/app/toscalib/types/operation.pyc b/app/toscalib/types/operation.pyc
new file mode 100644
index 0000000..ec25aae
--- /dev/null
+++ b/app/toscalib/types/operation.pyc
diff --git a/app/toscalib/types/property.py b/app/toscalib/types/property.py
new file mode 100644
index 0000000..7f794dd
--- /dev/null
+++ b/app/toscalib/types/property.py
@@ -0,0 +1,92 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+from toscalib.types.constraints import PropertyConstraints
+from toscalib.types.entry_schema import EntrySchema
+from toscalib.types.data import DataType, TYP_STR, TYP_ANY, TYP_MAP
+from toscalib.templates.constant import *
+import logging
+
+class PropertyDefinition(object):
+    def __init__(self, name, content = None):
+        self.name = name
+        self.raw_content = content
+        self.parsed = False
+        self.type = None
+        self.type_obj = None
+        
+        if content is None:
+            self.required = True
+            self.type = TYP_ANY
+            self.type_obj = DataType(self.type)
+            self.default = self.name
+            self.parsed = True
+        
+    def _parse_content(self, db):
+        
+        if self.parsed is True:
+            return
+        
+        content = self.raw_content
+        
+        if content is None:
+            self.required = True
+            self.type = TYP_ANY
+            self.type_obj = DataType(self.type)
+            self.default = self.name
+            self.parsed = True
+            return
+        
+#        if content.has_key(PROP_TYPE):
+        if PROP_TYPE in content:
+            self.type = content[PROP_TYPE]
+            if self.type in DataType._built_in_types():
+                self.type_obj = DataType(self.type)
+                self.type_obj._parse_content(db)
+#            elif db.DATA_TYPES.has_key(self.type) is False:
+            elif self.type in db.DATA_TYPES is False:
+                logging.warning( 'Data type: '+ self.type+ ' not defined or imported!')
+                self.type_obj = None
+            else:
+                self.type_obj = db.DATA_TYPES[self.type]
+                self.type_obj._parse_content(db)
+
+        self.required = True
+#        if content.has_key(PROP_REQUIRED):
+        if PROP_REQUIRED in content:
+            if content[PROP_REQUIRED] not in TRUE_VALUES:
+                self.required = False
+            
+#        if content.has_key(PROP_DEFAULT):
+        if PROP_DEFAULT in content:
+            self.default = content[PROP_DEFAULT]
+        else:
+            self.default = None
+            
+#        if content.has_key(PROP_ENTRY):
+        if PROP_ENTRY in content:
+            self.type_obj.entry = EntrySchema(content[PROP_ENTRY])
+            self.type_obj.entry._parse_content(db)
+            
+#        if content.has_key(PROP_CONSTRAINT):
+        if PROP_CONSTRAINT in content:
+            self.constraints = PropertyConstraints(content[PROP_CONSTRAINT])
+            self.constraints._parse_content()
+        else:
+            self.contraints = None
+            
+        self.parsed = True
+
+    def _create_rawcontent(self):
+        self.raw_content = {}
+        self.raw_content[YMO_PROP_TYPE] = self.type
+        if self.type == TYP_ANY:
+            self.raw_content[YMO_PROP_TYPE] = TYP_STR
+        if self.default is not None and self.default is not self.name:
+            self.raw_content[YMO_PROP_DEFAULT] = self.default
+        if self.required is False:
+            self.raw_content[YMO_PROP_REQUIRED] = self.required
+#add more about constraints        
+        
+  
+  
+\ No newline at end of file
diff --git a/app/toscalib/types/property.pyc b/app/toscalib/types/property.pyc
new file mode 100644
index 0000000..73008a3
--- /dev/null
+++ b/app/toscalib/types/property.pyc
diff --git a/app/toscalib/types/relationship.py b/app/toscalib/types/relationship.py
new file mode 100644
index 0000000..b2408b0
--- /dev/null
+++ b/app/toscalib/types/relationship.py
@@ -0,0 +1,13 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+class RelationshipType:
+    def __init__(self, name, content):
+        if name is None or content is None:
+            return None
+        self.name = name
+        self.raw_content = content
+        
+    def _parse_content(self, db):
+        pass
+\ No newline at end of file
diff --git a/app/toscalib/types/relationship.pyc b/app/toscalib/types/relationship.pyc
new file mode 100644
index 0000000..f106cbe
--- /dev/null
+++ b/app/toscalib/types/relationship.pyc
diff --git a/app/toscalib/types/requirement.py b/app/toscalib/types/requirement.py
new file mode 100644
index 0000000..9cc9f6e
--- /dev/null
+++ b/app/toscalib/types/requirement.py
@@ -0,0 +1,63 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+from toscalib.templates.constant import *
+import logging
+
+class RequirementDefinition(object):
+    def __init__(self, content):
+        self.name =  None
+        self.parsed = False
+        self.raw_content = content
+        self.req_type = None
+        self.req_capability = None
+        self.relationship = None
+        self.occurrence = [1,1]
+        
+    def _parse_content(self, db):
+        if self.parsed is True:
+            return
+        
+        content = self.raw_content
+    
+        if content is None:
+            logging.warning( 'Construct None requirement section')
+            self.parsed = True
+            return
+        if len(content.keys()) != 1:
+            logging.warning( 'Requirement section does not have exact one element: ' + len(content.keys()))
+            return
+        self.name = list(content.keys())[0]
+        requirement_def = content[self.name]
+        if type(requirement_def) is not dict:
+            logging.warning( 'Cannot parse requirement definition: '+ self.name)
+            return
+        
+#        if requirement_def.has_key(REQ_NODE):
+        if REQ_NODE in requirement_def:
+            self.req_type = requirement_def[REQ_NODE]
+        else:
+            self.req_type = None
+#        if requirement_def.has_key(REQ_CAPABILITY):
+        if REQ_CAPABILITY in requirement_def:
+            self.req_capability = requirement_def[REQ_CAPABILITY]
+        else:
+            self.req_capability = None
+#        if requirement_def.has_key(REQ_RELATIONSHIP):
+        if REQ_RELATIONSHIP in requirement_def:
+            self.relationship = requirement_def[REQ_RELATIONSHIP]
+        else:
+            self.relationship = None
+#        if requirement_def.has_key(REQ_OCCURRENCE):
+        if REQ_OCCURRENCE in requirement_def:
+            self.occurrence = requirement_def[REQ_OCCURRENCE]
+            if type(self.occurrence) is not list:
+                logging.warning( 'Requirement occurrence expects a list of two numbers but provided with: '+ self.occurrence)
+        
+        self.parsed = True
+        
+        
+            
+            
+            
+\ No newline at end of file
diff --git a/app/toscalib/types/requirement.pyc b/app/toscalib/types/requirement.pyc
new file mode 100644
index 0000000..6a61138
--- /dev/null
+++ b/app/toscalib/types/requirement.pyc
diff --git a/app/toscalib/utils/__init__.py b/app/toscalib/utils/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/app/toscalib/utils/__init__.py
diff --git a/app/toscalib/utils/__init__.pyc b/app/toscalib/utils/__init__.pyc
new file mode 100644
index 0000000..b047006
--- /dev/null
+++ b/app/toscalib/utils/__init__.pyc
diff --git a/app/toscalib/utils/tosca_export.py b/app/toscalib/utils/tosca_export.py
new file mode 100644
index 0000000..c4399ef
--- /dev/null
+++ b/app/toscalib/utils/tosca_export.py
@@ -0,0 +1,40 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+import yaml
+import re
+from toscalib.templates.constant import *
+
+def _yaml_export(filename, content):    
+    out_str = yaml.safe_dump(content,  default_flow_style=False, width=float("inf"))
+    out_str = re.sub(YMO_PREFIX, '', out_str)
+    if filename == 'WEB':
+        return out_str
+    with open(filename, 'w') as outfile:
+        outfile.write(out_str)
+    return out_str
+
+def _heat_export(filename, content):
+    heat_ver = YMO_PREFIX + 'heat_template_version'
+    heat_content = content[YMO_TOPOLOGY]
+    if heat_content is None:
+        heat_content = {}
+    heat_content[heat_ver] = '2013-05-23'
+#    if heat_content.has_key(YMO_TOPO_OUTPUTS):
+    if YMO_TOPO_OUTPUTS in heat_content:
+        heat_content.pop(YMO_TOPO_OUTPUTS)
+        
+    out_str = yaml.dump(heat_content,  default_flow_style=False)
+    out_str = re.sub(YMO_TOPO_INPUTS, YMO_PREFIX+'parameters', out_str)
+    out_str = re.sub(YMO_TOPO_NODE_TEMPLATES, YMO_PREFIX+'resources', out_str)
+    
+    out_str = re.sub('get_input', 'get_param', out_str)
+    out_str = re.sub('get_attribute', 'get_attr', out_str)
+    out_str = re.sub('get_id', 'get_resource', out_str)
+    out_str = re.sub('get_property', 'get_attr', out_str)
+    out_str = re.sub('type: integer', 'type: number', out_str)
+        
+    out_str = re.sub(YMO_PREFIX, '', out_str)
+    with open(filename, 'w') as outfile:
+        outfile.write(out_str)
diff --git a/app/toscalib/utils/tosca_export.pyc b/app/toscalib/utils/tosca_export.pyc
new file mode 100644
index 0000000..2552481
--- /dev/null
+++ b/app/toscalib/utils/tosca_export.pyc
diff --git a/app/toscalib/utils/tosca_heat.py b/app/toscalib/utils/tosca_heat.py
new file mode 100644
index 0000000..ca5672c
--- /dev/null
+++ b/app/toscalib/utils/tosca_heat.py
@@ -0,0 +1,6 @@
+
+def _type_validate(type):
+    pass
+
+def _type_translate(type):
+    pass
+\ No newline at end of file
diff --git a/app/toscalib/utils/tosca_heat.pyc b/app/toscalib/utils/tosca_heat.pyc
new file mode 100644
index 0000000..a69a761
--- /dev/null
+++ b/app/toscalib/utils/tosca_heat.pyc
diff --git a/app/toscalib/utils/tosca_import.py b/app/toscalib/utils/tosca_import.py
new file mode 100644
index 0000000..d0e2f03
--- /dev/null
+++ b/app/toscalib/utils/tosca_import.py
@@ -0,0 +1,296 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+import os
+from toscalib.utils.yamlparser import load_yaml, simple_parse
+from toscalib.templates.database import ToscaDB
+from toscalib.types.node import NodeType
+from toscalib.types.data import DataType
+from toscalib.types.capability import CapabilityType
+from toscalib.types.relationship import RelationshipType
+from toscalib.templates.constant import *
+from toscalib.templates.topology import ToscaTopology
+from macpath import dirname
+import logging
+
+
+# _TRUE_VALUES = ('True', 'true', '1', 'yes')
+
+class import_context(object):
+    def __init__(self):
+        self.curr_path = os.getcwd()
+        self.curr_file_name = ''
+        self.metadata = None
+        self.temp_name = None
+        self.extra_imports = []
+        
+def _dir_import(files_imported, dir_name, db=None, ctx=None):
+    if db is None:
+        db = ToscaDB()
+    
+    if os.path.isdir(dir_name) is False:
+        logging.warning( 'Dir: '+ dir_name+ ' not exist! Loading failed!')
+        return db
+    
+    for f in os.listdir(dir_name):
+        filename = os.path.join(dir_name, f)
+        if os.path.isfile(filename):
+            try:
+                db = _file_import(files_imported, filename, db)
+            except ValueError:
+                logging.error( 'Fail to import file: '+ filename)
+                continue
+        if os.path.isdir(filename):
+            try: 
+                db = _dir_import(files_imported, filename, db)
+            except ValueError:
+                logging.error( 'Fail to import dir: '+ filename)
+                continue
+    
+    return db  
+ 
+     
+    
+def _file_import(files_imported, filename, db=None, ctx=None):
+    logging.debug( 'Start to import file: '+ filename)
+
+    if db is None:
+        db = ToscaDB()
+        
+    if ctx is None:
+        orig_import = True
+        ctx = import_context()
+    else:
+        orig_import = False
+            
+    if filename == os.path.abspath(filename):
+        full_file_path = filename
+    else:
+        full_file_path = os.path.abspath(os.path.join(ctx.curr_path, filename))
+        
+    if os.path.isfile(full_file_path) == False:
+        logging.debug( 'File: ' + filename + ' not exist! Import as extra import!')
+        ctx.extra_imports.append({filename:filename})
+        return db
+    
+    if full_file_path in files_imported:
+        logging.debug( 'File: ' + filename + ' has been imported!')
+        return db
+    
+    ctx.curr_path = os.path.dirname(full_file_path)
+    ctx.curr_file_name = os.path.basename(full_file_path)
+    parser = load_yaml(full_file_path)
+
+    ctx.extra_imports = []
+    
+#    if parser.has_key(IMPORT):
+    if IMPORT in parser:
+        db = _parse_import(files_imported, parser[IMPORT], db, ctx)
+#    if parser.has_key(METADATA):
+    if METADATA in parser:
+        ctx.metadata = parser[METADATA]
+#    if parser.has_key(DATA_TYPE):
+    if DATA_TYPE in parser:
+        db = _parse_data_type(parser[DATA_TYPE], db, ctx)
+#    if parser.has_key(NODE_TYPE):
+    if NODE_TYPE in parser:
+        db = _parse_node_type(parser[NODE_TYPE], db, ctx)
+#    if parser.has_key(TOPOLOGY):
+    if TOPOLOGY in parser:
+        db = _parse_topology_template(parser[TOPOLOGY], db, ctx)
+#    if parser.has_key(CAPABILITY_TYPE):
+    if CAPABILITY_TYPE in parser:
+        db = _parse_capability_type(parser[CAPABILITY_TYPE], db, ctx)
+#    if parser.has_key(RELATIONSHIP_TYPE):
+    if RELATIONSHIP_TYPE in parser:
+        db = _parse_relationship_type(parser[RELATIONSHIP_TYPE], db, ctx)
+    
+    if orig_import:
+        db._parse_objects()
+    
+    files_imported.append(full_file_path)
+    logging.debug( 'File '+ filename+ ' imported!')
+    return db
+
+def _single_template_file_import(filename, db=None, ctx=None):
+    logging.debug( 'Start to import file: '+ filename)
+
+    if db is None:
+        db = ToscaDB()
+        
+    if ctx is None:
+        ctx = import_context()
+            
+    if filename == os.path.abspath(filename):
+        full_file_path = filename
+    else:
+        full_file_path = os.path.abspath(os.path.join(ctx.curr_path, filename))
+        
+    if os.path.isfile(full_file_path) == False:
+        logging.warning( 'File: ' +filename + ' not exist! Import failed!')
+        return db
+    
+    
+    ctx.curr_path = os.path.dirname(full_file_path)
+    ctx.curr_file_name = os.path.basename(full_file_path)
+    parser = load_yaml(full_file_path)
+    
+#     if parser.has_key(IMPORT):
+#         db = _parse_import(files_imported, parser[IMPORT], db, ctx)
+    ctx.extra_imports = []
+#    if parser.has_key(IMPORT):
+    if IMPORT in parser:
+        db = _parse_import([], parser[IMPORT], db, ctx)
+#    if parser.has_key(METADATA):
+    if METADATA in parser:
+        ctx.metadata = parser[METADATA]
+#    if parser.has_key(DATA_TYPE):
+    if DATA_TYPE in parser:
+        db = _parse_data_type(parser[DATA_TYPE], db, ctx)
+#    if parser.has_key(NODE_TYPE):
+    if NODE_TYPE in parser:
+        db = _parse_node_type(parser[NODE_TYPE], db, ctx)
+#    if parser.has_key(TOPOLOGY):
+    if TOPOLOGY in parser:
+        db = _parse_topology_template(parser[TOPOLOGY], db, ctx)
+#    if parser.has_key(CAPABILITY_TYPE):
+    if CAPABILITY_TYPE in parser:
+        db = _parse_capability_type(parser[CAPABILITY_TYPE], db, ctx)
+#    if parser.has_key(RELATIONSHIP_TYPE):
+    if RELATIONSHIP_TYPE in parser:
+        db = _parse_relationship_type(parser[RELATIONSHIP_TYPE], db, ctx)
+    
+    db._parse_objects()
+    
+    logging.debug( 'File '+ filename+ ' imported!')
+    return db
+
+def _yaml_str_import(yml_str, db=None, ctx=None):
+    parser = simple_parse(yml_str)
+    
+    if ctx is None:
+        ctx = import_context()
+
+    ctx.extra_imports = []
+    
+#    if parser.has_key(IMPORT):
+    if IMPORT in parser:
+        db = _parse_import([], parser[IMPORT], db, ctx)
+#    if parser.has_key(METADATA):
+    if METADATA in parser:
+        ctx.metadata = parser[METADATA]
+#    if parser.has_key(DATA_TYPE):
+    if DATA_TYPE in parser:
+        db = _parse_data_type(parser[DATA_TYPE], db, ctx)
+#    if parser.has_key(NODE_TYPE):
+    if NODE_TYPE in parser:
+        db = _parse_node_type(parser[NODE_TYPE], db, ctx)
+#    if parser.has_key(TOPOLOGY):
+    if TOPOLOGY in parser:
+        db = _parse_topology_template(parser[TOPOLOGY], db, ctx)
+#    if parser.has_key(CAPABILITY_TYPE):
+    if CAPABILITY_TYPE in parser:
+        db = _parse_capability_type(parser[CAPABILITY_TYPE], db, ctx)
+#    if parser.has_key(RELATIONSHIP_TYPE):
+    if RELATIONSHIP_TYPE in parser:
+        db = _parse_relationship_type(parser[RELATIONSHIP_TYPE], db, ctx)
+    
+    db._parse_objects()
+    
+    return db
+
+def _parse_data_type(data_type_section, db, ctx):
+    if data_type_section is None:
+        return db
+    if db is None: 
+        db = ToscaDB()
+        
+    for data_type_name in data_type_section.keys():
+        db._import_data_type(DataType(data_type_name, data_type_section[data_type_name]))
+    return db
+
+def _parse_node_type(node_type_section, db, ctx):    
+    if node_type_section is None:
+        return db
+    if db is None:
+        db = ToscaDB()
+            
+    for node_type_def_name in node_type_section.keys():
+        db._import_node_type(NodeType(node_type_def_name, node_type_section[node_type_def_name]))
+    return db
+
+def _parse_capability_type(cap_type_section, db, ctx):    
+    if cap_type_section is None:
+        return db
+    if db is None:
+        db = ToscaDB()
+            
+    for cap_type_def_name in cap_type_section.keys():
+        db._import_capability_type(CapabilityType(cap_type_def_name, cap_type_section[cap_type_def_name]))
+    return db
+
+def _parse_relationship_type(rel_type_section, db, ctx):    
+    if rel_type_section is None:
+        return db
+    if db is None:
+        db = ToscaDB()
+            
+    for rel_type_def_name in rel_type_section.keys():
+        db._import_relationship_type(RelationshipType(rel_type_def_name,rel_type_section[rel_type_def_name]))
+    return db
+
+def _parse_topology_template(topology_section, db, ctx):    
+    if topology_section is None:
+        return db
+    if db is None:
+        db = ToscaDB()
+        
+    if ctx.metadata is None or ctx.metadata['template_name'] is None or ctx.metadata['template_name']=='':
+        template_key = ctx.curr_file_name
+    else:
+        template_key = ctx.metadata['template_name']
+        
+    if template_key is None or template_key == '':
+        index = 0
+        while True:
+#            if db.TEMPLATES.has_key('template'+str(index)):
+            if 'template'+str(index) in db.TEMPLATES:
+                index+=1
+                continue
+            break
+        template_key = 'template'+str(index)
+        
+    ctx.temp_name = template_key
+    
+    new_topology = ToscaTopology(template_key, ctx.metadata, topology_section)
+    new_topology.extra_imports = ctx.extra_imports
+    db._import_template(new_topology)
+            
+    return db
+
+def _parse_requirement_name_and_value(content):
+    list_size = len(content.keys())
+    if list_size != 1:
+        logging.warning( 'Requirement section does not have exact one element: '+ list_size)
+        return
+    ck = list(content.keys())[0]
+    return ck, content[ck]        
+        
+def _parse_import(file_imported, import_section, db, ctx):
+    if db is None:
+        db = ToscaDB()
+        
+    if import_section is None:
+        return db
+    
+    for new_file_sec in import_section:
+#        for new_file in new_file_sec.itervalues():
+        for new_file in iter(new_file_sec.values()):
+            curr_path_bk = ctx.curr_path
+            curr_filename_bk = ctx.curr_file_name
+            _file_import(file_imported, new_file, db, ctx)
+            ctx.curr_path = curr_path_bk
+            ctx.curr_file_name = curr_filename_bk
+        
+    return db
diff --git a/app/toscalib/utils/tosca_import.pyc b/app/toscalib/utils/tosca_import.pyc
new file mode 100644
index 0000000..b86dfa7
--- /dev/null
+++ b/app/toscalib/utils/tosca_import.pyc
diff --git a/app/toscalib/utils/tosca_operate.py b/app/toscalib/utils/tosca_operate.py
new file mode 100644
index 0000000..bc67310
--- /dev/null
+++ b/app/toscalib/utils/tosca_operate.py
@@ -0,0 +1,94 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+from toscalib.templates.node import Node
+import copy, logging
+#from __builtin__ import False
+
+def _create_new_node(template, type_name, node_name = None):
+    db = template.db
+#    if db.NODE_TYPES.has_key(type_name) is False:
+    if type_name not in db.NODE_TYPES:
+        new_name = 'unknown_'+ str(template.node_index)
+        template.node_index = template.node_index + 1
+        new_node = Node(template, new_name, None)
+        logging.debug( 'New node: '+ new_name+ ' added')
+        return new_node
+    
+    if node_name is None:
+        new_name = _get_basename(db.NODE_TYPES[type_name].name) + '_' + str(template.node_index)
+        template.node_index = template.node_index + 1
+    else:
+        new_name = node_name
+         
+    new_node = Node(template, new_name, db.NODE_TYPES[type_name])
+
+    template._add_node(new_node)    
+    
+    logging.debug( 'New node: '+ new_name+ ' added')
+    return new_node
+    
+
+def _create_new_template(template, type_name, prefix_name = None):
+    db = template.db
+    if prefix_name is None:
+        prefix = db.TEMPLATES[type_name].name + '_' + str(template.temp_index) + '_'
+        template.temp_index = template.temp_index + 1
+    elif prefix_name == 'NO_PREFIX':
+        prefix = ''
+    else:
+        prefix = prefix_name
+    
+    new_temp = copy.deepcopy(db.TEMPLATES[type_name])
+    new_temp._update_prefix(prefix)
+    template.inputs.update(new_temp.inputs)
+    template.outputs.update(new_temp.outputs)
+    template.node_dict.update(new_temp.node_dict)
+    return template
+
+def _assign_property_value(node, property_name, value):
+#    if node.properties.has_key(property_name) is False:
+    if property_name not in node.properties:
+        logging.warning( 'No property with name '+ property_name+ ' in the node '+ node.name)
+        return False
+    return node.properties[property_name]._assign(value)
+
+def _assign_capability_property_value(node, cap_name, prop_name, value):
+#    if node.capabilities.has_key(cap_name) is False:
+    if cap_name not in node.capabilities:
+        logging.warning( 'No capability with name '+ cap_name+ ' in the node '+ node.name)
+        return False
+    cap_item = node.capabilities[cap_name]
+#    if cap_item.properties.has_key(prop_name) is False:
+    if prop_name not in cap_item.properties:
+        logging.warning( 'No propoerty with name'+ prop_name+ ' in the node '+ node.name+ ' capability '+ cap_name)
+        return False
+    return cap_item.properties[prop_name]._assign(value)
+
+def _assign_requirement_value(node, requirement_name, value):
+
+    requirement_found = False
+    for req in node.requirements:
+        if req.name == requirement_name:
+            requirement_found = req
+            break
+    if requirement_found is False:
+        logging.warning( 'No requirement with name '+ requirement_name+ ' in the node '+ node.name)
+        return False
+    if isinstance(value, Node) is False:
+        logging.warning( 'Node value should be passed to requirement assignment')
+        return False
+    else:
+        if requirement_found._verify_node(value):
+            requirement_found._assign(value)
+        else:
+            logging.warning( 'Invalid requirement fulfillment for node '+ node.name+ '->'+ requirement_name)
+ 
+    
+    return True
+ 
+def _get_basename(name):
+    names = name.split(".")
+    return names[len(names)-1]       
+    
+\ No newline at end of file
diff --git a/app/toscalib/utils/tosca_operate.pyc b/app/toscalib/utils/tosca_operate.pyc
new file mode 100644
index 0000000..4ebd264
--- /dev/null
+++ b/app/toscalib/utils/tosca_operate.pyc
diff --git a/app/toscalib/utils/tosca_print.py b/app/toscalib/utils/tosca_print.py
new file mode 100644
index 0000000..a7205e3
--- /dev/null
+++ b/app/toscalib/utils/tosca_print.py
@@ -0,0 +1,58 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+
+LEVEL_NODE_NAME = 1
+LEVEL_NODE_DETAILS = 2
+LEVEL_NODE_EVERYTHING = 3
+
+def _print_template(template, level=LEVEL_NODE_DETAILS):
+    print_str = ''
+    if template is None: 
+        return print_str
+    print_str += 'Nodes:'+ '\n'
+    for node in iter(template.node_dict.values()):
+        print_str += _print_node(node, level)
+    return print_str
+ 
+def _print_node(node, level):
+    print_str = ''
+    if node is None:
+        return
+    print_str +=  ' '+ node.name + '\n'
+    print_str +=   '    type: '+ node.type+ '\n'
+    if level == LEVEL_NODE_DETAILS:
+        if len(node.properties) > 0:
+            print_str +=   '    properties:' + '\n'
+        for prop in iter(node.properties.values()):
+            if prop.filled:
+                print_str +=   '     '+ prop.name+ ': '+ str(prop.value._get_value()[0])+ '\n'
+            else:
+                print_str +=   '     '+ prop.name+ ': null'+ '\n'
+        if len(node.requirements)> 0:
+            print_str +=   '    requirements:'+ '\n'
+        for req in node.requirements:
+            if req.filled:
+                print_str +=   '     '+ req.name+ ': '+ req.value.name+ '\n'
+            else:
+                print_str +=   '     '+ req.name+ ': null'+ '\n'
+        print_str +=   ''+ '\n'
+    return print_str
+    
+
+def _print_node_types(db):
+    print_str =  'Available node types: '+ '\n'
+    for name in db.NODE_TYPES.keys():
+        print_str +=   name, '\n'
+    return print_str
+
+def _print_templates(db):
+    print_str =   'Available templates: '+ '\n'
+    for name in db.TEMPLATES.keys():
+        print_str +=   name, '\n'
+    return print_str
+
+def _print_node_type(node_type):
+    print_str =   'Node Type Definition: '+ node_type.name+ '\n'
+    print_str +=   node_type.raw_content+ '\n'
+    return print_str
diff --git a/app/toscalib/utils/tosca_print.pyc b/app/toscalib/utils/tosca_print.pyc
new file mode 100644
index 0000000..7c39616
--- /dev/null
+++ b/app/toscalib/utils/tosca_print.pyc
diff --git a/app/toscalib/utils/validateutils.py b/app/toscalib/utils/validateutils.py
new file mode 100644
index 0000000..dca08b1
--- /dev/null
+++ b/app/toscalib/utils/validateutils.py
@@ -0,0 +1,81 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import collections
+import dateutil.parser
+import numbers
+
+import six
+
+#from toscalib.utils.gettextutils import _
+
+
+def str_to_num(value):
+    '''Convert a string representation of a number into a numeric type.'''
+    if isinstance(value, numbers.Number):
+        return value
+    try:
+        return int(value)
+    except ValueError:
+        return float(value)
+
+
+def validate_number(value):
+    return str_to_num(value)
+
+
+def validate_integer(value):
+    if not isinstance(value, int):
+        try:
+            value = int(value)
+        except Exception:
+            raise ValueError(_('"%s" is not an integer') % value)
+    return value
+
+
+def validate_float(value):
+    if not isinstance(value, float):
+        raise ValueError(_('"%s" is not a float') % value)
+    return validate_number(value)
+
+
+def validate_string(value):
+    if not isinstance(value, six.string_types):
+        raise ValueError(_('"%s" is not a string') % value)
+    return value
+
+
+def validate_list(value):
+    if not isinstance(value, list):
+        raise ValueError(_('"%s" is not a list') % value)
+    return value
+
+
+def validate_map(value):
+    if not isinstance(value, collections.Mapping):
+        raise ValueError(_('"%s" is not a map') % value)
+    return value
+
+
+def validate_boolean(value):
+    if isinstance(value, bool):
+        return value
+
+    if isinstance(value, str):
+        normalised = value.lower()
+        if normalised in ['true', 'false']:
+            return normalised == 'true'
+    raise ValueError(_('"%s" is not a boolean') % value)
+
+
+def validate_timestamp(value):
+    return dateutil.parser.parse(value)
diff --git a/app/toscalib/utils/yamlparser.py b/app/toscalib/utils/yamlparser.py
new file mode 100644
index 0000000..e54227d
--- /dev/null
+++ b/app/toscalib/utils/yamlparser.py
@@ -0,0 +1,63 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import codecs
+from collections import OrderedDict
+
+import yaml
+
+
+if hasattr(yaml, 'CSafeLoader'):
+    yaml_loader = yaml.CSafeLoader
+else:
+    yaml_loader = yaml.SafeLoader
+
+
+def load_yaml(path):
+    with codecs.open(path, encoding='utf-8', errors='strict') as f:
+        return yaml.load(f.read(), Loader=yaml_loader)
+
+
+def simple_parse(tmpl_str):
+    try:
+        tpl = yaml.load(tmpl_str, Loader=yaml_loader)
+    except yaml.YAMLError as yea:
+        raise ValueError(yea)
+    else:
+        if tpl is None:
+            tpl = {}
+    return tpl
+
+
+def ordered_load(stream, Loader=yaml.Loader, object_pairs_hook=OrderedDict):
+    class OrderedLoader(Loader):
+        pass
+
+    def construct_mapping(loader, node):
+        loader.flatten_mapping(node)
+        return object_pairs_hook(loader.construct_pairs(node))
+
+    OrderedLoader.add_constructor(
+        yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG,
+        construct_mapping)
+    return yaml.load(stream, OrderedLoader)
+
+
+def simple_ordered_parse(tmpl_str):
+    try:
+        tpl = ordered_load(tmpl_str)
+    except yaml.YAMLError as yea:
+        raise ValueError(yea)
+    else:
+        if tpl is None:
+            tpl = {}
+    return tpl
diff --git a/app/toscalib/utils/yamlparser.pyc b/app/toscalib/utils/yamlparser.pyc
new file mode 100644
index 0000000..8d97b2a
--- /dev/null
+++ b/app/toscalib/utils/yamlparser.pyc
diff --git a/app/version.py b/app/version.py
new file mode 100644
index 0000000..1fb3765
--- /dev/null
+++ b/app/version.py
@@ -0,0 +1 @@
+__version__ =  '1806.0.022118-SNAPSHOT'
+\ No newline at end of file
diff --git a/app/version.pyc b/app/version.pyc
new file mode 100644
index 0000000..7a19a68
--- /dev/null
+++ b/app/version.pyc
diff --git a/app/web/uwsgi.ini b/app/web/uwsgi.ini
new file mode 100644
index 0000000..c4cca12
--- /dev/null
+++ b/app/web/uwsgi.ini
@@ -0,0 +1,16 @@
+[uwsgi]
+module = tosca_server:application
+#plugin = python
+chdir = /srv
+master = True
+processes = 2
+pidfile = /tmp/project-master.pid
+vacuum = true
+max-requests = 5000
+enable-threads = True
+logto = /var/log/uwsgi/%n.log
+
+uid = dcae
+socket = /run/uwsgi/tosca.sock
+chown-socket = dcae:nginx
+chmod-socket = 664
diff --git a/docker/Dockerfile b/docker/Dockerfile
new file mode 100644
index 0000000..fbfa7df
--- /dev/null
+++ b/docker/Dockerfile
@@ -0,0 +1,20 @@
+FROM onap/dcae-tosca-base:1.0.4
+
+RUN apk add --no-cache \
+    curl \
+    && :
+
+COPY ./app /srv/
+
+COPY ./docker/docker-entrypoint.sh /srv/
+
+COPY ./nginx/nginx.conf /etc/nginx/nginx.conf
+
+RUN chmod +x /srv/tosca_server.py && \
+    chmod +x /srv/docker-entrypoint.sh
+
+RUN pip3 install -r /srv/requirements.txt
+
+EXPOSE 8085 
+
+ENTRYPOINT ["/srv/docker-entrypoint.sh", "/usr/local/bin/uwsgi", "--ini", "/srv/web/uwsgi.ini"]
diff --git a/docker/Dockerfile.Base b/docker/Dockerfile.Base
new file mode 100644
index 0000000..0f3b85d
--- /dev/null
+++ b/docker/Dockerfile.Base
@@ -0,0 +1,39 @@
+FROM python:3.5-alpine
+
+ENV http_proxy http://one.proxy.att.com:8080
+ENV https_proxy http://one.proxy.att.com:8080
+
+ENV GROUPID=1000 \
+    USERNAME=dcae \
+    USERID=1001 \
+    USER_HOME=/home/dcae
+
+RUN apk add --no-cache \
+    autoconf \
+    gcc \
+    libc-dev \
+    linux-headers \
+    nginx \
+    && :
+
+RUN pip install --upgrade setuptools && \
+    pip install uwsgi==2.0.15
+
+RUN mkdir -p \
+    /var/log/uwsgi \
+    /run/uwsgi \
+    /srv    
+
+RUN addgroup -g ${GROUPID} -S ${USERNAME}
+
+RUN adduser -S -G ${USERNAME} -u ${USERID} -s /bin/bash -h ${USER_HOME} ${USERNAME}
+
+RUN chown ${USERNAME}:nginx /run/uwsgi
+
+RUN apk del \
+    autoconf \
+    gcc \
+    libc-dev \
+    linux-headers \
+    && :
+
diff --git a/docker/docker-entrypoint.sh b/docker/docker-entrypoint.sh
new file mode 100644
index 0000000..42fe60b
--- /dev/null
+++ b/docker/docker-entrypoint.sh
@@ -0,0 +1,10 @@
+#!/bin/sh
+set -x
+echo "Running entry point"
+echo $@
+## Run nginxi Web Server
+/usr/sbin/nginx -c /etc/nginx/nginx.conf
+
+# Execute arguments
+echo >&2 $0: Continuing with "$@"...
+exec "$@"
diff --git a/nginx/nginx.conf b/nginx/nginx.conf
new file mode 100644
index 0000000..363e205
--- /dev/null
+++ b/nginx/nginx.conf
@@ -0,0 +1,30 @@
+#user nginx;
+worker_processes  1;
+
+error_log  logs/error.log;
+error_log  logs/error.log  notice;
+error_log  logs/error.log  info;
+
+pid        nginx.pid;
+
+
+events {
+    worker_connections  4096;
+}
+
+
+http {
+
+    server {
+        listen   8085;
+        server_name  localhost;
+        charset utf-8r;
+
+        location / {
+            include  uwsgi_params;
+            uwsgi_pass unix:/run/uwsgi/tosca.sock;
+            
+        }
+    }
+
+}
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..f706f8b
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,159 @@
+<project 
+  xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.onap.oparent</groupId>
+    <artifactId>oparent</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+  </parent>
+
+  <groupId>org.onap.dcae.dcae-tosca-app </groupId>
+  <artifactId>dcae-tosca-app</artifactId>
+  <packaging>pom</packaging>
+  <version>1.0.0-SNAPSHOT</version>
+  <name>dcae-tosca-app</name>
+
+  <properties>
+        <!--nexus-->
+        <sitePath>/content/sites/site/org/onap/dcae/${project.artifactId}/${project.version}</sitePath>
+        <!--maven-->
+        <timestamp>${maven.build.timestamp}</timestamp>
+        <maven.build.timestamp.format>yyyy.MM.dd.HH.mm</maven.build.timestamp.format>
+        <!--docker-->
+        <docker.tag>${project.version}-${maven.build.timestamp}</docker.tag>
+        <docker.latest.tag>${project.version}-latest</docker.latest.tag>
+        <docker.staging.tag>${parsedVersion.majorVersion}.${parsedVersion.minorVersion}-STAGING-latest</docker.staging.tag>
+  </properties>
+
+
+  <profiles>
+      <profile>
+          <id>docker</id>
+          <properties>
+              <!-- Docker tags -->
+              <maven.build.timestamp.format>yyyyMMdd'T'HHmm</maven.build.timestamp.format>
+              <docker.tag>${project.version}-${maven.build.timestamp}</docker.tag>
+              <docker.latest.tag>${project.version}-latest</docker.latest.tag>
+              <docker.staging.tag>${parsedVersion.majorVersion}.${parsedVersion.minorVersion}-STAGING-latest</docker.staging.tag>
+          </properties>
+          <activation>
+              <activeByDefault>false</activeByDefault>
+          </activation>
+          <build>
+              <plugins>
+                  <plugin>
+                      <groupId>org.codehaus.mojo</groupId>
+                      <artifactId>build-helper-maven-plugin</artifactId>
+                      <version>1.8</version>
+                      <executions>
+                          <execution>
+                              <id>parse-version</id>
+                              <goals>
+                                  <goal>parse-version</goal>
+                              </goals>
+                          </execution>
+                      </executions>
+                  </plugin>
+                  <plugin>
+                      <groupId>org.sonatype.plugins</groupId>
+                      <artifactId>nexus-staging-maven-plugin</artifactId>
+                      <version>1.6.7</version>
+                      <extensions>true</extensions>
+                      <configuration>
+                          <nexusUrl>${onap.nexus.url}</nexusUrl>
+                          <stagingProfileId>176c31dfe190a</stagingProfileId>
+                          <serverId>ecomp-staging</serverId>
+                      </configuration>
+                  </plugin>
+                  <plugin>
+                      <artifactId>maven-resources-plugin</artifactId>
+                      <version>3.0.2</version>
+                      <executions>
+                          <execution>
+                              <id>copy-docker-file</id>
+                              <phase>validate</phase>
+                              <goals>
+                                  <goal>copy-resources</goal>
+                              </goals>
+                              <configuration>
+                                  <outputDirectory>${project.basedir}</outputDirectory>
+                                  <resources>
+                                      <resource>
+                                          <directory>${project.basedir}/docker</directory>
+                                          <includes>
+                                              <include>Dockerfile</include>
+                                          </includes>
+                                      </resource>
+                                  </resources>
+                              </configuration>
+                          </execution>
+                      </executions>
+                  </plugin>
+                  <plugin>
+                      <groupId>io.fabric8</groupId>
+                      <artifactId>docker-maven-plugin</artifactId>
+                      <version>0.19.1</version>
+                      <configuration>
+                          <verbose>true</verbose>
+                          <apiVersion>1.23</apiVersion>
+                          <registry>nexus3.onap.org:10003</registry>
+                          <images>
+                              <image>
+                                  <name>onap/dcae-tosca-app</name>
+                                  <alias>dcae-tosca-app</alias>
+                                  <build>
+                                      <cleanup>true</cleanup>
+                                      <tags>
+                                          <tag>${docker.tag}</tag>
+                                          <tag>${docker.latest.tag}</tag>
+                                          <tag>${docker.staging.tag}</tag>
+                                      </tags>
+                                      <dockerFileDir>${project.basedir}</dockerFileDir>
+                                  </build>
+                              </image>
+                          </images>
+                      </configuration>
+                      <executions>
+                          <execution>
+                              <id>clean-images</id>
+                              <phase>pre-clean</phase>
+                              <goals>
+                                  <goal>remove</goal>
+                              </goals>
+                              <configuration>
+                                  <removeAll>true</removeAll>
+                              </configuration>
+                          </execution>
+                          <execution>
+                              <id>generate-images</id>
+                              <phase>package</phase>
+                              <goals>
+                                  <goal>build</goal>
+                              </goals>
+                          </execution>
+                          <execution>
+                              <id>push-images</id>
+                              <phase>deploy</phase>
+                              <goals>
+                                  <goal>build</goal>
+                                  <goal>push</goal>
+                              </goals>
+                              <configuration>
+                                  <image>onap/dcae-tosca-app</image>
+                              </configuration>
+                          </execution>
+                      </executions>
+                  </plugin>
+              </plugins>
+          </build>
+          <distributionManagement>
+              <site>
+                  <id>nexus</id>
+                  <url>dav:${nexus.url}${sitePath}</url>
+              </site>
+          </distributionManagement>
+      </profile>
+  </profiles>
+</project>
+
diff --git a/scripts/RunJson2Yaml.sh b/scripts/RunJson2Yaml.sh
new file mode 100644
index 0000000..3e12425
--- /dev/null
+++ b/scripts/RunJson2Yaml.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -x
+# The script should immediately exit if any command in the script fails.
+# set -e
+# This is the path for the json spac folder
+file_path="../app/data/json-spac"
+
+for f in $file_path/*
+do
+    filename=$(basename $f)
+    name=$(echo $filename | cut -f 1 -d '.')
+    
+    echo $filename $name
+    python ../app/model_create.py -i $f -o ../app/data/tosca_model/$name/ --name=$name -t ../app/data/import_file.yaml -m ../app/data/meta_model/meta_tosca_schema.yaml
+    echo "-------------------"
+done
diff --git a/simple_compose_stdin.py b/simple_compose_stdin.py
new file mode 100644
index 0000000..532c57a
--- /dev/null
+++ b/simple_compose_stdin.py
@@ -0,0 +1,35 @@
+#Author: Shu Shi
+#emaiL: shushi@research.att.com
+
+import sys, json, base64, logging
+
+from toscalib.tosca_workbook import ToscaWorkBook
+    
+input_data = sys.stdin.readline()  
+try:
+    in_data = json.loads(input_data)
+except ValueError as e:
+    logging.error( 'error, cannot load input json data: ' + str(input_data))
+
+workbook = ToscaWorkBook()
+workbook._import_dir('./data/shared_model/')
+
+#if in_data.has_key('models'):
+if 'models' in in_data:
+    in_model = in_data['models']
+    if type(in_model) != list:
+        logging.warning( 'models in the input should be a list type')
+    for model_entry in in_model:
+        for key in ['schema', 'template', 'translate']:
+#            if model_entry.has_key(key):
+            if key in model_entry:
+                workbook._import_yml_str(base64.b64decode(model_entry[key]))
+
+#if in_data.has_key('template'):
+if 'template' in in_data:
+    in_temp = in_data['template']
+    workbook._translate_template_yaml_str(base64.b64decode(in_temp))
+    workbook._add_shared_node([{'dcae.capabilities.cdapHost':'cdap_host'}, {'dcae.capabilities.dockerHost': 'docker_host'}, {'dcae.capabilities.composition.host': 'composition_virtual'}])
+                
+ret = workbook._export_yaml_web('cloudify,main')
+print(ret)
diff --git a/tosca_server.pyc b/tosca_server.pyc
new file mode 100644
index 0000000..1bd8f2e
--- /dev/null
+++ b/tosca_server.pyc
diff --git a/toscalib/__init__.pyc b/toscalib/__init__.pyc
new file mode 100644
index 0000000..55190c1
--- /dev/null
+++ b/toscalib/__init__.pyc
diff --git a/toscalib/templates/__init__.pyc b/toscalib/templates/__init__.pyc
new file mode 100644
index 0000000..4ab1179
--- /dev/null
+++ b/toscalib/templates/__init__.pyc
diff --git a/toscalib/templates/capability_item.pyc b/toscalib/templates/capability_item.pyc
new file mode 100644
index 0000000..e81ec20
--- /dev/null
+++ b/toscalib/templates/capability_item.pyc
diff --git a/toscalib/templates/constant.pyc b/toscalib/templates/constant.pyc
new file mode 100644
index 0000000..ec5584f
--- /dev/null
+++ b/toscalib/templates/constant.pyc
diff --git a/toscalib/templates/database.pyc b/toscalib/templates/database.pyc
new file mode 100644
index 0000000..5a8d85e
--- /dev/null
+++ b/toscalib/templates/database.pyc
diff --git a/toscalib/templates/heat_constants.pyc b/toscalib/templates/heat_constants.pyc
new file mode 100644
index 0000000..22fa58a
--- /dev/null
+++ b/toscalib/templates/heat_constants.pyc
diff --git a/toscalib/templates/interface_item.pyc b/toscalib/templates/interface_item.pyc
new file mode 100644
index 0000000..569c24a
--- /dev/null
+++ b/toscalib/templates/interface_item.pyc
diff --git a/toscalib/templates/node.pyc b/toscalib/templates/node.pyc
new file mode 100644
index 0000000..4eeb108
--- /dev/null
+++ b/toscalib/templates/node.pyc
diff --git a/toscalib/templates/operation_item.pyc b/toscalib/templates/operation_item.pyc
new file mode 100644
index 0000000..1fbb451
--- /dev/null
+++ b/toscalib/templates/operation_item.pyc
diff --git a/toscalib/templates/property_item.pyc b/toscalib/templates/property_item.pyc
new file mode 100644
index 0000000..207f9b8
--- /dev/null
+++ b/toscalib/templates/property_item.pyc
diff --git a/toscalib/templates/requirement_item.pyc b/toscalib/templates/requirement_item.pyc
new file mode 100644
index 0000000..a9d7579
--- /dev/null
+++ b/toscalib/templates/requirement_item.pyc
diff --git a/toscalib/templates/substitution_rule.pyc b/toscalib/templates/substitution_rule.pyc
new file mode 100644
index 0000000..b901ed9
--- /dev/null
+++ b/toscalib/templates/substitution_rule.pyc
diff --git a/toscalib/templates/topology.pyc b/toscalib/templates/topology.pyc
new file mode 100644
index 0000000..1e8a0ba
--- /dev/null
+++ b/toscalib/templates/topology.pyc
diff --git a/toscalib/tosca_builder.pyc b/toscalib/tosca_builder.pyc
new file mode 100644
index 0000000..8a506a4
--- /dev/null
+++ b/toscalib/tosca_builder.pyc
diff --git a/toscalib/tosca_workbook.pyc b/toscalib/tosca_workbook.pyc
new file mode 100644
index 0000000..4863e92
--- /dev/null
+++ b/toscalib/tosca_workbook.pyc
diff --git a/toscalib/types/__init__.pyc b/toscalib/types/__init__.pyc
new file mode 100644
index 0000000..8eaffbd
--- /dev/null
+++ b/toscalib/types/__init__.pyc
diff --git a/toscalib/types/capability.pyc b/toscalib/types/capability.pyc
new file mode 100644
index 0000000..64afa1a
--- /dev/null
+++ b/toscalib/types/capability.pyc
diff --git a/toscalib/types/constraints.pyc b/toscalib/types/constraints.pyc
new file mode 100644
index 0000000..af2f629
--- /dev/null
+++ b/toscalib/types/constraints.pyc
diff --git a/toscalib/types/data.pyc b/toscalib/types/data.pyc
new file mode 100644
index 0000000..3e05119
--- /dev/null
+++ b/toscalib/types/data.pyc
diff --git a/toscalib/types/entry_schema.pyc b/toscalib/types/entry_schema.pyc
new file mode 100644
index 0000000..8b473f8
--- /dev/null
+++ b/toscalib/types/entry_schema.pyc
diff --git a/toscalib/types/interface.pyc b/toscalib/types/interface.pyc
new file mode 100644
index 0000000..9fa7b8c
--- /dev/null
+++ b/toscalib/types/interface.pyc
diff --git a/toscalib/types/node.pyc b/toscalib/types/node.pyc
new file mode 100644
index 0000000..2c289fc
--- /dev/null
+++ b/toscalib/types/node.pyc
diff --git a/toscalib/types/operation.pyc b/toscalib/types/operation.pyc
new file mode 100644
index 0000000..db7e056
--- /dev/null
+++ b/toscalib/types/operation.pyc
diff --git a/toscalib/types/property.pyc b/toscalib/types/property.pyc
new file mode 100644
index 0000000..162881f
--- /dev/null
+++ b/toscalib/types/property.pyc
diff --git a/toscalib/types/relationship.pyc b/toscalib/types/relationship.pyc
new file mode 100644
index 0000000..f3450e8
--- /dev/null
+++ b/toscalib/types/relationship.pyc
diff --git a/toscalib/types/requirement.pyc b/toscalib/types/requirement.pyc
new file mode 100644
index 0000000..145aeea
--- /dev/null
+++ b/toscalib/types/requirement.pyc
diff --git a/toscalib/utils/__init__.pyc b/toscalib/utils/__init__.pyc
new file mode 100644
index 0000000..d354098
--- /dev/null
+++ b/toscalib/utils/__init__.pyc
diff --git a/toscalib/utils/tosca_export.pyc b/toscalib/utils/tosca_export.pyc
new file mode 100644
index 0000000..e07fa63
--- /dev/null
+++ b/toscalib/utils/tosca_export.pyc
diff --git a/toscalib/utils/tosca_heat.pyc b/toscalib/utils/tosca_heat.pyc
new file mode 100644
index 0000000..a958536
--- /dev/null
+++ b/toscalib/utils/tosca_heat.pyc
diff --git a/toscalib/utils/tosca_import.pyc b/toscalib/utils/tosca_import.pyc
new file mode 100644
index 0000000..5dc01e8
--- /dev/null
+++ b/toscalib/utils/tosca_import.pyc
diff --git a/toscalib/utils/tosca_operate.pyc b/toscalib/utils/tosca_operate.pyc
new file mode 100644
index 0000000..b411bd2
--- /dev/null
+++ b/toscalib/utils/tosca_operate.pyc
diff --git a/toscalib/utils/tosca_print.pyc b/toscalib/utils/tosca_print.pyc
new file mode 100644
index 0000000..7ec2ae3
--- /dev/null
+++ b/toscalib/utils/tosca_print.pyc
diff --git a/toscalib/utils/yamlparser.pyc b/toscalib/utils/yamlparser.pyc
new file mode 100644
index 0000000..1d5b4c2
--- /dev/null
+++ b/toscalib/utils/yamlparser.pyc
author	Stone, Avi (as206k) <as206k@att.com>	2018-04-12 16:41:45 +0300
committer	Stone, Avi (as206k) <as206k@att.com>	2018-04-12 16:41:45 +0300
commit	879e94b78193798e8b170fca9b924d2c3881f7ba (patch)
tree	150de697138a7593869eaae455add025b06a6e04
parent	7e02c7aaab14828ef8baaef98865f26d98e3b795 (diff)