diff --git a/src/main/java/net/onrc/onos/core/topology/ImmutableTopologySnapshot.java b/src/main/java/net/onrc/onos/core/topology/ImmutableTopologySnapshot.java
new file mode 100644
index 0000000..6fd8d03
--- /dev/null
+++ b/src/main/java/net/onrc/onos/core/topology/ImmutableTopologySnapshot.java
@@ -0,0 +1,784 @@
+package net.onrc.onos.core.topology;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import javax.annotation.concurrent.Immutable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+import net.floodlightcontroller.core.IFloodlightProviderService.Role;
+import net.floodlightcontroller.util.MACAddress;
+import net.onrc.onos.core.util.Dpid;
+import net.onrc.onos.core.util.LinkTuple;
+import net.onrc.onos.core.util.OnosInstanceId;
+import net.onrc.onos.core.util.PortNumber;
+import net.onrc.onos.core.util.SwitchPort;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.Multimap;
+
+/**
+ * Immutable Topology snapshot.
+ */
+@Immutable
+public final class ImmutableTopologySnapshot
+                implements ImmutableTopology, ImmutableInternalTopology {
+
+    private static final Logger log = LoggerFactory
+                .getLogger(ImmutableTopologySnapshot.class);
+
+    /**
+     * Empty Topology.
+     */
+    public static final ImmutableTopologySnapshot EMPTY = new ImmutableTopologySnapshot();
+
+    // interface adaptor
+    private final BaseTopologyAdaptor adaptor;
+
+
+    // Mastership info
+    // Dpid -> [ (InstanceID, Role) ]
+    private final Map<Dpid, SortedSet<MastershipEvent>> mastership;
+
+    // DPID -> Switch
+    private final Map<Dpid, SwitchEvent> switches;
+    private final Map<Dpid, Map<PortNumber, PortEvent>> ports;
+
+    // Index from Port to Host
+    private final Multimap<SwitchPort, HostEvent> hosts;
+    private final Map<MACAddress, HostEvent> mac2Host;
+
+    // SwitchPort -> (type -> Link)
+    private final Map<SwitchPort, Map<String, LinkEvent>> outgoingLinks;
+    private final Map<SwitchPort, Map<String, LinkEvent>> incomingLinks;
+
+
+    // TODO Slice out Topology Builder interface.
+    //      May need to change put*, remove* return values.
+    /**
+     * Immutable Topology Builder.
+     */
+    @NotThreadSafe
+    public static final class Builder {
+
+        private final ImmutableTopologySnapshot current;
+
+        /**
+         * Builder to start from empty topology.
+         */
+        private Builder() {
+            this.current = new ImmutableTopologySnapshot(EMPTY);
+        }
+
+        /**
+         * Builder to start building from existing topology.
+         *
+         * @param original topology to start building from
+         */
+        private Builder(final ImmutableTopologySnapshot original) {
+            // original must be internally mutable instance
+            this.current = original;
+        }
+
+
+        /**
+         * Gets the current InternalTopology being built.
+         *
+         * @return InternalTopology
+         */
+        BaseInternalTopology getCurrentInternal() {
+            return this.current;
+        }
+
+        /**
+         * Gets the current Topology being built.
+         *
+         * @return Topology
+         */
+        BaseTopology getCurrent() {
+            return this.current;
+        }
+
+        /**
+         * Builds the {@link ImmutableTopologySnapshot}.
+         *
+         * @return ImmutableTopologySnapshot
+         */
+        public ImmutableTopologySnapshot build() {
+            return new ImmutableTopologySnapshot(this);
+        }
+
+        // TODO Define error conditions for topology mutation
+        //  - Element was already gone:
+        //          Treat as error or silently ignore?
+        //  - Removing element, where child element still exist:
+        //          Treat as error or silently remove?
+
+        /**
+         * Puts a SwitchEvent.
+         *
+         * @param sw Switch to add. (Will be frozen if not already)
+         * @return Builder
+         */
+        public Builder putSwitch(SwitchEvent sw) {
+            checkNotNull(sw);
+
+            current.switches.put(sw.getDpid(), sw.freeze());
+            if (current.ports.get(sw.getDpid()) == null) {
+                current.ports.put(sw.getDpid(), new HashMap<PortNumber, PortEvent>());
+            }
+            return this;
+        }
+
+        /**
+         * Removes a SwitchEvent from this snapshot.
+         * <p>
+         * Will also remove ports, if it has not been removed already.
+         *
+         * @param dpid Switch DPID
+         * @return Builder
+         */
+        public Builder removeSwitch(Dpid dpid) {
+            checkNotNull(dpid);
+
+            current.switches.remove(dpid);
+            Map<PortNumber, PortEvent> removedPorts = current.ports.remove(dpid);
+            if (removedPorts != null && !removedPorts.isEmpty()) {
+                log.warn("Some ports were removed as side-effect of #removeSwitch({})", dpid);
+            }
+            return this;
+        }
+
+        /**
+         * Puts a PortEvent.
+         *
+         * @param port Port to add. (Will be frozen if not already)
+         * @return Builder
+         */
+        public Builder putPort(PortEvent port) {
+            checkNotNull(port);
+
+            // TODO check parent port and throw TopologyMutationFailed
+
+            Map<PortNumber, PortEvent> portMap = current.ports.get(port.getDpid());
+            if (portMap == null) {
+                // shouldn't happen but just to be sure
+                portMap = new HashMap<>();
+                current.ports.put(port.getDpid(), portMap);
+            }
+            portMap.put(port.getPortNumber(), port.freeze());
+            return this;
+        }
+
+        /**
+         * Removes a PortEvent from this snapshot.
+         *
+         * @param port SwitchPort to remove
+         * @return Builder
+         */
+        public Builder removePort(SwitchPort port) {
+            checkNotNull(port);
+
+            removePort(port.getDpid(), port.getPortNumber());
+            return this;
+        }
+
+        /**
+         * Removes a PortEvent from this snapshot.
+         * <p>
+         * Will also remove ports, if it has not been removed already.
+         *
+         * @param dpid Switch DPID
+         * @param number PortNumber
+         * @return Builder
+         */
+        public Builder removePort(Dpid dpid, PortNumber number) {
+            checkNotNull(dpid);
+            checkNotNull(number);
+
+            // TODO sanity check:
+            // - Links should be removed
+            // - Host attachment point should be updated.
+            Map<PortNumber, PortEvent> portMap = current.ports.get(dpid);
+            if (portMap != null) {
+                portMap.remove(number);
+            }
+            return this;
+        }
+
+        /**
+         * Puts a LinkEvent.
+         *
+         * @param link LinkEvent
+         * @return Builder
+         */
+        public Builder putLink(LinkEvent link) {
+            checkNotNull(link);
+
+            // TODO check ports and throw TopologyMutationFailed
+
+            // TODO remove host or ignore?
+
+            // TODO Add sanity check?
+            // - There cannot be 2 links in same direction between a port pair.
+            putLinkMap(current.outgoingLinks, link.getSrc(), link);
+            putLinkMap(current.incomingLinks, link.getDst(), link);
+            return this;
+        }
+
+        /**
+         * Helper method to update outgoingLinks, incomingLinks.
+         *
+         * @param linkMap outgoingLinks or incomingLinks to update
+         * @param port {@code linkMap} key to update
+         * @param link Link to add
+         */
+        private void putLinkMap(Map<SwitchPort, Map<String, LinkEvent>> linkMap,
+                                SwitchPort port, LinkEvent link) {
+
+            Map<String, LinkEvent> linksOnPort = linkMap.get(port);
+            if (linksOnPort == null) {
+                linksOnPort = new HashMap<String, LinkEvent>();
+            }
+            linksOnPort.put(link.getType(), link);
+        }
+
+        /**
+         * Removes a LinkEvent from this snapshot.
+         *
+         * @param link Link to remove
+         * @param type type of link to remove
+         * @return Builder
+         */
+        public Builder removeLink(LinkTuple link, String type) {
+            checkNotNull(link);
+
+            Map<String, LinkEvent> portLinks
+                = current.outgoingLinks.get(link.getSrc());
+            if (portLinks != null) {
+                // no conditional update here
+                portLinks.remove(type);
+            }
+            portLinks
+                = current.incomingLinks.get(link.getDst());
+            if (portLinks != null) {
+                // no conditional update here
+                portLinks.remove(type);
+            }
+            return this;
+        }
+
+        /**
+         * Removes a LinkEvent from this snapshot.
+         *
+         * @param link Link to remove
+         * @return Builder
+         */
+        public Builder removeLink(LinkTuple link) {
+            checkNotNull(link);
+
+            Map<String, LinkEvent> links = current.outgoingLinks.get(link.getSrc());
+            if (links == null) {
+                // nothing to do
+                return this;
+            }
+
+            for (LinkEvent linkEvt : links.values()) {
+                removeLink(linkEvt.getLinkTuple(), linkEvt.getType());
+            }
+            return this;
+        }
+
+        /**
+         * Puts a HostEvent.
+         * <p>
+         * Removes attachment points for previous HostEvent and update
+         * them with new HostEvent
+         *
+         * @param host HostEvent
+         * @return Builder
+         */
+        public Builder putHost(HostEvent host) {
+            checkNotNull(host);
+
+            // TODO check Link does not exist on port and throw TopologyMutationFailed
+
+            // Host cannot be simply put() to replace instance
+            // since we need to track attachment point update.
+            // remove -> put to replace all attachment points, etc. for now.
+
+            // remove old attachment points
+            removeHost(host.getMac());
+
+            // add new attachment points
+            for (SwitchPort port : host.getAttachmentPoints()) {
+                current.hosts.put(port, host);
+            }
+            current.mac2Host.put(host.getMac(), host);
+            return this;
+        }
+
+        /**
+         * Removes a HostEvent from this snapshot.
+         *
+         * @param mac MACAddress of the Host to remove
+         * @return Builder
+         */
+        public Builder removeHost(MACAddress mac) {
+            checkNotNull(mac);
+
+            HostEvent host = current.mac2Host.remove(mac);
+            if (host != null) {
+                for (SwitchPort port : host.getAttachmentPoints()) {
+                    current.hosts.remove(port, host);
+                }
+            }
+            return this;
+        }
+
+        /**
+         * Puts a mastership change event.
+         *
+         * @param master MastershipEvent
+         * @return Builder
+         */
+        public Builder putSwitchMastershipEvent(MastershipEvent master) {
+            checkNotNull(master);
+
+            SortedSet<MastershipEvent> candidates
+                = current.mastership.get(master.getDpid());
+            if (candidates == null) {
+                // SortedSet, customized so that MASTER MastershipEvent appear
+                // earlier during iteration.
+                candidates = new TreeSet<>(new MastershipEvent.MasterFirstComparator());
+            }
+
+            // always replace
+            candidates.remove(master);
+            candidates.add(master);
+            return this;
+        }
+
+        /**
+         * Removes a mastership change event.
+         * <p>
+         * Note: Only Dpid and OnosInstanceId will be used to identify the
+         * {@link MastershipEvent} to remove.
+         *
+         * @param master {@link MastershipEvent} to remove. (Role is ignored)
+         * @return Builder
+         */
+        public Builder removeSwitchMastershipEvent(MastershipEvent master) {
+            checkNotNull(master);
+
+            SortedSet<MastershipEvent> candidates
+                = current.mastership.get(master.getDpid());
+            if (candidates == null) {
+                // nothing to do
+                return this;
+            }
+            candidates.remove(master);
+
+            return this;
+        }
+    }
+
+    /**
+     * Create an empty Topology.
+     */
+    private ImmutableTopologySnapshot() {
+        mastership = Collections.emptyMap();
+        switches = Collections.emptyMap();
+        ports = Collections.emptyMap();
+        hosts = ImmutableMultimap.of();
+        mac2Host = Collections.emptyMap();
+        outgoingLinks = Collections.emptyMap();
+        incomingLinks = Collections.emptyMap();
+        this.adaptor = new BaseTopologyAdaptor(this);
+    }
+
+    /**
+     * Constructor to create instance from Builder.
+     *
+     * @param builder Builder
+     */
+    private ImmutableTopologySnapshot(final Builder builder) {
+
+        // TODO Change to move semantics to avoid shallow copying or
+        // Shallow copies should be created using
+        // Immutable variant or wrapped by Unmodifiable.
+        //
+        // If we switched to Immutable* Collections,
+        // wrapping by Collections.unmodifiableCollection() can be removed.
+
+        // shallow copy Set in Map
+        this.mastership = new HashMap<>(builder.current.mastership.size());
+        for (Entry<Dpid, SortedSet<MastershipEvent>> e
+                    : builder.current.mastership.entrySet()) {
+            this.mastership.put(e.getKey(), new TreeSet<>(e.getValue()));
+        }
+
+        this.switches = new HashMap<>(builder.current.switches);
+
+        // shallow copy Map in Map
+        this.ports = new HashMap<>(builder.current.ports.size());
+        for (Entry<Dpid, Map<PortNumber, PortEvent>> entry
+                    : builder.current.ports.entrySet()) {
+            this.ports.put(entry.getKey(), new HashMap<>(entry.getValue()));
+        }
+
+        this.hosts =
+                HashMultimap.<SwitchPort, HostEvent>create(builder.current.hosts);
+        this.mac2Host = new HashMap<>(builder.current.mac2Host);
+
+        // shallow copy Map in Map
+        this.outgoingLinks = new HashMap<>(builder.current.outgoingLinks.size());
+        for (Entry<SwitchPort, Map<String, LinkEvent>> entry
+                : builder.current.outgoingLinks.entrySet()) {
+            this.outgoingLinks.put(entry.getKey(), new HashMap<>(entry.getValue()));
+        }
+
+        // shallow copy Map in Map
+        this.incomingLinks = new HashMap<>(builder.current.incomingLinks.size());
+        for (Entry<SwitchPort, Map<String, LinkEvent>> entry
+                : builder.current.incomingLinks.entrySet()) {
+            this.incomingLinks.put(entry.getKey(), new HashMap<>(entry.getValue()));
+        }
+
+        this.adaptor = new BaseTopologyAdaptor(this);
+    }
+
+    /**
+     * Create internally mutable shallow copy of given instance.
+     * <p>
+     * Note: only expected to be used by Builder.
+     *
+     * @param original instance to copy from
+     */
+    private ImmutableTopologySnapshot(ImmutableTopologySnapshot original) {
+
+        // shallow copy Set in Map
+        this.mastership = new HashMap<>(original.mastership.size());
+        for (Entry<Dpid, SortedSet<MastershipEvent>> e
+                        : original.mastership.entrySet()) {
+            this.mastership.put(e.getKey(), new TreeSet<>(e.getValue()));
+        }
+
+        this.switches = new HashMap<>(original.switches);
+
+        // shallow copy Map in Map
+        this.ports = new HashMap<>(original.ports.size());
+        for (Entry<Dpid, Map<PortNumber, PortEvent>> entry
+                : original.ports.entrySet()) {
+            this.ports.put(entry.getKey(), new HashMap<>(entry.getValue()));
+        }
+
+        this.hosts =
+                HashMultimap.<SwitchPort, HostEvent>create(original.hosts);
+        this.mac2Host = new HashMap<>(original.mac2Host);
+
+        // shallow copy Map in Map
+        this.outgoingLinks = new HashMap<>(original.outgoingLinks.size());
+        for (Entry<SwitchPort, Map<String, LinkEvent>> entry
+                : original.outgoingLinks.entrySet()) {
+            this.outgoingLinks.put(entry.getKey(), new HashMap<>(entry.getValue()));
+        }
+
+        // shallow copy Map in Map
+        this.incomingLinks = new HashMap<>(original.incomingLinks.size());
+        for (Entry<SwitchPort, Map<String, LinkEvent>> entry
+                : original.incomingLinks.entrySet()) {
+            this.incomingLinks.put(entry.getKey(), new HashMap<>(entry.getValue()));
+        }
+
+        this.adaptor = new BaseTopologyAdaptor(this);
+    }
+
+
+    /**
+     * Gets the builder starting from empty topology.
+     *
+     * @return Builder
+     */
+    public static Builder initialBuilder() {
+        return new Builder();
+    }
+
+    /**
+     * Gets the builder starting from this topology.
+     *
+     * @return Builder
+     */
+    public Builder builder() {
+        return new Builder(new ImmutableTopologySnapshot(this));
+    }
+
+    @Override
+    public SwitchEvent getSwitchEvent(final Dpid dpid) {
+        return this.switches.get(dpid);
+    }
+
+    @Override
+    public Collection<SwitchEvent> getAllSwitchEvents() {
+        return Collections.unmodifiableCollection(switches.values());
+    }
+
+    @Override
+    public PortEvent getPortEvent(final SwitchPort port) {
+        return getPortEvent(port.getDpid(), port.getPortNumber());
+    }
+
+    @Override
+    public PortEvent getPortEvent(final Dpid dpid, PortNumber portNumber) {
+        Map<PortNumber, PortEvent> portMap = this.ports.get(dpid);
+        if (portMap != null) {
+            return portMap.get(portNumber);
+        }
+        return null;
+    }
+
+    @Override
+    public Collection<PortEvent> getPortEvents(final Dpid dpid) {
+        Map<PortNumber, PortEvent> portList = ports.get(dpid);
+        if (portList == null) {
+            return Collections.emptyList();
+        }
+        return Collections.unmodifiableCollection(portList.values());
+    }
+
+    @Override
+    public Collection<PortEvent> getAllPortEvents() {
+        List<PortEvent> events = new LinkedList<>();
+        for (Map<PortNumber, PortEvent> cm : ports.values()) {
+            events.addAll(cm.values());
+        }
+        return Collections.unmodifiableCollection(events);
+    }
+
+    @Override
+    public LinkEvent getLinkEvent(final LinkTuple linkId) {
+        Map<String, LinkEvent> links = this.outgoingLinks.get(linkId.getSrc());
+        if (links == null) {
+            return null;
+        }
+
+        // TODO Should we look for Packet link first?
+        //  => Not needed unless invariant is broken.
+
+        for (LinkEvent link : links.values()) {
+            if (link.getDst().equals(linkId.getDst())) {
+                return link;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public LinkEvent getLinkEvent(final LinkTuple linkId, final String type) {
+        Map<String, LinkEvent> links = this.outgoingLinks.get(linkId.getSrc());
+        if (links == null) {
+            return null;
+        }
+        return links.get(type);
+    }
+
+    @Override
+    public Collection<LinkEvent> getLinkEventsFrom(SwitchPort srcPort) {
+        Map<String, LinkEvent> links = this.outgoingLinks.get(srcPort);
+        if (links == null) {
+            return Collections.emptyList();
+        }
+
+        return Collections.unmodifiableCollection(links.values());
+    }
+
+    @Override
+    public Collection<LinkEvent> getLinkEventsTo(SwitchPort dstPort) {
+        Map<String, LinkEvent> links = this.incomingLinks.get(dstPort);
+        if (links == null) {
+            return Collections.emptyList();
+        }
+
+        return Collections.unmodifiableCollection(links.values());
+    }
+
+    @Override
+    public Collection<LinkEvent> getLinkEvents(final LinkTuple linkId) {
+        Map<String, LinkEvent> links = this.outgoingLinks.get(linkId.getSrc());
+        if (links == null) {
+            return Collections.emptyList();
+        }
+
+        // unless invariant is broken, this should contain at most 1 element.
+        return Collections.unmodifiableCollection(links.values());
+    }
+
+    @Override
+    public Collection<LinkEvent> getAllLinkEvents() {
+        List<LinkEvent> events = new LinkedList<>();
+        for (Map<String, LinkEvent> cm : outgoingLinks.values()) {
+            events.addAll(cm.values());
+        }
+        return Collections.unmodifiableCollection(events);
+    }
+
+    @Override
+    public HostEvent getHostEvent(final MACAddress mac) {
+        return this.mac2Host.get(mac);
+    }
+
+    @Override
+    public Collection<HostEvent> getHostEvents(SwitchPort port) {
+        return Collections.unmodifiableCollection(this.hosts.get(port));
+    }
+
+    @Override
+    public Collection<HostEvent> getAllHostEvents() {
+        return Collections.unmodifiableCollection(mac2Host.values());
+    }
+
+    /**
+     * Gets the master instance ID for a switch.
+     *
+     * @param dpid switch dpid
+     * @return master instance ID or null if there is no master
+     */
+    public OnosInstanceId getSwitchMaster(Dpid dpid) {
+        final SortedSet<MastershipEvent> candidates = mastership.get(dpid);
+        if (candidates == null) {
+            return null;
+        }
+        for (MastershipEvent candidate : candidates) {
+            if (candidate.getRole() == Role.MASTER) {
+                return candidate.getOnosInstanceId();
+            }
+        }
+        return null;
+    }
+
+
+    // TODO find better way to delegate following to interface adaptor
+
+    @Override
+    public Switch getSwitch(Dpid dpid) {
+        return adaptor.getSwitch(dpid);
+    }
+
+    @Override
+    public Iterable<Switch> getSwitches() {
+        return adaptor.getSwitches();
+    }
+
+    @Override
+    public Port getPort(Dpid dpid, PortNumber number) {
+        return adaptor.getPort(dpid, number);
+    }
+
+    @Override
+    public Port getPort(SwitchPort port) {
+        return adaptor.getPort(port);
+    }
+
+    @Override
+    public Collection<Port> getPorts(Dpid dpid) {
+        return adaptor.getPorts(dpid);
+    }
+
+    @Override
+    public Link getOutgoingLink(Dpid dpid, PortNumber number) {
+        return adaptor.getOutgoingLink(dpid, number);
+    }
+
+    @Override
+    public Link getOutgoingLink(SwitchPort port) {
+        return adaptor.getOutgoingLink(port);
+    }
+
+    @Override
+    public Link getOutgoingLink(Dpid dpid, PortNumber number, String type) {
+        return adaptor.getOutgoingLink(dpid, number, type);
+    }
+
+    @Override
+    public Link getOutgoingLink(SwitchPort port, String type) {
+        return adaptor.getOutgoingLink(port, type);
+    }
+
+    @Override
+    public Collection<Link> getOutgoingLinks(SwitchPort port) {
+        return adaptor.getOutgoingLinks(port);
+    }
+
+    @Override
+    public Link getIncomingLink(Dpid dpid, PortNumber number) {
+        return adaptor.getIncomingLink(dpid, number);
+    }
+
+    @Override
+    public Link getIncomingLink(SwitchPort port) {
+        return adaptor.getIncomingLink(port);
+    }
+
+    @Override
+    public Link getIncomingLink(Dpid dpid, PortNumber number, String type) {
+        return adaptor.getIncomingLink(dpid, number, type);
+    }
+
+    @Override
+    public Link getIncomingLink(SwitchPort port, String type) {
+        return adaptor.getIncomingLink(port, type);
+    }
+
+    @Override
+    public Collection<Link> getIncomingLinks(SwitchPort port) {
+        return adaptor.getIncomingLinks(port);
+    }
+
+    @Override
+    public Link getLink(Dpid srcDpid, PortNumber srcNumber,
+                        Dpid dstDpid, PortNumber dstNumber) {
+
+        return adaptor.getLink(srcDpid, srcNumber, dstDpid, dstNumber);
+    }
+
+    @Override
+    public Link getLink(Dpid srcDpid, PortNumber srcNumber,
+                        Dpid dstDpid, PortNumber dstNumber,
+                        String type) {
+
+        return adaptor.getLink(srcDpid, srcNumber, dstDpid, dstNumber, type);
+    }
+
+    @Override
+    public Iterable<Link> getLinks() {
+        return adaptor.getLinks();
+    }
+
+    @Override
+    public Host getHostByMac(MACAddress address) {
+        return adaptor.getHostByMac(address);
+    }
+
+    @Override
+    public Iterable<Host> getHosts() {
+        return adaptor.getHosts();
+    }
+
+    @Override
+    public Collection<Host> getHosts(SwitchPort port) {
+        return adaptor.getHosts(port);
+    }
+}