Example #1
0
    def _js(self):
        '''
        handle js

        JS文件不同于CSS,其本身不能引用其它相对路径的静态资源,因此可以实现
        先合并再替换、加时间戳,无需预先处理所有js文件。
        '''
        js_modules = C('require_js_modules')
        if not utils.isList(js_modules):
            js_modules = C('require_modules')

        if not utils.isList(js_modules):
            js_modules = ['main']

        for js in js_modules:
            try:
                if not utils.isStr(js):
                    continue;
                js = re.sub(r'^\/+','',js)
                if not js.endswith('.js'):
                    js += '.js'
                js_realpath = os.path.join(self._build_js_dir,js)
                self.build_js(js_realpath,js_realpath,self._build_js_dir)
            except Exception,e:
                if self._force:
                    log.error('[less]%s'%e)
                else:
                    raise e
Example #2
0
    def writeMember(self, obj, memberName):
        if isString(obj):
            logging.warning(u"String as object provided! " +
                            self._warningPrefix(obj, memberName))
        if isInteger(memberName) and isList(obj):
            member = obj[memberName]
            memberName = str(memberName)
        else:
            member = getattr(obj, memberName, None)
        if member is None:
            self.log(u"skipped " + self._warningPrefix(obj, memberName) +
                     u"It is empty or does not exist (=None).")
            return

        if isCallable(member) and not hasattr(member, "hdfWrite"):
            member = member()

        if hasattr(member, "hdfWrite"):  # support instances and types
            # store the member in a group of its own
            oldLocation = self.location
            self._location = "/".join((oldLocation.rstrip('/'), memberName))
            member.hdfWrite(self)  # recursion entry, mind the loops!
            self._location = oldLocation
        elif isList(member):
            self.writeDataset(memberName, member)
        elif isString(member) or isNumber(member):
            self.writeAttribute(memberName, member)
        else:
            self.log(u"skipped " + self._warningPrefix(obj, memberName) +
                     "(={}) It is not a compatible value type!".format(
                         classname(member)))
Example #3
0
def getOpenFiles(parent, labeltext, path,
                 filefilter = None, multiple = True):
    kwargs = {'options': QFileDialog.ReadOnly,
              'caption': labeltext,
              'dir': path, # why does pyside have different kwarg keys?
              'filter': makeFilter(filefilter)}
    if multiple:
        res = QFileDialog.getOpenFileNames(parent, **kwargs)
        if isList(res) and isList(res[0]):
            res = res[0]
        elif not isList(res):
            res = list(res)
        return res
    else:
        return [QFileDialog.getOpenFileName(parent, **kwargs)]
Example #4
0
 def _updateFitParam(self, param, valueWidget):
     if not isinstance(param, FitParameterBase):
         return
     keymin, keymax = param.name() + "min", param.name() + "max"
     minWidget = self.getWidget(keymin)
     maxWidget = self.getWidget(keymax)
     # get changed value range if any
     minValue = self.getValue(minWidget)
     maxValue = self.getValue(maxWidget)
     # update value range for numerical parameters
     if None not in (minValue, maxValue):
         param.setDisplayActiveRange((minValue, maxValue))
         displayRange = param.displayActiveRange()  # get updated values
         if isList(displayRange) and None not in displayRange:
             self.setValue(minWidget, min(displayRange))
             self.setValue(maxWidget, max(displayRange))
     newActive = self.get(param.name() + "active")
     if not isinstance(newActive, bool):  # None for non-fit parameters
         return
     # update active state for fit parameters
     param.setActive(newActive)
     if None in (valueWidget, minWidget, maxWidget):
         return
     if param.isActive():
         valueWidget.hide()
         minWidget.show()
         maxWidget.show()
     else:
         valueWidget.show()
         minWidget.hide()
         maxWidget.hide()
