diff --git a/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/AlarmStore.java b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/AlarmStore.java
new file mode 100644
index 0000000..90ab767
--- /dev/null
+++ b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/AlarmStore.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.faultmanagement.api;
+
+import org.onosproject.incubator.net.faultmanagement.alarm.Alarm;
+import org.onosproject.incubator.net.faultmanagement.alarm.AlarmEvent;
+import org.onosproject.incubator.net.faultmanagement.alarm.AlarmId;
+import org.onosproject.net.DeviceId;
+import org.onosproject.store.Store;
+
+import java.util.Collection;
+
+/**
+ * Manages inventory of alarms; not intended for direct use.
+ */
+public interface AlarmStore extends Store<AlarmEvent, AlarmStoreDelegate> {
+
+    /**
+     * Retrieves and alarm based on it's id.
+     *
+     * @param alarmId alarm identifier
+     * @return alarm
+     */
+    Alarm getAlarm(AlarmId alarmId);
+
+    /**
+     * Retrieves all alarms present in the system.
+     *
+     * @return alarms
+     */
+    Collection<Alarm> getAlarms();
+
+    /**
+     * Retrieves alarms for a device.
+     *
+     * @param deviceId device identifier
+     * @return alarms
+     */
+    Collection<Alarm> getAlarms(DeviceId deviceId);
+
+    /**
+     * Stores an alarm.
+     *
+     * @param alarm alarm
+     */
+    void setAlarm(Alarm alarm);
+
+    /**
+     * Removes an alarm.
+     *
+     * @param alarmId alarm
+     */
+    void removeAlarm(AlarmId alarmId);
+}
diff --git a/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/AlarmStoreDelegate.java b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/AlarmStoreDelegate.java
new file mode 100644
index 0000000..961f98c
--- /dev/null
+++ b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/AlarmStoreDelegate.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.faultmanagement.api;
+
+import org.onosproject.incubator.net.faultmanagement.alarm.AlarmEvent;
+import org.onosproject.store.StoreDelegate;
+
+/**
+ * Infrastructure alarm store delegate abstraction.
+ */
+public interface AlarmStoreDelegate extends StoreDelegate<AlarmEvent> {
+}
diff --git a/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/package-info.java b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/package-info.java
new file mode 100644
index 0000000..4f370b7
--- /dev/null
+++ b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/api/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed 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.
+ */
+
+/**
+ * Infrastructure alarm store &amp; related services API definitions.
+ */
+package org.onosproject.faultmanagement.api;
diff --git a/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/AlarmsManager.java b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/AlarmManager.java
similarity index 67%
rename from apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/AlarmsManager.java
rename to apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/AlarmManager.java
index c7f724e..e45fa23 100644
--- a/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/AlarmsManager.java
+++ b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/AlarmManager.java
@@ -21,11 +21,17 @@
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Deactivate;
 import org.apache.felix.scr.annotations.Modified;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
 import org.apache.felix.scr.annotations.Service;
 import org.onlab.util.ItemNotFoundException;
+import org.onosproject.faultmanagement.api.AlarmStore;
+import org.onosproject.faultmanagement.api.AlarmStoreDelegate;
 import org.onosproject.incubator.net.faultmanagement.alarm.Alarm;
 import org.onosproject.incubator.net.faultmanagement.alarm.AlarmEntityId;
+import org.onosproject.incubator.net.faultmanagement.alarm.AlarmEvent;
 import org.onosproject.incubator.net.faultmanagement.alarm.AlarmId;
+import org.onosproject.incubator.net.faultmanagement.alarm.AlarmListener;
 import org.onosproject.incubator.net.faultmanagement.alarm.AlarmProvider;
 import org.onosproject.incubator.net.faultmanagement.alarm.AlarmProviderRegistry;
 import org.onosproject.incubator.net.faultmanagement.alarm.AlarmProviderService;
@@ -33,15 +39,13 @@
 import org.onosproject.incubator.net.faultmanagement.alarm.DefaultAlarm;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.DeviceId;
-import org.onosproject.net.provider.AbstractProviderRegistry;
+import org.onosproject.net.provider.AbstractListenerProviderRegistry;
 import org.onosproject.net.provider.AbstractProviderService;
