diff --git a/xos/models.py b/xos/models.py
index a839b4a..4ab3c15 100644
--- a/xos/models.py
+++ b/xos/models.py
@@ -16,20 +16,101 @@
 
 class CeilometerService(Service):
     KIND = CEILOMETER_KIND
+    LOOK_FOR_IMAGES=[ "ceilometer-service-trusty-server-multi-nic",
+                    ]
 
     class Meta:
         app_label = "monitoring"
         verbose_name = "Ceilometer Service"
         proxy = True
 
+    def get_instance(self):
+        for slice in self.slices.all():
+             for instance in slice.instances.all():
+                 if instance.image.name in self.LOOK_FOR_IMAGES:
+                     return instance
+        return None
+
+    @property
+    def addresses(self):
+        if (not self.id) or (not self.get_instance()):
+            return {}
+
+        addresses = {}
+        for ns in self.get_instance().ports.all():
+            if "private" in ns.network.name.lower():
+                addresses["private"] = (ns.ip, ns.mac)
+            elif ("nat" in ns.network.name.lower()) or ("management" in ns.network.name.lower()):
+                addresses["nat"] = (ns.ip, ns.mac)
+            #TODO: Do we need this client_access_network. Revisit in VTN context
+            #elif "ceilometer_client_access" in ns.network.labels.lower():
+            #    addresses["ceilometer"] = (ns.ip, ns.mac)
+        return addresses
+
+    @property
+    def nat_ip(self):
+        return self.addresses.get("nat", (None, None))[0]
+
+    @property
+    def nat_mac(self):
+        return self.addresses.get("nat", (None, None))[1]
+
+    @property
+    def private_ip(self):
+        return self.addresses.get("private", (None, None))[0]
+
+    @property
+    def private_mac(self):
+        return self.addresses.get("private", (None, None))[1]
+
+    def get_controller(self):
+        if not self.slices.count:
+            raise XOSConfigurationError("The service has no slices")
+        cslice = self.slices.all()[0].controllerslices.all()[0]
+        controller = cslice.controller
+        if not controller:
+            raise XOSConfigurationError("The service slice has no controller")
+        return controller
+
     @property
     def ceilometer_pub_sub_url(self):
-        return self.get_attribute("ceilometer_pub_sub_url", None)
+        if not self.get_instance():
+            return self.get_attribute("ceilometer_pub_sub_url", None)
+        if not self.private_ip:
+            return None
+        return "http://" + self.private_ip + ":4455/"
 
     @ceilometer_pub_sub_url.setter
     def ceilometer_pub_sub_url(self, value):
         self.set_attribute("ceilometer_pub_sub_url", value)
 
+    @property
+    def ceilometer_auth_url(self):
+        #FIXME: Crude way to determine if monitoring service is getting deployed with its own ceilometer+keystone 
+        if not self.get_instance():
+            return self.get_controller().auth_url
+        if not self.private_ip:
+            return None
+        return "http://" + self.private_ip + ":5000/v2.0"
+
+    @property
+    def ceilometer_admin_user(self):
+        if not self.get_instance():
+            return self.get_controller().admin_user
+        return 'admin'
+
+    @property
+    def ceilometer_admin_password(self):
+        if not self.get_instance():
+            return self.get_controller().admin_password
+        return 'password'
+
+    @property
+    def ceilometer_admin_tenant(self):
+        if not self.get_instance():
+            return self.get_controller().admin_tenant
+        return 'admin'
+
 class MonitoringChannel(TenantWithContainer):   # aka 'CeilometerTenant'
     class Meta:
         proxy = True
@@ -165,10 +246,41 @@
         return 8888+self.id
 
     @property
+    def ssh_proxy_tunnel(self):
+        return self.get_attribute("ssh_proxy_tunnel", False)
+
+    @ssh_proxy_tunnel.setter
+    def ssh_proxy_tunnel(self, value):
+        self.set_attribute("ssh_proxy_tunnel", value)
+
+    @property
+    def ssh_tunnel_port(self):
+        return self.get_attribute("ssh_tunnel_port")
+
+    @ssh_tunnel_port.setter
+    def ssh_tunnel_port(self, value):
+        self.set_attribute("ssh_tunnel_port", value)
+
+    @property
+    def ssh_tunnel_ip(self):
+        return self.get_attribute("ssh_tunnel_ip")
+
+    @ssh_tunnel_ip.setter
+    def ssh_tunnel_ip(self, value):
+        self.set_attribute("ssh_tunnel_ip", value)
+
+    @property
     def ceilometer_url(self):
-        if not self.private_ip:
-            return None
-        return "http://" + self.private_ip + ":" + str(self.ceilometer_port) + "/"
+        if self.ssh_proxy_tunnel:
+            if self.ssh_tunnel_ip and self.ssh_tunnel_port:
+                return "http://" + self.ssh_tunnel_ip + ":" + str(self.ssh_tunnel_port) + "/"
+            else:
+                return None
+        else:
+            if self.private_ip and self.ceilometer_port:
+                return "http://" + self.private_ip + ":" + str(self.ceilometer_port) + "/"
+            else:
+                return None
 
 def model_policy_monitoring_channel(pk):
     # TODO: this should be made in to a real model_policy