Example #5
0
 def update(self):
     """Updates this item according to eventually changed data object"""
     data = self.data() # forced to be DataSet in __init__
     columnCount = len(data.displayData)
     for column in range(0, columnCount):
         columnData = data.displayData[column]
         if not isList(columnData): # columnData is supposed to be tuple
             columnData = (columnData, )
         for attrname in columnData: # set attributes of columns if avail
             if not isString(attrname):
                 continue
             value = getattr(data, attrname, None)
             if value is None:
                 continue
             getProperty, setProperty, value = self.getItemProperty(value)
             # set it always, regardless if needed
             setProperty(column, value)
     # adjust #table columns
     treeWidget = self.treeWidget()
     if treeWidget is not None and treeWidget.columnCount() < columnCount:
         treeWidget.setColumnCount(columnCount)
     # update children
     for item in self.takeChildren(): # remove all children
         item.remove()
         del item
Example #6
0
 def setAlignment(self, alignment):
     if alignment is None:
         return
     if not isList(alignment):
         alignment = [alignment]
     for c in range(0, self.columnCount()):
         self.setTextAlignment(c, alignment[min(c, len(alignment)-1)])
Example #7
0
 def processSeriesStats(seriesItem, seriesPlot, fileData, columnNames):
     # gather data values indexed by columns names first
     stats = dict()
     ((sampleName, seriesKeyName, (pname, lo, hi, weight)),
      valuePairs) = seriesItem
     columnNames[0] = seriesKeyName.replace(" ", "_")
     for seriesKey, moments in valuePairs:
         values = (seriesKey, pname, lo, hi, weight) + moments
         for name, value in zip(columnNames, values):
             if name not in stats:
                 stats[name] = []
             # for plotting below, no float-str conversion here
             stats[name].append(value)
     # convert numerical stats to proper formatted text for file output
     for key, values in stats.items():
         # proper float-str formatting for text file output
         if key not in fileData:
             fileData[key] = []
         for value in values:
             if isList(value):
                 value = ";".join(
                     [AsciiFile.formatValue(v) for v in value])
             fileData[key].append(AsciiFile.formatValue(value))
     # simple statistics plotting, kind of a prototype for now ...
     stats["seriesKeyName"] = seriesKeyName
     stats["seriesKey"] = stats[columnNames[0]]
     stats["cfg"] = u"{param} [{lo},{hi}] {w}".format(param=pname,
                                                      lo=lo,
                                                      hi=hi,
                                                      w=weight)
     stats["title"] = sampleName
     seriesPlot.plot(stats)
Example #8
0
 def addMenuEntry(self, name = None, text = None, toolTip = None,
                  shortCut = None, checkable = False, checked = False,
                  callbacks = None, menuStates = None):
     """
     Argument 'callbacks' is supposed to be a list of methods
     which will be connected to the QAction.triggered signal.
     """
     a = QAction(self)
     assert isString(name)
     a.setObjectName("action{0}".format(name.title()))
     assert text is not None
     a.setText(self._updateTitle(escapeAmp(text)))
     if toolTip is not None:
         a.setToolTip(self._updateTitle(toolTip))
     if shortCut is not None:
         a.setShortcut(shortCut)
         a.setShortcutContext(Qt.WidgetShortcut)
     a.setCheckable(bool(checkable))
     a.setChecked(bool(checked))
     if not isList(callbacks):
         callbacks = (callbacks, )
     for callback in callbacks:
         if callback is None:
             continue
         assert callable(callback), tr("Specified callbacks have to be "
                                       "a method or a function!")
         a.triggered.connect(callback)
     self.addMenuEntryAction(name, a, menuStates)
     return a
Example #9
0
def _getSettingValueFromLabel( settings_list , label ):
  assert(utils.isList(settings_list))
  assert(utils.isString(label))
  for s in settings_list:
    if _getSettingLabel(s) == label:
      return _getSettingValue(s)
  return None
