useradmin/filestore/src/main/java/org/apache/felix/useradmin/filestore/RoleRepositorySerializer.java

/**
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You 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.
 */
package org.apache.felix.useradmin.filestore;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;


import org.apache.felix.useradmin.RoleFactory;
import org.osgi.service.useradmin.Group;
import org.osgi.service.useradmin.Role;
import org.osgi.service.useradmin.User;

/**
 * Provides a serializer for a role repository.
 */
final class RoleRepositorySerializer {
    
    private static final int VALUE_TYPE_STRING = 1;
    private static final int VALUE_TYPE_BARRAY = 2; 

    /**
     * Deserializes a given input stream.
     * 
     * @param is the input stream to deserialize, cannot be <code>null</code>.
     * @return a {@link Map} representing the role repository. It provides a 
     *         mapping between the name of the role as key and the associated
     *         role as value.
     * @throws IOException in case of I/O problems;
     * @throws IllegalArgumentException in case the given stream was <code>null</code>.
     */
    public Map deserialize(InputStream is) throws IOException {
        if (is == null) {
            throw new IllegalArgumentException("InputStream cannot be null!");
        }
        return readRepository(new DataInputStream(is));
    }

    /**
     * Serializes a given map to the given output stream.
     * 
     * @param roleRepository the repository to serialize, cannot be <code>null</code>;
     * @param os the output stream to serialize to, cannot be  <code>null</code>.
     * @throws IOException in case of I/O problems;
     * @throws IllegalArgumentException in case the given parameter was <code>null</code>.
     */
    public void serialize(Map roleRepository, OutputStream os) throws IOException {
        if (roleRepository == null) {
            throw new IllegalArgumentException("Map cannot be null!");
        }
        if (os == null) {
            throw new IllegalArgumentException("OutputStream cannot be null!");
        }
        writeRepository(roleRepository, new DataOutputStream(os));
    }
    
    /**
     * Adds all groups, based on the given stub groups.
     * 
     * @param repository the repository to add the groups to, cannot be <code>null</code>;
     * @param stubGroups the list with stub groups to replace, cannot be <code>null</code>.
     * @throws IOException in case a referenced role was not found in the repository.
     */
    private void addGroups(Map repository, List stubGroups) throws IOException {
        // First create "empty" groups in the repository; we'll fill them in later on...
        Iterator sgIter = stubGroups.iterator();
        while (sgIter.hasNext()) {
            StubGroupImpl stubGroup = (StubGroupImpl) sgIter.next();

            Group group = (Group) RoleFactory.createRole(Role.GROUP, stubGroup.getName());
            copyDictionary(stubGroup.getProperties(), group.getProperties());
            copyDictionary(stubGroup.getCredentials(), group.getCredentials());

            repository.put(group.getName(), group);
        }
        
        int origSize = stubGroups.size();
        while (!stubGroups.isEmpty()) {
            List copy = new ArrayList(stubGroups);
            
            int size = copy.size();
            for (int i = 0; i < size; i++) {
                StubGroupImpl stubGroup = (StubGroupImpl) copy.get(i);

                Group group = (Group) repository.get(stubGroup.getName());
                if (group != null) {
                    resolveGroupMembers(stubGroup, group, repository);
                    stubGroups.remove(stubGroup);
                }
            }

            // In case we didn't resolve any groups; we should fail...
            if (origSize == stubGroups.size()) {
                throw new IOException("Failed to resolve groups: " + stubGroups);
            }

            origSize = stubGroups.size();
        }
    }
    
    /**
     * Converts a given {@link Dictionary} implementation to a {@link Map} implementation.
     * 
     * @param dictionary the dictionary to convert, cannot be <code>null</code>.
     * @return a {@link Map} instance with all the same key-value pairs as the given dictionary, never <code>null</code>.
     */
    private Map convertToMap(Dictionary dictionary) {
        Map result = new HashMap();
        if (dictionary instanceof Map) {
            result.putAll((Map) dictionary);
        } else {
            Enumeration keyEnum = dictionary.keys();
            while (keyEnum.hasMoreElements()) {
                Object key = keyEnum.nextElement();
                result.put(key, dictionary.get(key));
            }
        }
        return result;
    }
    
    /**
     * Copies the contents of a given dictionary to a given other dictionary.
     * 
     * @param source the dictionary to copy from;
     * @param dest the dictionary to copy to.
     */
    private void copyDictionary(Dictionary source, Dictionary dest) {
        Enumeration keys = source.keys();
        while (keys.hasMoreElements()) {
            Object key = keys.nextElement();
            Object value = source.get(key);
            dest.put(key, value);
        }
    }

