Exemplo n.º 1
0
    def create_user(self, user_id, user):
        try:
            self.get_user(user_id)
        except exception.UserNotFound:
            pass
        else:
            msg = _('Duplicate ID, %s.') % user_id
            raise exception.Conflict(type='user', details=msg)

        try:
            self.get_user_by_name(user['name'], user['domain_id'])
        except exception.UserNotFound:
            pass
        else:
            msg = _('Duplicate name, %s.') % user['name']
            raise exception.Conflict(type='user', details=msg)

        user = utils.hash_user_password(user)
        new_user = user.copy()

        new_user.setdefault('groups', [])

        self.db.set('user-%s' % user_id, new_user)
        domain_id = user['domain_id']
        user_name_key = self._calc_user_name_key(new_user['name'], domain_id)
        self.db.set(user_name_key, new_user)
        self._user_id_to_domain_id.notify_user_created(user_id, domain_id)
        user_list = set(self.db.get('user_list', []))
        user_list.add(user_id)
        self.db.set('user_list', list(user_list))
        return identity.filter_user(new_user)
Exemplo n.º 2
0
    def create_user(self, user_id, user):
        user['name'] = clean.user_name(user['name'])
        try:
            self.get_user(user_id)
        except exception.UserNotFound:
            pass
        else:
            msg = 'Duplicate ID, %s.' % user_id
            raise exception.Conflict(type='user', details=msg)

        try:
            self.get_user_by_name(user['name'], user['domain_id'])
        except exception.UserNotFound:
            pass
        else:
            msg = 'Duplicate name, %s.' % user['name']
            raise exception.Conflict(type='user', details=msg)

        user = utils.hash_user_password(user)
        new_user = user.copy()

        new_user.setdefault('groups', [])

        self.db.set('user-%s' % user_id, new_user)
        self.db.set('user_name-%s' % new_user['name'], new_user)
        user_list = set(self.db.get('user_list', []))
        user_list.add(user_id)
        self.db.set('user_list', list(user_list))
        return identity.filter_user(new_user)