Example #10
0
    def __call__(self, dataset):
        if self.model is None:
            logging.warning("No model set!")
            return
        # start log file writing
        testfor(isinstance(dataset, DataSet), Exception,
                "{cls} requires a DataSet!".format(cls=type(self)))
        self._outFn = OutputFilename(dataset)
        fn = self._outFn.filenameVerbose("log", "this log")
        logFile = logging.FileHandler(fn, encoding="utf8")
        widgetHandler = log.getWidgetHandlers()[0]
        log.replaceHandler(widgetHandler)  # remove everything else
        log.addHandler(logFile)
        try:
            # show last lines about pdf output from separate thread
            widgetHandler.widget.addWatchDir(self._outFn.outDir)
        except AttributeError:
            pass

        self._writeSettings(dict(), dataset)
        if self.nolog:  # refers to the widgethandler
            log.removeHandler(widgetHandler)
        #set data in the algorithm
        self._algo.data = dataset

        # write HDF5, show exceptions traceback, if any
        try:
            self.hdfStore(self._outFn.filenameVerbose(
                "hdf5archive",
                "Complete state of the calculation",
                extension='.hdf5'),
                          rootLocation="mcsasentry")
        except Exception as e:
            import traceback
            print(traceback.format_exc())

        self._algo.calc()
        if self.nolog:
            log.addHandler(widgetHandler)

        if isList(self._algo.result) and len(self._algo.result):
            res = self._algo.result[0]
            # quick hack for now, will get fixed with Parameter design
            for p in self.model.activeParams():
                self._writeDistrib(p)
                self._writeStatistics(p)
            self._updateSeries(dataset, self.model)
            # plotting last so stats were already calculated
            if res is not None:
                self._writeFit(res)
                self._writeContribs(res)
                self._algo.plot(outputFilename=self._outFn,
                                autoClose=self._algo.autoClose())
        else:
            logging.info("No results available!")

        log.removeHandler(logFile)
Example #11
0
 def setValueRange(self, newRange):
     testfor(isList(newRange), ValueRangeError,
             "A value range for a string type parameter has to be a list!")
     testfor(all([isString(v) for v in newRange]), ValueRangeError,
             "A value range for a string has to be a list of strings!")
     self._valueRange = newRange
     if not (self.value() in self.valueRange()):
         # where are the default values?
         self.setValue(self.valueRange()[0])
Example #12
0
def generateValues(numberGenerator, defaultRange, lower, upper, count):
    # works with vectors of multiple bounds too
    vRange = defaultRange
    if lower is None:
        lower = vRange[0]
    if upper is None:
        upper = vRange[1]
    vRange = (np.maximum(vRange[0], lower), np.minimum(vRange[1], upper))
    if isList(vRange[0]) and isList(vRange[1]):
        assert len(vRange[0]) == len(
            vRange[1]), ("Provided value range is unsymmetrical!")
    try:  # update count to length of provided bound vectors
        count = max(count, min([len(x) for x in vRange]))
    except:
        pass
    values = numberGenerator.get(count)
    # scale numbers to requested range
    return values * (vRange[1] - vRange[0]) + vRange[0]
Example #13
0
def _writeSettings( settings_list ):
  assert(utils.isList(settings_list))
  try:
    f = open(SETTINGS_PATH,"w")
    f.write( "\n".join([ "=".join(s) for s in settings_list ]) )
    f.close()
  except IOError:
    print("Could not write cfg file.")
    return False
  return True
Example #14
0
 def addToMenuState(self, stateName, *entryNames):
     assert isString(stateName)
     if stateName != self.allMenuStates: # default state
         assert hasattr(self, stateName)
     assert isList(entryNames)
     entryList = self._states.get(stateName, [])
     for name in entryNames:
         if name in self._actions:
             entryList.append(name)
     self._states[stateName] = entryList
