Example #1
0
  def __call__( self, name, value ):
    path = [ int( i ) if i.isdigit() else i for i in name.split( '.' ) ]
    name = path.pop( 0 )

    if not config_name_regex.match( name ):
      raise ParamaterError( 'name', 'invalid' )

    config_values = self.structure.config_values

    if name not in config_values:
      raise ParamaterError( 'name', '"{0}" not found'.format( name ) )

    while path:
      if not isinstance( config_values, ( dict, list ) ):
        raise ParamaterError( 'name', '"{0}" at non indexable level'.format( name ) )

      try:
        config_values = config_values[ name ]
      except ( KeyError, IndexError ):
        raise ParamaterError( 'name', '"{0}" not found'.format( name ) )

      name = path.pop( 0 )

    if not isinstance( config_values, ( dict, list ) ):
      raise ParamaterError( 'name', '"{0}" at non indexable level'.format( name ) )

    if name not in config_values:
      raise ParamaterError( 'name', '"{0}" not found'.format( name ) )

    config_values[ name ] = value

    self.structure.full_clean()
    self.structure.save( update_fields=[ 'config_values' ] )
Example #2
0
  def clean( self, *args, **kwargs ):
    super().clean( *args, **kwargs )
    errors = {}
    if not name_regex.match( self.name ):  # if this regex changes, make sure to update tcalc parser in archetect
      errors[ 'name' ] = 'BluePrint Script name "{0}" is invalid'.format( self.name )

    if self.config_values is not None:
      for name in self.config_values:
        if not config_name_regex.match( name ):
          errors[ 'config_values' ] = 'config item name "{0}" is invalid'.format( name )
          break

    if errors:
      raise ValidationError( errors )
Example #3
0
  def clean( self, *args, **kwargs ):
    super().clean( *args, **kwargs )
    errors = {}

    if self.foundation_id is not None and self.foundation.blueprint not in self.blueprint.combined_foundation_blueprint_list:
      errors[ 'foundation' ] = 'The blueprint "{0}" is not allowed on foundation "{1}"'.format( self.blueprint, self.foundation.blueprint )

    if self.config_values is not None:
      for name in self.config_values:
        if not config_name_regex.match( name ):
          errors[ 'config_values' ] = 'config item name "{0}" is invalid'.format( name )
          break

    if errors:
      raise ValidationError( errors )
Example #4
0
    def clean(self, *args, **kwargs):
        super().clean(*args, **kwargs)
        errors = {}

        if not name_regex.match(self.name):
            errors['name'] = 'name "{0}" is invalid'.format(self.name)

        for name in self.config_values:
            if not config_name_regex.match(name):
                errors[
                    'config_values'] = 'config item name "{0}" is invalid'.format(
                        name)
                break

        if errors:
            raise ValidationError(errors)
Example #5
0
  def clean( self, *args, **kwargs ):
    super().clean( *args, **kwargs )
    errors = {}

    if self.name and not name_regex.match( self.name ):
      errors[ 'name' ] = 'Invalid'

    if self.config_values is not None:
      for name in self.config_values:
        if not config_name_regex.match( name ):
          errors[ 'config_values' ] = 'config item name "{0}" is invalid'.format( name )
          break

        if name in ( 'domain_search', 'dns_servers', 'log_servers' ):
          if not isinstance( self.config_values[ name ], list ):
            errors[ 'config_values' ] = 'config item "{0}" must be a list'.format( name )
          break

    if errors:
      raise ValidationError( errors )
Example #6
0
def _updateConfig(config_value_map, class_list, config):
    if config_value_map is None:
        return

    for name in sorted(config_value_map.keys(), key=value_key):
        if not config_name_regex.match(name):
            raise ValueError('invalid config value name "{0}"'.format(name))

        value = config_value_map[name]

        try:
            (name, class_type) = name.split(':')
        except ValueError:
            class_type = None

        if class_type is not None and class_type not in class_list:
            continue

        if name[0] in '-<>':
            op = name[0]
            name = name[1:]
            try:
                old_value = config[name]
            except KeyError:
                if op != '-':
                    config[name] = value
                continue

            if isinstance(old_value, str):
                if not isinstance(value, str):
                    value = str(value)

                if op == '-':
                    config[name] = old_value.replace(value, '', 1)

                elif op == '<':
                    config[name] = value + old_value

                elif op == '>':
                    config[name] = old_value + value

            elif isinstance(old_value, dict):
                if op == '-':
                    if isinstance(value, str):
                        try:
                            del config[name][value]
                        except KeyError:
                            pass

                    elif isinstance(value, list):
                        for key in value:
                            try:
                                del config[name][key]
                            except KeyError:
                                pass

                else:
                    if not isinstance(value, dict):
                        raise ValueError(
                            'can only append/prepend dict with a dict')

                    config[name].update(value)

            elif isinstance(old_value, list):
                if isinstance(value, list):
                    if op == '-':
                        config[name] = old_value
                        for item in value:
                            try:
                                config[name].remove(item)
                            except ValueError:
                                pass

                    elif op == '<':
                        config[name] = value + old_value

                    elif op == '>':
                        config[name] = old_value + value

                else:
                    if op == '-':
                        config[name] = old_value
                        try:
                            config[name].remove(value)
                        except ValueError:
                            pass

                    elif op == '<':
                        config[name] = [value] + old_value

                    elif op == '>':
                        config[name] = old_value + [value]

        elif name[0] == '~':
            name = name[1:]
            try:
                del config[name]
            except KeyError:
                pass

        else:
            config[name] = value