desc.py
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:7k
源码类别:

网格计算

开发平台:

Java

  1. #Licensed to the Apache Software Foundation (ASF) under one
  2. #or more contributor license agreements.  See the NOTICE file
  3. #distributed with this work for additional information
  4. #regarding copyright ownership.  The ASF licenses this file
  5. #to you under the Apache License, Version 2.0 (the
  6. #"License"); you may not use this file except in compliance
  7. #with the License.  You may obtain a copy of the License at
  8. #     http://www.apache.org/licenses/LICENSE-2.0
  9. #Unless required by applicable law or agreed to in writing, software
  10. #distributed under the License is distributed on an "AS IS" BASIS,
  11. #WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. #See the License for the specific language governing permissions and
  13. #limitations under the License.
  14. """manage component descriptors"""
  15. # -*- python -*-
  16. import random
  17. from sets import Set
  18. from pprint import pformat
  19. from hodlib.Common.util import local_fqdn
  20. from hodlib.Common.tcp import tcpSocket, tcpError
  21. class Schema:
  22.   """the primary class for describing
  23.   schema's """
  24.   STRING, LIST, MAP = range(3)
  25.   def __init__(self, name, type = STRING, delim=','):
  26.     self.name = name
  27.     self.type = type
  28.     self.delim = delim
  29.   def getName(self):
  30.     return self.name
  31.   def getType(self):
  32.     return self.type
  33.   def getDelim(self):
  34.     return self.delim
  35. class _Merger:
  36.   """A class to merge lists and add key/value
  37.   pairs to a dictionary"""
  38.   def mergeList(x, y, uniq=True):
  39.     l = []
  40.     l.extend(x)
  41.     l.extend(y)
  42.     if not uniq:
  43.       return l
  44.     s = Set(l)
  45.     l = list(s)
  46.     return l
  47.   mergeList = staticmethod(mergeList)
  48.   def mergeMap(to, add):
  49.     for k in add:
  50.       to.setdefault(k, add[k])
  51.     return to
  52.   mergeMap = staticmethod(mergeMap)
  53. class NodePoolDesc:
  54.   """a schema for describing
  55.   Nodepools"""
  56.   def __init__(self, dict):
  57.     self.dict = dict.copy()
  58.     self.dict.setdefault('attrs', {})
  59.     self._checkRequired()
  60.     if 'options' in dict: self.dict['attrs'] = dict['options']
  61.   def _checkRequired(self):
  62.     if not 'id' in self.dict:
  63.       raise ValueError, "nodepool needs 'id'"
  64.     if self.getPkgDir() == None:
  65.       raise ValueError, "nodepool %s needs 'pkgs'" % (self.getName())
  66.   def getName(self):
  67.     return self.dict['id']
  68.   def getPkgDir(self):
  69.     return self.dict['batch-home']
  70.   def getAttrs(self):
  71.     return self.dict['attrs']
  72.   def getSchema():
  73.     schema = {}
  74.     s = Schema('id')
  75.     schema[s.getName()] = s
  76.     s = Schema('batch-home', Schema.LIST, ':')
  77.     schema[s.getName()] = s
  78.     s = Schema('attrs', Schema.MAP)
  79.     schema[s.getName()] = s
  80.     return schema
  81.   getSchema = staticmethod(getSchema)
  82. class ServiceDesc:
  83.   """A schema for describing services"""
  84.   def __init__(self, dict):
  85.     self.dict = dict.copy()
  86.     self.dict.setdefault('external', False)
  87.     self.dict.setdefault('attrs', {})
  88.     self.dict.setdefault('envs', {})
  89.     self.dict.setdefault('host',None)
  90.     self.dict.setdefault('port',None)
  91.     self.dict.setdefault('tar', None)
  92.     self.dict.setdefault('pkgs', '')
  93.     self.dict.setdefault('final-attrs', {})
  94.     self._checkRequired()
  95.     if self.dict.has_key('hadoop-tar-ball'):
  96.       self.dict['tar'] = self.dict['hadoop-tar-ball']  
  97.   def _checkRequired(self):
  98.     if not 'id' in self.dict:
  99.       raise ValueError, "service description needs 'id'"
  100. #    if len(self.getPkgDirs()) <= 0:
  101. #      raise ValueError, "service description %s needs 'pkgs'" % (self.getName())
  102.   def getName(self):
  103.     return self.dict['id']
  104.   def isExternal(self):
  105.     """True if the service is outside hod. 
  106.     e.g. connect to existing HDFS"""
  107.     
  108.     return self.dict['external']
  109.   def getPkgDirs(self):
  110.     return self.dict['pkgs']
  111.   
  112.   def getTar(self):
  113.     return self.dict['tar']
  114.   
  115.   def getAttrs(self):
  116.     return self.dict['attrs']
  117.   def getfinalAttrs(self):
  118.     return self.dict['final-attrs']
  119.   
  120.   def getEnvs(self):
  121.     return self.dict['envs']
  122.   def getSchema():
  123.     schema = {}
  124.     s = Schema('id')
  125.     schema[s.getName()] = s
  126.     s = Schema('external')
  127.     schema[s.getName()] = s
  128.     s = Schema('pkgs', Schema.LIST, ':')
  129.     schema[s.getName()] = s
  130.     
  131.     s = Schema('tar', Schema.LIST, ":")
  132.     schema[s.getName()] = s
  133.     
  134.     s = Schema('attrs', Schema.MAP)
  135.     schema[s.getName()] = s
  136.     s = Schema('final-attrs', Schema.MAP)
  137.     schema[s.getName()] = s
  138.     
  139.     s = Schema('envs', Schema.MAP)
  140.     schema[s.getName()] = s
  141.     return schema
  142.   
  143.   getSchema = staticmethod(getSchema)
  144. class CommandDesc:
  145.   def __init__(self, dict):
  146.     """a class for how a command is described"""
  147.     self.dict = dict
  148.   def __repr__(self):
  149.     return pformat(self.dict)
  150.   
  151.   def _getName(self):
  152.     """return the name of the command to be run"""
  153.     return self.dict['name']
  154.   def _getProgram(self):
  155.     """return where the program is """
  156.     return self.dict['program']
  157.   def _getArgv(self):
  158.     """return the arguments for the command to be run"""
  159.     return self.dict['argv']
  160.   def _getEnvs(self):
  161.     """return the environment in which the command is to be run"""
  162.     return self.dict['envs']
  163.   
  164.   def _getPkgDirs(self):
  165.     """return the packages for this command"""
  166.     return self.dict['pkgdirs']
  167.   def _getWorkDirs(self):
  168.     """return the working directories for this command"""
  169.     return self.dict['workdirs']
  170.   def _getAttrs(self):
  171.     """return the list of attributes for this command"""
  172.     return self.dict['attrs']
  173.   def _getfinalAttrs(self):
  174.     """return the final xml params list for this command"""
  175.     return self.dict['final-attrs']
  176.   
  177.   def _getForeground(self):
  178.     """return if the command is to be run in foreground or not"""
  179.     return self.dict['fg']
  180.   def _getStdin(self):
  181.     return self.dict['stdin']
  182.   def toString(cmdDesc):
  183.     """return a string representation of this command"""
  184.     row = []
  185.     row.append('name=%s' % (cmdDesc._getName()))
  186.     row.append('program=%s' % (cmdDesc._getProgram()))
  187.     row.append('pkgdirs=%s' % CommandDesc._csv(cmdDesc._getPkgDirs(), ':'))
  188.     if 'argv' in cmdDesc.dict:
  189.       row.append('argv=%s' % CommandDesc._csv(cmdDesc._getArgv()))
  190.     if 'envs' in cmdDesc.dict:
  191.       envs = cmdDesc._getEnvs()
  192.       list = []
  193.       for k in envs:
  194.         v = envs[k]
  195.         list.append('%s=%s' % (k, v))
  196.       row.append('envs=%s' % CommandDesc._csv(list))
  197.     if 'workdirs' in cmdDesc.dict:
  198.       row.append('workdirs=%s' % CommandDesc._csv(cmdDesc._getWorkDirs(), ':'))
  199.     if 'attrs' in cmdDesc.dict:
  200.       attrs = cmdDesc._getAttrs()
  201.       list = []
  202.       for k in attrs:
  203.         v = attrs[k]
  204.         list.append('%s=%s' % (k, v))
  205.       row.append('attrs=%s' % CommandDesc._csv(list))
  206.     if 'final-attrs' in cmdDesc.dict:
  207.       fattrs = cmdDesc._getAttrs()
  208.       list = []
  209.       for k in fattrs:
  210. v = fattrs[k]
  211. list.append('%s=%s' % (k, v)) 
  212.       row.append('final-attrs=%s' % CommandDesc._cvs(list))
  213.       
  214.     if 'fg' in cmdDesc.dict:
  215.       row.append('fg=%s' % (cmdDesc._getForeground()))
  216.     if 'stdin' in cmdDesc.dict:
  217.       row.append('stdin=%s' % (cmdDesc._getStdin()))
  218.     return CommandDesc._csv(row)
  219.   toString = staticmethod(toString)
  220.   def _csv(row, delim=','):
  221.     """return a string in csv format"""
  222.     import cStringIO
  223.     import csv
  224.     queue = cStringIO.StringIO()
  225.     writer = csv.writer(queue, delimiter=delim, escapechar='\', quoting=csv.QUOTE_NONE, 
  226.                           doublequote=False, lineterminator='n')
  227.     writer.writerow(row)
  228.     return queue.getvalue().rstrip('n')
  229.   _csv = staticmethod(_csv)