Example #15
0
def _printSettings( settings_list ):
  assert(utils.isList(settings_list))
  print("{:<20}{:<20}".format("Label","Value"))
  print("-"*40)
  for s in settings_list:
    if not _validateSettingFormat(s):
      return
    print("{:<20}{:<20}".format(_getSettingLabel(s),_getSettingValue(s)))
  if len(settings_list) == 0:
    print("No settings found.")
			def monitor_service(svc,symbol,value):
			    cmd = __config__[svc]
			    cName = cmd.split()[0]
			    __cmd__ = os.sep.join([__plugins__,cName])
			    if (os.path.exists(__cmd__)):
				cmd = cmd.replace(cName,__cmd__).replace(symbol,value)
				logger.debug('(+++) %s=%s' % (svc,cmd))

				__results__ = utils.shellexecute(cmd)
				results = [str(item).strip() for item in __results__[0]]
				retcode = [str(item).strip() for item in __results__[-1]]
				logger.info('(+++) cmd-->results=%s' % (results))
				logger.info('(+++) cmd-->retcode=%s' % (retcode))
				
				data = "%s\\t%s\\t%s\\t%s\n" % (options.host, svc, 0 if (len(retcode) == 0) else 1, results[0])
				logger.debug('(+++) data=%s' % (data))

				payload = utils.SmartObject()
	
				payload.oper = "login"
				payload.username = __username__
				payload.password = __password__

				payload.send_nsca = data

				__cfg__ = None
				__results__ = utils.shellexecute(__find_send_nsca_cfg__)
				results = [str(f).strip() for f in __results__[0] if (os.path.exists(str(f).strip()))]
				if (len(results) > 0):
				    __cfg__ = results[0]
				logger.info('__results__=%s [%s]' % (__results__,len(__results__)))
				logger.info('__cfg__=%s' % (__cfg__))

				payload.cfg = __cfg__

				headers = {'Content-Type':'application/json', 'Accept':'application/json'}
				r = requests.post('%s/nsca/nagios/send/nsca' % (options.url),data=simplejson.dumps(payload.__dict__), headers=headers)
				logger.debug('r.status_code=%s' % (r.status_code))
				logger.debug('r.json()=%s' % (r.json()))
				
				if (r.status_code == 200):
				    try:
					response = utils.SmartObject(args=r.json())
					logger.debug('response=%s' % (response.__dict__))
					matches = __re1__.search(response.status[0] if (utils.isList(response.status)) else response.status) if (response.status) else None
					if (matches):
					    groups = utils.SmartObject(args=matches.groupdict())
					    logger.debug('(+++) matches=%s [%s]' % (matches,groups.__dict__))
					    
					    if (groups.num):
						logger.debug('(+++) groups.num=%s' % (groups.num))
				    except Exception, ex:
					logger.exception('EXCEPTION: %s' % (utils.formattedException(details=ex)))
Example #17
0
 def removeItems(self, indexList):
     """Deletes items specified in the given list of indices."""
     if not isList(indexList) or not len(indexList):
         return
     removedItems = []
     for i in reversed(sorted(indexList)):
         item = self.listWidget.topLevelItem(i)
         if not item.isRemovable:
             continue
         item.remove()
         removedItems.append(item.data())
     self.sigRemovedData.emit(removedItems)
     self.selectionChanged()
Example #18
0
 def _setValue(self, index, value):
     """Common setter method for all _entries."""
     assert isList(index)
     if not isList(self._values):
         self._values = []
     # enforce value types instead of testing it
     row = index[0]
     while len(self._values) <= row:
         self._values.append([])
     if len(index) == 1:
         # set the full line to value
         self._values[row] = value
     else:
         col = colCount = index[1]
         if row == 2:
             colCount = 8
         elif row > 2:
             colCount = 5
         line = self._values[row]
         while len(line) < colCount:
             line.append(0)
         line[col] = value
Example #19
0
 def append(self, histList):
     if histList is None:
         return
     if not isList(histList):
         histList = [histList]
     if not len(histList):
         return
     # put a copy of histograms into the ui list, otherwise comparison fails
     DataList.loadData(self,
                       sourceList=histList,
                       showProgress=False,
                       processSourceFunc=lambda x: x)
     self.fitColumnsToContents()