    /**
     * Returns the role with the given name from the given repository.
     * 
     * @param repository the repository to obtain the roles from, cannot be <code>null</code>;
     * @param name the name of the role to retrieve, cannot be <code>null</code>.
     * @return a role matching the given name, or <code>null</code> if no such role exists.
     */
    private Role getRoleFromRepository(Map repository, String name) {
        Role role;
        if (Role.USER_ANYONE.equals(name)) {
            role = RoleFactory.createRole(Role.USER_ANYONE);
        } else {
            role = (Role) repository.get(name);
        }
        return role;
    }
    
    /**
     * Reads and fills a given dictionary.
     * 
     * @param dict the dictionary to read & fill, cannot be <code>null</code>;
     * @param dis the input stream to read the data from, cannot be <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private void readDictionary(Dictionary dict, DataInputStream dis) throws IOException {
        // Read the number of entries...
        int count = dis.readInt();
        while (count-- > 0) {
            // Read the name of the key...
            String key = dis.readUTF();
            // Read the type of the value...
            int type = dis.read();
            // Read the value & add the actual entry...
            if (VALUE_TYPE_BARRAY == type) {
                int length = dis.readInt();
                byte[] value = new byte[length];
                if (dis.read(value, 0, length) != length) {
                    throw new IOException("Invalid repository; failed to correctly read dictionary!");
                }
                dict.put(key, value);
            } else if (VALUE_TYPE_STRING == type) {
                dict.put(key, dis.readUTF());
            }
        }
    }

    /**
     * Reads a (stub) group from the given input stream.
     * 
     * @param dis the input stream to read the data from, cannot be <code>null</code>.
     * @return the read (stub) group, never <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private StubGroupImpl readGroup(DataInputStream dis) throws IOException {
        StubGroupImpl group = new StubGroupImpl(dis.readUTF());
        
        readDictionary(group.getProperties(), dis);
        readDictionary(group.getCredentials(), dis);
        
        // Read the number of basic members...
        int count = dis.readInt();
        while (count-- > 0) {
            group.addMember(dis.readUTF());
        }
        
        // Read the number of required members...
        count = dis.readInt();
        while (count-- > 0) {
            group.addRequiredMember(dis.readUTF());
        }
        
        return group;
    }

    /**
     * Reads the entire repository from the given input stream.
     * 
     * @param dis the input stream to read the data from, cannot be <code>null</code>.
     * @return the repository {@link Map}, never <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private Map readRepository(DataInputStream dis) throws IOException {
        Map repository = new HashMap();
        
        int entryCount = dis.readInt();
        
        List stubGroups = new ArrayList();
        
        // Keep reading until no more types can be read...
        while (entryCount-- > 0) {
            int type = dis.readInt();
            
            Role role = null;
            if (Role.GROUP == type) {
                stubGroups.add(readGroup(dis));
            } else if (Role.USER == type) {
                role = readUser(dis);
            } else {
                role = readRole(dis);
            }
            
            if (role != null) {
                repository.put(role.getName(), role);
            }
        }
        
        // Post processing stage: replace all stub groups with real group implementations...
        addGroups(repository, stubGroups);
        
        return repository;
    }
    
    /**
     * Reads a role from the given input stream.
     * 
     * @param dis the input stream to read the data from, cannot be <code>null</code>.
     * @return the read role, never <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private Role readRole(DataInputStream dis) throws IOException {
        Role role = RoleFactory.createRole(Role.ROLE, dis.readUTF());
        
        readDictionary(role.getProperties(), dis);
        
        return role;
    }

    /**
     * Reads a user from the given input stream.
     * 
     * @param dis the input stream to read the data from, cannot be <code>null</code>.
     * @return the read user, never <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private User readUser(DataInputStream dis) throws IOException {
        User user = (User) RoleFactory.createRole(Role.USER, dis.readUTF());
        
        readDictionary(user.getProperties(), dis);
        readDictionary(user.getCredentials(), dis);
        
        return user;
    }

    /**
     * Resolves all basic and required group members for a given group, based on the names from the given stub group.
     * 
     * @param stubGroup the stub group to convert, cannot be <code>null</code>;
     * @param repository the repository to take the roles from, cannot be <code>null</code>.
     * @return a concrete {@link Group} instance with all members resolved, or <code>null</code> if not all members could be resolved.
     * @throws IOException in case a referenced role was not found in the repository.
     */
    private void resolveGroupMembers(StubGroupImpl stubGroup, Group group, Map repository) throws IOException {
        List names = stubGroup.getMemberNames();
        int size = names.size();

        for (int i = 0; i < size; i++) {
            String name = (String) names.get(i);
            Role role = getRoleFromRepository(repository, name);
            if (role == null) {
                throw new IOException("Unable to find referenced basic member: " + name);
            }
            group.addMember(role);
        }
        
        names = stubGroup.getRequiredMemberNames();
        size = names.size();
        
        for (int i = 0; i < size; i++) {
            String name = (String) names.get(i);
            Role role = getRoleFromRepository(repository, name);
            if (role == null) {
                throw new IOException("Unable to find referenced required member: " + name);
            }
            group.addRequiredMember(role);
        }
    }