-import org.osgi.service.component.ComponentContext;
 import org.slf4j.Logger;
 
 import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.Collectors;
 
@@ -54,63 +58,67 @@
  */
 @Component(immediate = true)
 @Service
-public class AlarmsManager
-        extends AbstractProviderRegistry<AlarmProvider, AlarmProviderService>
+public class AlarmManager
+        extends AbstractListenerProviderRegistry<AlarmEvent, AlarmListener, AlarmProvider, AlarmProviderService>
         implements AlarmService, AlarmProviderRegistry {
 
     private final Logger log = getLogger(getClass());
 
-    private final AtomicLong alarmIdGenerator = new AtomicLong(0);
 
-    // TODO Later should must be persisted to disk or database
-    protected final Map<AlarmId, Alarm> alarms = new ConcurrentHashMap<>();
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected AlarmStore store;
+
+    protected AlarmStoreDelegate delegate = this::post;
+
+    //TODO improve implementation of AlarmId
+    private final AtomicLong alarmIdGenerator = new AtomicLong(0);
 
     private static final String NOT_SUPPORTED_YET = "Not supported yet.";
 
     @Activate
-    public void activate(ComponentContext context) {
+    public void activate() {
+        store.setDelegate(delegate);
+        eventDispatcher.addSink(AlarmEvent.class, listenerRegistry);
         log.info("Started");
     }
 
     @Deactivate
-    public void deactivate(ComponentContext context) {
-        alarms.clear();
+    public void deactivate() {
+        store.unsetDelegate(delegate);
+        eventDispatcher.removeSink(AlarmEvent.class);
         log.info("Stopped");
     }
 
     @Modified
-    public boolean modified(ComponentContext context) {
+    public boolean modified() {
         log.info("Modified");
         return true;
     }
 
-    private AlarmId generateAlarmId() {
-        return AlarmId.alarmId(alarmIdGenerator.incrementAndGet());
-    }
-
     @Override
     public Alarm updateBookkeepingFields(AlarmId id, boolean isAcknowledged, String assignedUser) {
 
-        Alarm found = alarms.get(id);
+        Alarm found = store.getAlarm(id);
         if (found == null) {
             throw new ItemNotFoundException("Alarm with id " + id + " found");
         }
 
-        Alarm updated = new DefaultAlarm.Builder(found).
-                withAcknowledged(isAcknowledged).
-                withAssignedUser(assignedUser).build();
-        alarms.put(id, updated);
+        Alarm updated = new DefaultAlarm.Builder(found)
+                .withId(found.id())
+                .withAcknowledged(isAcknowledged)
+                .withAssignedUser(assignedUser).build();
+        store.setAlarm(updated);
         return updated;
     }
 
     public Alarm clear(AlarmId id) {
-        Alarm found = alarms.get(id);
+        Alarm found = store.getAlarm(id);
         if (found == null) {
-            log.warn("id {} cant be cleared as it is already gone.", id);
+            log.warn("Alarm {} is not present", id);
             return null;
         }
-        Alarm updated = new DefaultAlarm.Builder(found).clear().build();
-        alarms.put(id, updated);
+        Alarm updated = new DefaultAlarm.Builder(found).withId(id).clear().build();
+        store.setAlarm(updated);
         return updated;
     }
 
@@ -128,47 +136,44 @@
 
     @Override
     public Alarm getAlarm(AlarmId alarmId) {
-        return nullIsNotFound(alarms.get(checkNotNull(alarmId, "Alarm Id cannot be null")),
+        return nullIsNotFound(store.getAlarm(checkNotNull(alarmId, "Alarm Id cannot be null")),
                               "Alarm is not found");
     }
 
     @Override
     public Set<Alarm> getAlarms() {
-        return ImmutableSet.copyOf(alarms.values());
+        return ImmutableSet.copyOf(store.getAlarms());
     }
 
     @Override
     public Set<Alarm> getActiveAlarms() {
-        return alarms.values().stream().filter(
+        return ImmutableSet.copyOf(store.getAlarms().stream().filter(
                 a -> !a.severity().equals(Alarm.SeverityLevel.CLEARED)).
-                collect(Collectors.toSet());
+                collect(Collectors.toSet()));
     }
 
     @Override
     public Set<Alarm> getAlarms(Alarm.SeverityLevel severity) {
-        return alarms.values().stream().filter(
+        return ImmutableSet.copyOf(store.getAlarms().stream().filter(
                 a -> a.severity().equals(severity)).
-                collect(Collectors.toSet());
+                collect(Collectors.toSet()));
     }
 
     @Override
     public Set<Alarm> getAlarms(DeviceId deviceId) {
-        return alarms.values().stream().filter(
-                a -> deviceId.equals(a.deviceId())).
-                collect(Collectors.toSet());
+        return ImmutableSet.copyOf(store.getAlarms(deviceId));
     }
 
     private Set<Alarm> getActiveAlarms(DeviceId deviceId) {
-        return getActiveAlarms().stream().filter(
+        return ImmutableSet.copyOf(getActiveAlarms().stream().filter(
                 a -> deviceId.equals(a.deviceId())).
-                collect(Collectors.toSet());
+                collect(Collectors.toSet()));
     }
 
     @Override
     public Set<Alarm> getAlarms(DeviceId deviceId, AlarmEntityId source) {
-        return getAlarms(deviceId).stream().filter(
-                a -> source.equals(a.source())
-        ).collect(Collectors.toSet());
+        return ImmutableSet.copyOf(getAlarms(deviceId).stream().filter(
+                a -> source.equals(a.source())).collect(Collectors.toSet()));
     }
 
     @Override
@@ -189,35 +194,37 @@
     // Synchronised to prevent duplicate NE alarms being raised
     protected synchronized void updateAlarms(DeviceId deviceId, Set<Alarm> discoveredSet) {
         Set<Alarm> storedSet = getActiveAlarms(deviceId);
-        log.trace("currentNeAlarms={}. discoveredAlarms={}", storedSet, discoveredSet);
+        log.debug("CurrentNeAlarms={}. DiscoveredAlarms={}", storedSet, discoveredSet);
 
         if (CollectionUtils.isEqualCollection(storedSet, discoveredSet)) {
-            log.debug("Alarm lists are equivalent so no update for {}.", deviceId);
+            log.debug("No update for {}.", deviceId);
             return;
         }
-
+        //TODO implement distinction between UPDATED and CLEARED ALARMS
         storedSet.stream().filter(
                 (stored) -> (!discoveredSet.contains(stored))).forEach((stored) -> {
-            log.debug("Alarm will be cleared as it is not on the element. Cleared alarm: {}.", stored);
+            log.debug("Alarm will be Cleared as it is not on the device. Cleared alarm: {}.", stored);
             clear(stored.id());
         });
 
         discoveredSet.stream().filter(
                 (discovered) -> (!storedSet.contains(discovered))).forEach((discovered) -> {
-            log.info("New alarm raised as it is missing. New alarm: {}.", discovered);
+            log.info("New alarm raised {}", discovered);
             AlarmId id = generateAlarmId();
-            alarms.put(id, new DefaultAlarm.Builder(discovered).withId(id).build());
+            store.setAlarm(new DefaultAlarm.Builder(discovered).withId(id).build());
         });
     }
 
-    private class InternalAlarmProviderService
-            extends AbstractProviderService<AlarmProvider>
+    //TODO improve implementation of AlarmId
+    private AlarmId generateAlarmId() {
+        return AlarmId.alarmId(alarmIdGenerator.incrementAndGet());
+    }
+
+    private class InternalAlarmProviderService extends AbstractProviderService<AlarmProvider>
             implements AlarmProviderService {
 
         InternalAlarmProviderService(AlarmProvider provider) {
             super(provider);
-
-
         }
 
         @Override
diff --git a/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/DistributedAlarmStore.java b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/DistributedAlarmStore.java
new file mode 100644
index 0000000..caea52b
--- /dev/null
+++ b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/DistributedAlarmStore.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.faultmanagement.impl;
+
+import com.google.common.collect.ImmutableSet;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Modified;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onosproject.faultmanagement.api.AlarmStore;
+import org.onosproject.faultmanagement.api.AlarmStoreDelegate;
+import org.onosproject.incubator.net.faultmanagement.alarm.Alarm;
+import org.onosproject.incubator.net.faultmanagement.alarm.AlarmEntityId;
+import org.onosproject.incubator.net.faultmanagement.alarm.AlarmEvent;
+import org.onosproject.incubator.net.faultmanagement.alarm.AlarmId;
+import org.onosproject.incubator.net.faultmanagement.alarm.DefaultAlarm;
+import org.onosproject.net.DeviceId;
+import org.onosproject.store.AbstractStore;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.ConsistentMap;
+import org.onosproject.store.service.MapEvent;
+import org.onosproject.store.service.MapEventListener;
+import org.onosproject.store.service.Serializer;
+import org.onosproject.store.service.StorageService;
+import org.slf4j.Logger;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Manages information of alarms using gossip protocol to distribute
+ * information.
+ */
+@Component(immediate = true)
+@Service
+public class DistributedAlarmStore
+        extends AbstractStore<AlarmEvent, AlarmStoreDelegate>
+        implements AlarmStore {
+
+    private final Logger log = getLogger(getClass());
+    private ConsistentMap<AlarmId, Alarm> alarms;
+    private Map<AlarmId, Alarm> alarmsMap;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected StorageService storageService;
+
+    private final MapEventListener<AlarmId, Alarm> listener = new InternalListener();
+
+    @Activate
+    public void activate() {
+        log.info("Started");
+        alarms = storageService.<AlarmId, Alarm>consistentMapBuilder()
+                .withName("onos-alarm-table")
+                .withSerializer(Serializer.using(KryoNamespaces.API,
+                                                 Alarm.class,
+                                                 DefaultAlarm.class,
+                                                 AlarmId.class,
+                                                 AlarmEvent.Type.class,
+                                                 Alarm.SeverityLevel.class,
+                                                 AlarmEntityId.class))
+                .build();
+        alarms.addListener(listener);
+        alarmsMap = alarms.asJavaMap();
+    }
+
+    @Deactivate
+    public void deactivate() {
+        alarms.removeListener(listener);
+        log.info("Stopped");
+    }
+
+    @Modified
+    public boolean modified() {
+        log.info("Modified");
+        return true;
+    }
+
+    @Override
+    public Alarm getAlarm(AlarmId alarmId) {
+        return alarmsMap.get(alarmId);
+    }
+
+    @Override
+    public Collection<Alarm> getAlarms() {
+        return ImmutableSet.copyOf(alarmsMap.values());
+    }
+
+    @Override
+    public Collection<Alarm> getAlarms(DeviceId deviceId) {
+        //FIXME: this is expensive, need refactoring when core maps provide different indexes.
+        return ImmutableSet.copyOf(alarmsMap.values().stream()
+                .filter(alarm -> alarm.deviceId().equals(deviceId))
+                .collect(Collectors.toSet()));
+    }
+
+    @Override
+    public void setAlarm(Alarm alarm) {
+        alarms.put(alarm.id(), alarm);
+    }
+
+    @Override
+    public void removeAlarm(AlarmId alarmId) {
+        alarms.remove(alarmId);
+    }
+
+    //Event listener to notify delegates about Map events.
+    private class InternalListener implements MapEventListener<AlarmId, Alarm> {
+
+        @Override
+        public void event(MapEvent<AlarmId, Alarm> mapEvent) {
+            final AlarmEvent.Type type;
+            final Alarm alarm;
+            switch (mapEvent.type()) {
+                case INSERT:
+                    type = AlarmEvent.Type.CREATED;
+                    alarm = mapEvent.newValue().value();
+                    break;
+                case UPDATE:
+                    type = AlarmEvent.Type.CREATED;
+                    alarm = mapEvent.newValue().value();
+                    break;
+                case REMOVE:
+                    type = AlarmEvent.Type.REMOVED;
+                    alarm = mapEvent.oldValue().value();
+                    break;
+                default:
+                    throw new IllegalArgumentException("Wrong event type " + mapEvent.type());
+            }
+            notifyDelegate(new AlarmEvent(type, alarm));
+        }
+    }
+}
diff --git a/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/package-info.java b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/package-info.java
index 89944ef..aa3b4f8 100644
--- a/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/package-info.java
+++ b/apps/faultmanagement/fmmgr/src/main/java/org/onosproject/faultmanagement/impl/package-info.java
@@ -15,6 +15,6 @@
  */
 
 /**
- * Fault Management application implementation.
+ * Infrastructure alarm model &amp; related services implementation.
  */
 package org.onosproject.faultmanagement.impl;