Example #20
0
def _validateSettingFormat( s ):
  if not utils.isList(s):
    print("Setting isn't table.")
    return False
  if len(s) != 2:
    print("Setting table size is wrong.")
    return False
  if True in [ not utils.isString(x) for x in s]:
    print("Settings variables aren't string.")
    return False
  if False in [ _validateString(x) for x in s]:
    print("Settings variables are invalid.")
    return False
  return True
Example #21
0
    def __init__(self, parent, algorithm, appSettings=None, showParams=None):
        """Additional arguments: *showParams* is a list of parameter names to
        show in this widget. If not specified it shows all available parameters
        by default."""
        super(SettingsGridWidget, self).__init__(parent, algorithm,
                                                 appSettings)
        self.title = TitleHandler.setup(self, self.algorithm.name())
        layout = QGridLayout(self)
        layout.setObjectName("configLayout")
        layout.setContentsMargins(0, 0, 0, 0)
        self.gridLayout = layout

        if not isList(showParams) or not len(showParams):
            showParams = self.algorithm.showParams
        self._widgets = tuple(self.makeWidgets(*showParams))
Example #22
0
 def __init__(self, *searchPaths):
     self._models = OrderedDict()
     for path, relFile in self.candidateFiles():
         if os.path.split(relFile)[-1].startswith("__init__"):
             continue
         filepath = os.path.join(path, relFile)
         validModelClasses = self._getModelClasses(path, relFile)
         if not isList(validModelClasses):
             continue
         for cls in validModelClasses:
             # get full class hierachy name, use that as key
             # there may be multiple models per file/module
             key = '.'.join((cls.__module__, cls.__name__))
             self._models[key] = (cls, filepath)
     self._models = reorder(self._models, self._priorityModels)
     logging.debug("Ordered model files: {}".format(self._models))
Example #23
0
 def writeDataset(self, name, data):
     if not isList(data):
         self.log("dataset {} is not of a list type! (={})".format(
             name, classname(data)))
         return
     shape = getattr(data, 'shape', "(len: {})".format(len(data)))
     self.log("dataset '{loc}/{name}' {shape}".format(
         loc=self.location.rstrip('/'), name=name, shape=shape))
     writeLocation = self._writeLocation()
     if name in writeLocation:
         del writeLocation[name]
     try:
         writeLocation.create_dataset(name, data=data, compression="gzip")
     except TypeError:
         # a TypeError is raised for non-chunkable data (such as string)
         writeLocation.create_dataset(name, data=data)
Example #24
0
 def setValueRange(selforcls, newRange):
     testfor(isList(newRange), ValueRangeError,
             "A value range is mandatory for a numerical parameter!")
     testfor(
         len(newRange) == 2, ValueRangeError,
         "A value range has to consist of two values!")
     testfor(all([isNumber(v) for v in newRange]), ValueRangeError,
             "A value range has to consist of numbers only!")
     minVal, maxVal = min(newRange), max(newRange)
     # minVal = max(minVal, -sys.float_info.max)
     # maxVal = min(maxVal,  sys.float_info.max)
     # avoid inf/nan showing up somewhere
     # otherwise, inf might be ok if UI elements support it (going in&out)
     minVal = max(minVal, -1e200)  # as good as -inf?...
     maxVal = min(maxVal, 1e200)  # as good as inf?...
     selforcls._valueRange = minVal, maxVal
     # apply limits to value:
     selforcls.setValue(selforcls.clip())
Example #25
0
def _editSetting( settings_list , label , new_value ):
  # saves the new value in the cfg file
  assert(utils.isList(settings_list))
  assert(utils.isString(label))
  assert(utils.isString(new_value))
  if len(new_value) == 0 or not _validateString(new_value):
    print("\nInvalid string for new value.")
    return False
  lbl_list = [ _getSettingLabel(s) for s in settings_list ]
  if not label in lbl_list:
    print("\nUnexpected error occurred. Label not in list.")
    return False
  if not _validateEdit(label,new_value):
    print("\nNew value does not meet label requirementes. Check README.")
    return False
  idx = lbl_list.index(label)
  settings_list[idx] = _formatSetting(label,new_value)
  return _writeSettings(settings_list) 