    /**
     * Writes a given dictionary to the given output stream.
     * 
     * @param dict the dictionary to write, cannot be <code>null</code>;
     * @param dos the output stream to write the data to, cannot be <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private void writeDictionary(Dictionary dict, DataOutputStream dos) throws IOException {
        Map properties = convertToMap(dict);
        
        Set entries = properties.entrySet();
        int size = entries.size();

        // Write the number of entries...
        dos.writeInt(size);
        
        Iterator entriesIter = entries.iterator();
        while (entriesIter.hasNext()) {
            Map.Entry entry = (Entry) entriesIter.next();
            
            dos.writeUTF((String) entry.getKey());
            
            Object value = entry.getValue();
            if (value instanceof String) {
                dos.write(VALUE_TYPE_STRING);
                dos.writeUTF((String) value);
            } else if (value instanceof byte[]) {
                dos.write(VALUE_TYPE_BARRAY);
                dos.writeInt(((byte[]) value).length);
                dos.write((byte[]) value);
            }
        }
    }

    /**
     * Writes a given group to the given output stream.
     * 
     * @param group the group to write, cannot be <code>null</code>.
     * @param dos the output stream to write the data to, cannot be <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private void writeGroup(Group group, DataOutputStream dos) throws IOException {
        dos.writeUTF(group.getName());

        writeDictionary(group.getProperties(), dos);
        writeDictionary(group.getCredentials(), dos);
        
        Role[] m = group.getMembers();

        if (m == null) {
            dos.writeInt(0);
        } else {
            // Write the number of basic members...
            dos.writeInt(m.length);
            // Write the names of the basic members...
            for (int i = 0; i < m.length; i++) {
                dos.writeUTF(m[i].getName());
            }
        }

        m = group.getRequiredMembers();
        
        if (m == null) {
            dos.writeInt(0);
        } else {
            // Write the number of required members...
            dos.writeInt(m.length);
            // Write the names of the required members...
            for (int i = 0; i < m.length; i++) {
                dos.writeUTF(m[i].getName());
            }
        }
    }
    
    /**
     * Writes the given repository to the given output stream.
     * 
     * @param repository the repository to write, cannot be <code>null</code>;
     * @param dos the output stream to write the data to, cannot be <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private void writeRepository(Map repository, DataOutputStream dos) throws IOException {
        Collection values = repository.values();
        Iterator valuesIter = values.iterator();
        
        // Write the total number of entries in our repository first...
        dos.writeInt(values.size());
        
        while (valuesIter.hasNext()) {
            Role role = (Role) valuesIter.next();
            
            int type = role.getType();
            
            dos.writeInt(type);
            
            if (Role.GROUP == type) {
                writeGroup((Group) role, dos);
            } else if (Role.USER == type) {
                writeUser((User) role, dos);
            } else {
                writeRole(role, dos);
            }
        }
    }
    
    /**
     * Writes a given role to the given output stream.
     * 
     * @param role the role to write, cannot be <code>null</code>.
     * @param dos the output stream to write the data to, cannot be <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private void writeRole(Role role, DataOutputStream dos) throws IOException {
        dos.writeUTF(role.getName());

        writeDictionary(role.getProperties(), dos);
    }
    
    /**
     * Writes a given user to the given output stream.
     * 
     * @param user the user to write, cannot be <code>null</code>.
     * @param dos the output stream to write the data to, cannot be <code>null</code>.
     * @throws IOException in case of I/O problems.
     */
    private void writeUser(User user, DataOutputStream dos) throws IOException {
        dos.writeUTF(user.getName());

        writeDictionary(user.getProperties(), dos);
        writeDictionary(user.getCredentials(), dos);
    }
}