Exemplo n.º 3
0
    def update_user(self, user_id, user):
        with sql.session_for_write() as session:
            user_ref = self._get_user(session, user_id)
            old_user_dict = user_ref.to_dict()
            user = utils.hash_user_password(user)
            for k in user:
                old_user_dict[k] = user[k]
            new_user = model.User.from_dict(old_user_dict)
            for attr in model.User.attributes:
                if attr not in model.User.readonly_attributes:
                    setattr(user_ref, attr, getattr(new_user, attr))
            # Move the "_resource_options" attribute over to the real user_ref
            # so that resource_options.resource_options_ref_to_mapper can
            # handle the work.
            setattr(user_ref, '_resource_options',
                    getattr(new_user, '_resource_options', {}))

            # Move options into the proper attribute mapper construct
            resource_options.resource_options_ref_to_mapper(
                user_ref, model.UserOption)

            if 'password' in user and self._change_password_required(user_ref):
                user_ref.password_ref.expires_at = datetime.datetime.utcnow()

            user_ref.extra = new_user.extra
            return base.filter_user(user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 4
0
 def create_user(self, user_id, user):
     user = utils.hash_user_password(user)
     with sql.session_for_write() as session:
         user_ref = model.User.from_dict(user)
         user_ref.created_at = datetime.datetime.utcnow()
         session.add(user_ref)
         return base.filter_user(user_ref.to_dict())
Exemplo n.º 5
0
 def create_user(self, user_id, user):
     user = utils.hash_user_password(user)
     session = sql.get_session()
     with session.begin():
         user_ref = User.from_dict(user)
         session.add(user_ref)
     return identity.filter_user(user_ref.to_dict())
Exemplo n.º 6
0
    def create_user(self, user_id, user):
        user['name'] = clean.user_name(user['name'])
        try:
            self.get_user(user_id)
        except exception.UserNotFound:
            pass
        else:
            msg = 'Duplicate ID, %s.' % user_id
            raise exception.Conflict(type='user', details=msg)

        try:
            self.get_user_by_name(user['name'], user['domain_id'])
        except exception.UserNotFound:
            pass
        else:
            msg = 'Duplicate name, %s.' % user['name']
            raise exception.Conflict(type='user', details=msg)

        user = utils.hash_user_password(user)
        new_user = user.copy()

        new_user.setdefault('groups', [])

        self.db.set('user-%s' % user_id, new_user)
        self.db.set('user_name-%s' % new_user['name'], new_user)
        user_list = set(self.db.get('user_list', []))
        user_list.add(user_id)
        self.db.set('user_list', list(user_list))
        return identity.filter_user(new_user)
Exemplo n.º 7
0
    def create_user(self, user_id, user):
        try:
            self.get_user(user_id)
        except exception.UserNotFound:
            pass
        else:
            msg = _('Duplicate ID, %s.') % user_id
            raise exception.Conflict(type='user', details=msg)

        try:
            self.get_user_by_name(user['name'], user['domain_id'])
        except exception.UserNotFound:
            pass
        else:
            msg = _('Duplicate name, %s.') % user['name']
            raise exception.Conflict(type='user', details=msg)

        user = utils.hash_user_password(user)
        new_user = user.copy()

        new_user.setdefault('groups', [])

        self.db.set('user-%s' % user_id, new_user)
        domain_id = user['domain_id']
        user_name_key = self._calc_user_name_key(new_user['name'], domain_id)
        self.db.set(user_name_key, new_user)
        self._user_id_to_domain_id.notify_user_created(user_id, domain_id)
        user_list = set(self.db.get('user_list', []))
        user_list.add(user_id)
        self.db.set('user_list', list(user_list))
        return identity.filter_user(new_user)
Exemplo n.º 8
0
 def create_user(self, user_id, user):
     user = utils.hash_user_password(user)
     with sql.session_for_write() as session:
         user_ref = model.User.from_dict(user)
         user_ref.created_at = datetime.datetime.utcnow()
         session.add(user_ref)
         return base.filter_user(user_ref.to_dict())
Exemplo n.º 9
0
 def _create_user(self, user_dict):
     user_dict['id'] = uuid.uuid4().hex
     user_dict = utils.hash_user_password(user_dict)
     with sql.session_for_write() as session:
         user_ref = model.User.from_dict(user_dict)
         session.add(user_ref)
         return base.filter_user(user_ref.to_dict())
Exemplo n.º 10
0
 def _create_user(self, user_dict, last_active_at):
     user_dict['id'] = uuid.uuid4().hex
     user_dict = utils.hash_user_password(user_dict)
     with sql.session_for_write() as session:
         user_ref = model.User.from_dict(user_dict)
         user_ref.last_active_at = last_active_at
         session.add(user_ref)
         return base.filter_user(user_ref.to_dict())
Exemplo n.º 11
0
 def _create_user(self, user_dict, password_created_at):
     user_dict = utils.hash_user_password(user_dict)
     with sql.session_for_write() as session:
         user_ref = model.User.from_dict(user_dict)
         user_ref.password_ref.created_at = password_created_at
         user_ref.password_ref.expires_at = (
             user_ref._get_password_expires_at(password_created_at))
         session.add(user_ref)
     return base.filter_user(user_ref.to_dict())
Exemplo n.º 12
0
 def create_user(self, user_id, user):
     user['name'] = clean.user_name(user['name'])
     user = utils.hash_user_password(user)
     session = self.get_session()
     with session.begin():
         user_ref = User.from_dict(user)
         session.add(user_ref)
         session.flush()
     return identity.filter_user(user_ref.to_dict())
Exemplo n.º 13
0
 def _create_user(self, user_dict, password_created_at):
     user_dict = utils.hash_user_password(user_dict)
     with sql.session_for_write() as session:
         user_ref = model.User.from_dict(user_dict)
         user_ref.password_ref.created_at = password_created_at
         user_ref.password_ref.expires_at = (
             user_ref._get_password_expires_at(password_created_at))
         session.add(user_ref)
     return base.filter_user(user_ref.to_dict())
Exemplo n.º 14
0
 def create_user(self, user_id, user):
     user['name'] = clean.user_name(user['name'])
     user = utils.hash_user_password(user)
     session = self.get_session()
     with session.begin():
         user_ref = User.from_dict(user)
         session.add(user_ref)
         session.flush()
     return identity.filter_user(user_ref.to_dict())
Exemplo n.º 15
0
 def create_user(self, user_id, user):
     user["name"] = clean.user_name(user["name"])
     if "enabled" not in user:
         user["enabled"] = True
     user = utils.hash_user_password(user)
     session = self.get_session()
     with session.begin():
         user_ref = User.from_dict(user)
         session.add(user_ref)
         session.flush()
     return identity.filter_user(user_ref.to_dict())
Exemplo n.º 16
0
 def create_user(self, user_id, user):
     user = utils.hash_user_password(user)
     with sql.session_for_write() as session:
         user_ref = model.User.from_dict(user)
         if self._change_password_required(user_ref):
             user_ref.password_ref.expires_at = datetime.datetime.utcnow()
         user_ref.created_at = datetime.datetime.utcnow()
         session.add(user_ref)
         # Set resource options passed on creation
         resource_options.resource_options_ref_to_mapper(
             user_ref, model.UserOption)
         return base.filter_user(user_ref.to_dict())
Exemplo n.º 17
0
 def update_user(self, user_id, user):
     with sql.session_for_write() as session:
         user_ref = self._get_user(session, user_id)
         old_user_dict = user_ref.to_dict()
         user = utils.hash_user_password(user)
         for k in user:
             old_user_dict[k] = user[k]
         new_user = model.User.from_dict(old_user_dict)
         for attr in model.User.attributes:
             if attr not in model.User.readonly_attributes:
                 setattr(user_ref, attr, getattr(new_user, attr))
         user_ref.extra = new_user.extra
         return base.filter_user(user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 18
0
 def update_user(self, user_id, user):
     with sql.session_for_write() as session:
         user_ref = self._get_user(session, user_id)
         old_user_dict = user_ref.to_dict()
         user = utils.hash_user_password(user)
         for k in user:
             old_user_dict[k] = user[k]
         new_user = User.from_dict(old_user_dict)
         for attr in User.attributes:
             if attr != 'id':
                 setattr(user_ref, attr, getattr(new_user, attr))
         user_ref.extra = new_user.extra
         return identity.filter_user(
             user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 19
0
    def update_user(self, user_id, user):
        session = sql.get_session()

        with session.begin():
            user_ref = self._get_user(session, user_id)
            old_user_dict = user_ref.to_dict()
            user = utils.hash_user_password(user)
            for k in user:
                old_user_dict[k] = user[k]
            new_user = User.from_dict(old_user_dict)
            for attr in User.attributes:
                if attr != 'id':
                    setattr(user_ref, attr, getattr(new_user, attr))
            user_ref.extra = new_user.extra
        return identity.filter_user(user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 20
0
 def update_user(self, user_id, user):
     with sql.session_for_write() as session:
         user_ref = self._get_user(session, user_id)
         if 'password' in user:
             self._validate_password_history(user['password'], user_ref)
         old_user_dict = user_ref.to_dict()
         user = utils.hash_user_password(user)
         for k in user:
             old_user_dict[k] = user[k]
         new_user = model.User.from_dict(old_user_dict)
         for attr in model.User.attributes:
             if attr != 'id':
                 setattr(user_ref, attr, getattr(new_user, attr))
         user_ref.extra = new_user.extra
         return base.filter_user(
             user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 21
0
    def update_user(self, user_id, user):
        session = db_session.get_session()
        if 'id' in user and user_id != user['id']:
            raise exception.ValidationError(_('Cannot change user ID'))

        with session.begin():
            user_ref = self._get_user(session, user_id)
            old_user_dict = user_ref.to_dict()
            user = utils.hash_user_password(user)
            for k in user:
                old_user_dict[k] = user[k]
            new_user = User.from_dict(old_user_dict)
            for attr in User.attributes:
                if attr != 'id':
                    setattr(user_ref, attr, getattr(new_user, attr))
            user_ref.extra = new_user.extra
        return identity.filter_user(user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 22
0
    def update_user(self, user_id, user):
        session = sql.get_session()
        if 'id' in user and user_id != user['id']:
            raise exception.ValidationError(_('Cannot change user ID'))

        with session.begin():
            user_ref = self._get_user(session, user_id)
            old_user_dict = user_ref.to_dict()
            user = utils.hash_user_password(user)
            for k in user:
                old_user_dict[k] = user[k]
            new_user = User.from_dict(old_user_dict)
            for attr in User.attributes:
                if attr != 'id':
                    setattr(user_ref, attr, getattr(new_user, attr))
            user_ref.extra = new_user.extra
        return identity.filter_user(user_ref.to_dict(include_extra_dict=True))
def upgrade(migrate_engine):
    # Upgrade operations go here. Don't create your own engine; bind
    # migrate_engine to your metadata
    meta = sql.MetaData()
    meta.bind = migrate_engine
    session = orm.sessionmaker(bind=migrate_engine)()

    for (table_name, elements) in data.DATA:
        table = sql.Table(table_name, meta, autoload=True)

        for element_data in elements:
            if table_name == 'user':
                # set up users passwords
                element_data['password'] = getpass.getpass(
                    _PASS_PROMT.format(element_data['name']))
                element_data = utils.hash_user_password(element_data)
            table.insert(element_data).execute()
            session.commit()
Exemplo n.º 24
0
    def update_user(self, user_id, user):
        if 'name' in user:
            user['name'] = clean.user_name(user['name'])
        session = self.get_session()
        if 'id' in user and user_id != user['id']:
            raise exception.ValidationError('Cannot change user ID')
        with session.begin():
            user_ref = session.query(User).filter_by(id=user_id).first()
            if user_ref is None:
                raise exception.UserNotFound(user_id=user_id)
            old_user_dict = user_ref.to_dict()
            user = utils.hash_user_password(user)
            for k in user:
                old_user_dict[k] = user[k]
            new_user = User.from_dict(old_user_dict)

            user_ref.name = new_user.name
            user_ref.extra = new_user.extra
            session.flush()
        return identity.filter_user(user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 25
0
    def update_user(self, user_id, user):
        if 'name' in user:
            user['name'] = clean.user_name(user['name'])
        session = self.get_session()
        if 'id' in user and user_id != user['id']:
            raise exception.ValidationError('Cannot change user ID')
        with session.begin():
            user_ref = session.query(User).filter_by(id=user_id).first()
            if user_ref is None:
                raise exception.UserNotFound(user_id=user_id)
            old_user_dict = user_ref.to_dict()
            user = utils.hash_user_password(user)
            for k in user:
                old_user_dict[k] = user[k]
            new_user = User.from_dict(old_user_dict)

            user_ref.name = new_user.name
            user_ref.extra = new_user.extra
            session.flush()
        return identity.filter_user(user_ref.to_dict())
Exemplo n.º 26
0
 def update_user(self, user_id, user):
     if 'name' in user:
         existing = self.db.get('user_name-%s' % user['name'])
         if existing and user_id != existing['id']:
             msg = 'Duplicate name, %s.' % user['name']
             raise exception.Conflict(type='user', details=msg)
     # get the old name and delete it too
     try:
         old_user = self.db.get('user-%s' % user_id)
     except exception.NotFound:
         raise exception.UserNotFound(user_id=user_id)
     new_user = old_user.copy()
     user = utils.hash_user_password(user)
     new_user.update(user)
     if new_user['id'] != user_id:
         raise exception.ValidationError('Cannot change user ID')
     self.db.delete('user_name-%s' % old_user['name'])
     self.db.set('user-%s' % user_id, new_user)
     self.db.set('user_name-%s' % new_user['name'], new_user)
     return new_user
Exemplo n.º 27
0
 def update_user(self, user_id, user):
     if 'name' in user:
         existing = self.db.get('user_name-%s' % user['name'])
         if existing and user_id != existing['id']:
             msg = 'Duplicate name, %s.' % user['name']
             raise exception.Conflict(type='user', details=msg)
     # get the old name and delete it too
     try:
         old_user = self.db.get('user-%s' % user_id)
     except exception.NotFound:
         raise exception.UserNotFound(user_id=user_id)
     new_user = old_user.copy()
     user = utils.hash_user_password(user)
     new_user.update(user)
     if new_user['id'] != user_id:
         raise exception.ValidationError('Cannot change user ID')
     self.db.delete('user_name-%s' % old_user['name'])
     self.db.set('user-%s' % user_id, new_user)
     self.db.set('user_name-%s' % new_user['name'], new_user)
     return new_user
Exemplo n.º 28
0
 def update_user(self, user_id, user):
     if "name" in user:
         user["name"] = clean.user_name(user["name"])
     session = self.get_session()
     if "id" in user and user_id != user["id"]:
         raise exception.ValidationError("Cannot change user ID")
     with session.begin():
         user_ref = session.query(User).filter_by(id=user_id).first()
         if user_ref is None:
             raise exception.UserNotFound(user_id=user_id)
         old_user_dict = user_ref.to_dict()
         user = utils.hash_user_password(user)
         for k in user:
             old_user_dict[k] = user[k]
         new_user = User.from_dict(old_user_dict)
         for attr in User.attributes:
             if attr != "id":
                 setattr(user_ref, attr, getattr(new_user, attr))
         user_ref.extra = new_user.extra
         session.flush()
     return identity.filter_user(user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 29
0
 def update_user(self, user_id, user):
     try:
         domain_id = self._user_id_to_domain_id.get(user_id)
     except exception.NotFound:
         raise exception.UserNotFound(user_id=user_id)
     if 'name' in user:
         user_key = self._calc_user_name_key(user['name'], domain_id)
         existing = self.db.get(user_key, False)
         if existing and user_id != existing['id']:
             msg = _('Duplicate name, %s.') % user['name']
             raise exception.Conflict(type='user', details=msg)
     # get the old name and delete it too
     old_user = self.db.get('user-%s' % user_id)
     new_user = old_user.copy()
     user = utils.hash_user_password(user)
     new_user.update(user)
     self.db.delete(self._calc_user_name_key(old_user['name'], domain_id))
     self.db.set('user-%s' % user_id, new_user)
     user_name_key = self._calc_user_name_key(new_user['name'], domain_id)
     self.db.set(user_name_key, new_user)
     return identity.filter_user(new_user)
Exemplo n.º 30
0
 def update_user(self, user_id, user):
     try:
         domain_id = self._user_id_to_domain_id.get(user_id)
     except exception.NotFound:
         raise exception.UserNotFound(user_id=user_id)
     if 'name' in user:
         user_key = self._calc_user_name_key(user['name'], domain_id)
         existing = self.db.get(user_key, False)
         if existing and user_id != existing['id']:
             msg = _('Duplicate name, %s.') % user['name']
             raise exception.Conflict(type='user', details=msg)
     # get the old name and delete it too
     old_user = self.db.get('user-%s' % user_id)
     new_user = old_user.copy()
     user = utils.hash_user_password(user)
     new_user.update(user)
     self.db.delete(self._calc_user_name_key(old_user['name'], domain_id))
     self.db.set('user-%s' % user_id, new_user)
     user_name_key = self._calc_user_name_key(new_user['name'], domain_id)
     self.db.set(user_name_key, new_user)
     return identity.filter_user(new_user)
Exemplo n.º 31
0
 def update_user(self, user_id, user):
     if 'name' in user:
         user['name'] = clean.user_name(user['name'])
     session = self.get_session()
     if 'id' in user and user_id != user['id']:
         raise exception.ValidationError('Cannot change user ID')
     # FIXME(henry-nash) Think about how we detect potential name clash
     # when we move domains
     with session.begin():
         user_ref = session.query(User).filter_by(id=user_id).first()
         if user_ref is None:
             raise exception.UserNotFound(user_id=user_id)
         old_user_dict = user_ref.to_dict()
         user = utils.hash_user_password(user)
         for k in user:
             old_user_dict[k] = user[k]
         new_user = User.from_dict(old_user_dict)
         for attr in User.attributes:
             if attr != 'id':
                 setattr(user_ref, attr, getattr(new_user, attr))
         user_ref.extra = new_user.extra
         session.flush()
     return identity.filter_user(user_ref.to_dict(include_extra_dict=True))
Exemplo n.º 32
0
 def update_user(self, user_id, user):
     try:
         domain_id = self._user_id_to_domain_id.get(user_id)
     except exception.NotFound:
         raise exception.UserNotFound(user_id=user_id)
     if "name" in user:
         user_key = self._calc_user_name_key(user["name"], domain_id)
         existing = self.db.get(user_key, False)
         if existing and user_id != existing["id"]:
             msg = _("Duplicate name, %s.") % user["name"]
             raise exception.Conflict(type="user", details=msg)
     # get the old name and delete it too
     old_user = self.db.get("user-%s" % user_id)
     new_user = old_user.copy()
     user = utils.hash_user_password(user)
     new_user.update(user)
     if new_user["id"] != user_id:
         raise exception.ValidationError("Cannot change user ID")
     self.db.delete(self._calc_user_name_key(old_user["name"], domain_id))
     self.db.set("user-%s" % user_id, new_user)
     user_name_key = self._calc_user_name_key(new_user["name"], domain_id)
     self.db.set(user_name_key, new_user)
     return identity.filter_user(new_user)
Exemplo n.º 33
0
 def test_hash_user_password_with_null_password(self):
     user = self._create_test_user(password=None)
     hashed = common_utils.hash_user_password(user)
     self.assertEqual(user, hashed)
Exemplo n.º 34
0
 def create_user(self, user_id, user):
     user = utils.hash_user_password(user)
     with sql.session_for_write() as session:
         user_ref = User.from_dict(user)
         session.add(user_ref)
         return identity.filter_user(user_ref.to_dict())
Exemplo n.º 35
0
 def test_hash_user_password_with_empty_password(self):
     password = ""
     user = self._create_test_user(password=password)
     user_hashed = utils.hash_user_password(user)
     password_hashed = user_hashed["password"]
     self.assertTrue(utils.check_password(password, password_hashed))
Exemplo n.º 36
0
 def test_hash_user_password_without_password(self):
     user = self._create_test_user()
     hashed = utils.hash_user_password(user)
     self.assertEqual(user, hashed)
Exemplo n.º 37
0
 def test_hash_user_password_with_empty_password(self):
     password = ''
     user = self._create_test_user(password=password)
     user_hashed = common_utils.hash_user_password(user)
     password_hashed = user_hashed['password']
     self.assertTrue(common_utils.check_password(password, password_hashed))
Exemplo n.º 38
0
 def test_hash_user_password_without_password(self):
     user = self._create_test_user()
     hashed = utils.hash_user_password(user)
     self.assertEqual(user, hashed)
Exemplo n.º 39
0
 def test_hash_user_password_with_empty_password(self):
     password = ''
     user = self._create_test_user(password=password)
     user_hashed = common_utils.hash_user_password(user)
     password_hashed = user_hashed['password']
     self.assertTrue(common_utils.check_password(password, password_hashed))
Exemplo n.º 40
0
 def test_hash_user_password_with_null_password(self):
     user = self._create_test_user(password=None)
     hashed = common_utils.hash_user_password(user)
     self.assertEqual(user, hashed)
Exemplo n.º 41
0
 def create_user(self, user_id, user):
     user = utils.hash_user_password(user)
     with sql.session_for_write() as session:
         user_ref = User.from_dict(user)
         session.add(user_ref)
         return identity.filter_user(user_ref.to_dict())