Example #26
0
 def _makeEntry(self,
                name,
                dtype,
                value,
                minmax=None,
                widgetType=None,
                parent=None,
                decimals=None,
                **kwargs):
     testfor(
         name not in self.keys, KeyError,
         "Input widget '{w}' exists already in '{s}'".format(
             w=name, s=self.objectName()))
     if widgetType is None:
         if dtype is float:
             widgetType = SciEntryBox
         else:
             widgetType = self.getInputWidget(dtype)
     if parent is None:
         parent = self
     widget = widgetType(parent, **kwargs)
     widget.setObjectName(name)
     if decimals is not None:  # set precision before the value is set
         widget.setDecimals(decimals)
     if dtype is bool:
         widget.setCheckable(True)
         widget.setChecked(value)
     else:
         widget.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
         if isList(minmax) and len(minmax):
             widget.setMinimum(min(minmax))
             widget.setMaximum(max(minmax))
         widget.setValue(value)
     # update tooltip with help text about valid input values
     decimals = getattr(widget, "decimals", None)
     if decimals is not None:
         decimals = decimals()
     try:
         SciEntryBox.updateToolTip(widget, decimals)
     except:
         pass  # for non-float input widgets
     self.connectInputWidgets(widget)
     return widget
Example #27
0
 def addMenuEntryAction(self, name, action, menuStates = None):
     """
     Common menu states: default and all. 'all' includes the default state.
     Everything else expects a method of the same name which evaluates to
     True or False. It is used to show or hide the respective context menu
     action.
     Actions bound to the same state appear grouped in the menu. The
     underlying ordered dict preserves the order of states.
     """
     action.setParent(self)
     action.setEnabled(True)
     if name in self._actions:
         name = "{0}_{1}".format(name, hash(action))
     self._actions[name] = action
     if menuStates is None:
         menuStates = self.allMenuStates
     if not isList(menuStates):
         menuStates = (menuStates,)
     for stateName in menuStates:
         self.addToMenuState(stateName, name)
Example #28
0
 def data(self, indexOrItem = None, selectedOnly = False):
     """
     Returns the list of data for a given list index or list widget item.
     If none is specified return the data of all items or the data of
     selected items only, if desired.
     """
     if type(indexOrItem) is int:
         if indexOrItem < 0 or indexOrItem >= len(self):
             raise IndexError
         items = [self.listWidget.topLevelItem(indexOrItem)]
     elif type(indexOrItem) is DataItem:
         items = [indexOrItem]
     elif (isList(indexOrItem) and
           len(indexOrItem) > 0 and
           type(indexOrItem[0]) is DataItem):
         items = indexOrItem
     else: # no indexOrItem given
         if selectedOnly:
             items = self.listWidget.selectedItems()
         else:
             items = self.topLevelItems()
     return [item.data() for item in items]
Example #29
0
 def formatAlgoInfo(self):
     """Preformats the algorithm information ready for printing
     the colons are surrounded by string-marks, to force laTeX rendering"""
     oString = u' Fitting of data$:$ {} '.format(self._figureTitle)
     oString += u'\n {}'.format(self._dataset.x0.limsString)
     oString += u'\n Active parameters$:$ {}, ranges: {} '.format(
         self._modelData.get('activeParamCount', 0), self._nR)
     oString += u'\n Background level: {0:3.3g} {pm} {1:3.3g}'.format(
         self._BG[0], self._BG[1], pm=PM)
     oString += u'\n ( Scaling factor: {0:3.3g} {pm} {1:3.3g} )'.format(
         self._SC[0], self._SC[1], pm=PM)
     times = self._result['times']
     if isList(times) and len(times):
         timesDDoF = 0
         if len(times) > 1:  # prevent division by zero in numpy.std()
             timesDDoF = 1
         oString += (u"\n Timing: {0:d} repetitions "
                     "of {1:3.3g} {pm} {2:3.3g} seconds").format(
                         np.size(times),
                         times.mean(),
                         times.std(ddof=timesDDoF),
                         pm=PM)
     return oString
Example #30
0
 def setParam(selforcls, p):
     """Sets the given parameter as an attribute of this object. Use this
     method instead of setattr()."""
     attrname = p.name()
     if not isList(selforcls._parameters):
         selforcls._parameters = []
     old = getattr(selforcls, attrname, None)
     oldIdx = -1
     if old is not None:
         try:
             p.setOnValueUpdate(old.onValueUpdate())
         except AttributeError:
             pass
         try:
             oldIdx = selforcls._parameters.index(old)
         except ValueError:
             pass
     setattr(selforcls, attrname, p)
     # maintain a list of all parameters, replace the old by the new to
     # keep the ordering or append the new if it didn't exist already
     if oldIdx >= 0:
         selforcls._parameters[oldIdx] = p
     else:
         selforcls._parameters.append(p)
Example #31
0
 def attributes(selforcls, exclude=None):
     """Returns a dictionary with <key, value> pairs of all attributes and
     their values in this type or instance.
     Helps to avoid having explicit long argument lists"""
     base = selforcls
     if not isinstance(base, type) and isinstance(base, object):
         base = type(base)
     # Parameter classes have only one direct subclass
     # FIXME: not necessarily true, see FitParameter
     base = base.__mro__[1]
     # store the direct base class for duplication later
     res = dict(cls=base, description=selforcls.__doc__)
     attr = selforcls.attributeNames()
     # filter a given list of attribute names
     if isList(exclude) or isSet(exclude):
         attr = [a for a in attr if a not in exclude]
     for name in attr:
         # if this throws an exception, there is a bug
         value = getattr(selforcls, name)()
         # use values which differ from the defaults only
         defValue = getattr(base, name)()
         if value != defValue:
             res[name] = value
     return res
			host1.use = "generic-host"
			host1.host_name = options.host
			host1.alias = options.host
			host1.address = options.ip
			payload.host1 = host1.__dict__
			
			command1 = utils.SmartObject()
			command1.command_name = "dummy_command_%s" % (options.host)
			command1.command_line = "echo \"0\""
			payload.command1 = command1.__dict__
			
			if (payload.partitions):
			    logger.info('1. payload.partitions=%s' % (payload.partitions))
			    results = utils.shellexecute(payload.partitions)
			    logger.info('2 results=%s' % (results))
			    partition_names = [str(r).strip() for r in results[0]] if (utils.isList(results)) else results
			    logger.info('3 payload.partition_names=%s' % (payload.partition_names))
			    for partition in partition_names:
				services.append(partition)

			count = 1
			for svc in services:
			    service = utils.SmartObject()
			    service.use = "generic-service"
			    service.host_name = options.host
			    service.service_description = svc
			    service.active_checks_enabled = "0"
			    service.passive_checks_enabled = "1"
			    service.check_command = command1.command_name
			    payload['service%s' % (count)] = service.__dict__
			    count += 1
Example #33
0
 def updateParamBounds(self, bounds):
     if not isList(bounds):
         bounds = [bounds,]
     if not isinstance(bounds, list):
         bounds = list(bounds)
     return bounds
Example #34
0
        #替换和加时间戳
        for dst in all_css_files:
            try:
                content = utils.readfile(dst)
                content = all_url(content,os.path.dirname(dst))
                content = replace(content,self._target)
                utils.writefile(dst,content)
            except Exception,e:
                if self._force:
                    log.error('[css]%s'%e)
                else:
                    raise e

        #仅对指定的CSS进行r.js合并
        css_modules = C('require_css_modules')
        if not utils.isList(css_modules):
            css_modules = ['main']

        for css in css_modules:
            try:
                if not utils.isStr(css):
                    continue;
                css = re.sub(r'\/*','',css)
                if not css.endswith('.css'):
                    css += '.css'
                css_realpath = os.path.join(self._build_css_dir,css)
                self.build_css(css_realpath,css_realpath)
                continue
            except Exception,e:
                if self._force:
                    log.error('[less]%s'%e)