OVS review

src/base/test/task_test_util.h

@@ -90,7 +90,7 @@ do {                                                                           \
 #define TASK_UTIL_EXPECT_VECTOR_EQ(actual, expected)             \
     do {                                                         \
         TASK_UTIL_EXPECT_EQ((expected).size(), (actual).size()); \
-        for (int i = 0; i < (expected).size(); i++) {            \
+        for (int i = 0; i < (int)((expected).size()); i++) {            \
             TASK_UTIL_EXPECT_EQ((expected)[i], (actual)[i]);     \
         }                                                        \
     } while (false)

src/config/api-server/vnc_addr_mgmt.py

@@ -119,6 +119,20 @@ def __str__(self):
 # end AddrMgmtInvalidGatewayIp
 
 
+class AddrMgmtInvalidServiceNodeIp(AddrMgmtError):
+
+    def __init__(self, subnet_val, service_address):
+        self.subnet_val = subnet_val
+        self.service_address = service_address
+    # end __init__
+
+    def __str__(self):
+        return "subnet(%s) has Invalid Service Node ip address(%s)" %\
+            (self.subnet_val, self.service_address)
+    # end __str__
+# end AddrMgmtInvalidServiceNodeIp
+
+
 class AddrMgmtInvalidDnsNameServer(AddrMgmtError):
 
     def __init__(self, subnet_val, name_server):
@@ -152,7 +166,7 @@ def set_db_conn(cls, db_conn):
     # end set_db_conn
 
     def __init__(self, name, prefix, prefix_len,
-                 gw=None, enable_dhcp=True,
+                 gw=None, service_address=None, enable_dhcp=True,
                  dns_nameservers=None,
                  alloc_pool_list=None,
                  addr_from_start=False):
@@ -184,6 +198,20 @@ def __init__(self, name, prefix, prefix_len,
             else: 
                 gw_ip = IPAddress(network.last - 1)
 
+        # check service_address
+        if service_address:
+            try:
+                service_node_address = IPAddress(service_address)
+            except AddrFormatError:
+                raise AddrMgmtInvalidServiceNodeIp(name, service_node_address)
+
+        else:
+            # reserve a service address ip in subnet
+            if addr_from_start:
+                service_node_address = IPAddress(network.first + 2)
+            else:
+                service_node_address = IPAddress(network.last - 2)
+
         # check dns_nameservers
         for nameserver in dns_nameservers or []:
             try:
@@ -208,11 +236,12 @@ def __init__(self, name, prefix, prefix_len,
                          'end':int(IPAddress(alloc_pool['end']))}
             alloc_int_list.append(alloc_int)
 
-        # exclude gw_ip if it is within allocation-pool
+        # exclude gw_ip, service_node_address if they are within allocation-pool
         for alloc_int in alloc_int_list:
             if alloc_int['start'] <= int(gw_ip) <= alloc_int['end']:
                 exclude.append(gw_ip)
-                break
+            if alloc_int['start'] <= int(service_node_address) <= alloc_int['end']:
+                exclude.append(service_node_address)
         self._db_conn.subnet_create_allocator(name, alloc_int_list,
                                               addr_from_start)
 
@@ -225,6 +254,7 @@ def __init__(self, name, prefix, prefix_len,
         self._version = network.version
         self._exclude = exclude
         self.gw_ip = gw_ip
+        self.dns_server_address = service_node_address
         self._alloc_pool_list = alloc_pool_list
         self.enable_dhcp = enable_dhcp
         self.dns_nameservers = dns_nameservers 
@@ -344,6 +374,7 @@ def _get_subnet_dicts(self, vn_fq_name, vn_dict=None):
             for ipam_subnet in ipam_subnets:
                 subnet_dict = copy.deepcopy(ipam_subnet['subnet'])
                 subnet_dict['gw'] = ipam_subnet.get('default_gateway', None)
+                subnet_dict['dns_server_address'] = ipam_subnet.get('dns_server_address', None)
                 subnet_dict['allocation_pools'] = \
                     ipam_subnet.get('allocation_pools', None)
                 subnet_dict['enable_dhcp'] = ipam_subnet.get('enable_dhcp', True)
@@ -372,20 +403,23 @@ def _create_subnet_objs(self, vn_fq_name_str, vn_dict):
                         subnet['ip_prefix_len'])
 
                     gateway_ip = ipam_subnet.get('default_gateway', None)
+                    service_address = ipam_subnet.get('dns_server_address', None)
                     allocation_pools = ipam_subnet.get('allocation_pools', None)
                     dhcp_config = ipam_subnet.get('enable_dhcp', True)
                     nameservers = ipam_subnet.get('dns_nameservers', None)
                     addr_start = ipam_subnet.get('addr_from_start', False)
                     subnet_obj = Subnet(
                         '%s:%s' % (vn_fq_name_str, subnet_name),
                         subnet['ip_prefix'], str(subnet['ip_prefix_len']),
-                        gw=gateway_ip, enable_dhcp=dhcp_config,
+                        gw=gateway_ip, service_address=service_address,
+                        enable_dhcp=dhcp_config,
                         dns_nameservers=nameservers,
                         alloc_pool_list=allocation_pools,
                         addr_from_start=addr_start)
                     self._subnet_objs[vn_fq_name_str][subnet_name] = \
                          subnet_obj
                     ipam_subnet['default_gateway'] = str(subnet_obj.gw_ip)
+                    ipam_subnet['dns_server_address'] = str(subnet_obj.dns_server_address)
     # end _create_subnet_objs
 
     def config_log(self, msg, level):
@@ -436,8 +470,8 @@ def net_update_req(self, vn_fq_name, db_vn_dict, req_vn_dict, obj_uuid=None):
 
         # check db_subnet_dicts and req_subnet_dicts  
         # following parameters are same for subnets present in both dicts
-        # 1. enable_dhcp, 2. default_gateway, 3. allocation_pool 
-        # 4 dns_nameservers
+        # 1. enable_dhcp, 2. default_gateway, 3. dns_server_address
+        # 4. allocation_pool, 5. dns_nameservers
         for key in req_subnet_dicts.keys():
             req_subnet = req_subnet_dicts[key]
             if key in db_subnet_dicts.keys():
@@ -446,6 +480,8 @@ def net_update_req(self, vn_fq_name, db_vn_dict, req_vn_dict, obj_uuid=None):
                     req_subnet['enable_dhcp'] = True
                 if (req_subnet['gw'] != db_subnet['gw']):
                     raise AddrMgmtSubnetInvalid(vn_fq_name_str, key)
+                if (req_subnet['dns_server_address'] != db_subnet['dns_server_address']):
+                    raise AddrMgmtSubnetInvalid(vn_fq_name_str, key)
 
                 req_alloc_list = req_subnet['allocation_pools'] or []
                 db_alloc_list = db_subnet['allocation_pools'] or []
@@ -641,6 +677,16 @@ def net_check_subnet(self, db_vn_dict, req_vn_dict):
                     err_msg = "gateway Ip of configured subnets conflicting " \
                         "in deciding forwarding mode for virtual network."
                     return False, err_msg
+
+                # check service address
+                service_address = ipam_subnet.get('dns_server_address', None)
+                if service_address is not None:
+                    try:
+                        service_node_address = IPAddress(service_address)
+                    except AddrFormatError:
+                        err_msg = "Invalid Dns Server Ip address:%s" \
+                            %(service_address)
+                        return False, err_msg
         return True, ""
     # end net_check_subnet
 
@@ -747,6 +793,7 @@ def ip_alloc_req(self, vn_fq_name, sub=None, asked_ip_addr=None,
                                     subnet_dict['ip_prefix'],
                                     subnet_dict['ip_prefix_len'],
                                     gw=subnet_dict['gw'],
+                                    service_address=subnet_dict['dns_server_address'],
                                     enable_dhcp=subnet_dict['enable_dhcp'],
                                     dns_nameservers=subnet_dict['dns_nameservers'],
                                     alloc_pool_list=subnet_dict['allocation_pools'],
@@ -757,6 +804,8 @@ def ip_alloc_req(self, vn_fq_name, sub=None, asked_ip_addr=None,
                 continue
             if asked_ip_addr == str(subnet_obj.gw_ip):
                 return asked_ip_addr
+            if asked_ip_addr == str(subnet_obj.dns_server_address):
+                return asked_ip_addr
             if asked_ip_addr and not subnet_obj.ip_belongs(asked_ip_addr):
                 continue
             try:
@@ -792,6 +841,7 @@ def ip_alloc_notify(self, ip_addr, vn_fq_name):
                                     subnet_dict['ip_prefix'],
                                     subnet_dict['ip_prefix_len'],
                                     gw=subnet_dict['gw'],
+                                    service_address=subnet_dict['dns_server_address'],
                                     enable_dhcp=subnet_dict['enable_dhcp'],
                                     dns_nameservers=subnet_dict['dns_nameservers'],
                                     alloc_pool_list=subnet_dict['allocation_pools'],
@@ -827,6 +877,7 @@ def ip_free_req(self, ip_addr, vn_fq_name, sub=None):
                                     subnet_dict['ip_prefix'],
                                     subnet_dict['ip_prefix_len'],
                                     gw=subnet_dict['gw'],
+                                    service_address=subnet_dict['dns_server_address'],
                                     enable_dhcp=subnet_dict['enable_dhcp'],
                                     dns_nameservers=subnet_dict['dns_nameservers'],
                                     alloc_pool_list=subnet_dict['allocation_pools'],
@@ -861,6 +912,7 @@ def is_ip_allocated(self, ip_addr, vn_fq_name, sub=None):
                                     subnet_dict['ip_prefix'],
                                     subnet_dict['ip_prefix_len'],
                                     gw=subnet_dict['gw'],
+                                    service_address=subnet_dict['dns_server_address'],
                                     enable_dhcp=subnet_dict['enable_dhcp'],
                                     dns_nameservers=subnet_dict['dns_nameservers'],
                                     alloc_pool_list=subnet_dict['allocation_pools'],

src/ifmap/ifmap_graph_walker.cc

@@ -244,6 +244,7 @@ void IFMapGraphWalker::AddNodesToWhitelist() {
     traversal_white_list_->include_vertex.insert("loadbalancer-pool");
     traversal_white_list_->include_vertex.insert("loadbalancer-member");
     traversal_white_list_->include_vertex.insert("loadbalancer-healthmonitor");
+    traversal_white_list_->include_vertex.insert("subnet");
 }
 
 void IFMapGraphWalker::AddLinksToWhitelist() {
@@ -321,6 +322,8 @@ void IFMapGraphWalker::AddLinksToWhitelist() {
         "source=loadbalancer-pool,target=virtual-ip");
     traversal_white_list_->include_edge.insert(
         "source=loadbalancer-pool,target=loadbalancer-member");
+    traversal_white_list_->include_edge.insert(
+        "source=virtual-machine-interface,target=subnet");
 
     // Manually add required links not picked by the
     // IFMapGraphTraversalFilterCalculator

src/ksync/ksync_entry.h

@@ -99,6 +99,9 @@ class KSyncEntry {
     // Returns true if entry is resolved and referring entry can be written
     bool IsResolved();
 
+    // Returns true if the entry data is resolved
+    virtual bool IsDataResolved() {return true;}
+
     // User define KSync Response handler
     virtual void Response() { };
 

src/ksync/ksync_object.cc

@@ -57,6 +57,19 @@ KSyncEntry *KSyncObject::Find(const KSyncEntry *key) {
     return NULL;
 }
 
+KSyncEntry *KSyncObject::Next(const KSyncEntry *entry) {
+    Tree::const_iterator it;
+    if (entry == NULL) {
+        it = tree_.begin();
+    } else {
+        it = tree_.iterator_to(*entry);
+        it++;
+    }
+    if (it != tree_.end()) {
+        return const_cast<KSyncEntry *>(it.operator->());
+    }
+    return NULL;
+}
 KSyncEntry *KSyncObject::CreateImpl(const KSyncEntry *key) {
     KSyncEntry *entry;
     if (need_index_) {
@@ -160,6 +173,11 @@ void KSyncDBObject::UnregisterDb(DBTableBase *table) {
     table_ = NULL;
 }
 
+KSyncDBObject::DBFilterResp KSyncDBObject::DBEntryFilter(const DBEntry *entry) {
+    // Default accept all
+    return DBFilterAccept;
+}
+
 void KSyncDBObject::set_test_id(DBTableBase::ListenerId id) {
     test_id_ = id;
 }
@@ -193,8 +211,13 @@ void KSyncDBObject::Notify(DBTablePartBase *partition, DBEntryBase *e) {
     assert(table_ == table);
     DBState *state = entry->GetState(table, id_);
     KSyncDBEntry *ksync = static_cast<KSyncDBEntry *>(state);
+    DBFilterResp resp = DBFilterAccept;
+
+    if (!entry->IsDeleted()) {
+        resp = DBEntryFilter(entry);
+    }
 
-    if (entry->IsDeleted()) {
+    if (entry->IsDeleted() || resp == DBFilterDelete) {
         // We may get duplicate delete notification in 
         // case of db entry reuse
         // add -> change ->delete(Notify) -> change -> delete(Notify)
@@ -204,6 +227,10 @@ void KSyncDBObject::Notify(DBTablePartBase *partition, DBEntryBase *e) {
             NotifyEvent(ksync, KSyncEntry::DEL_REQ);
         }
     } else {
+        if (resp == DBFilterIgnore) {
+            // DB filter tells us to ignore this Add/Change.
+            return;
+        }
         bool need_sync = false;
         if (ksync == NULL) {
             KSyncEntry *key, *found;
@@ -218,7 +245,17 @@ void KSyncDBObject::Notify(DBTablePartBase *partition, DBEntryBase *e) {
             }
             delete key;
             entry->SetState(table, id_, ksync);
-            assert(ksync->GetDBEntry() == NULL);
+            DBEntry *old_db_entry = ksync->GetDBEntry();
+            if (old_db_entry != NULL) {
+                // cleanup previous state id the old db entry is delete marked.
+                if (old_db_entry->IsDeleted()) {
+                    CleanupOnDel(ksync);
+                } else {
+                    // something wrong! two db entry in oper db points to same
+                    // KSync entry.
+                    assert(false);
+                }
+            }
             ksync->SetDBEntry(entry);
             need_sync = true;
         }
@@ -241,6 +278,8 @@ bool KSyncEntry::IsResolved() {
     KSyncObject *obj = GetObject();
     if (obj->IsIndexValid() && index_ == kInvalidIndex)
         return false;
+    if (IsDataResolved() == false)
+        return false;
     return ((state_ >= IN_SYNC) && (state_ < DEL_DEFER_SYNC));
 }
 
@@ -947,6 +986,7 @@ void KSyncObject::NotifyEvent(KSyncEntry *entry, KSyncEntry::KSyncEvent event) {
             break;
 
         case KSyncEntry::SYNC_WAIT:
+            dep_reval = true;
             state = KSyncSM_SyncWait(this, entry, event);
             break;
 
@@ -1107,11 +1147,41 @@ KSyncObjectManager::~KSyncObjectManager() {
 
 SandeshTraceBufferPtr KSyncTraceBuf(SandeshTraceBufferCreate("KSync", 1000));
 
-void KSyncObjectManager::Init() {
+KSyncObjectManager *KSyncObjectManager::Init() {
     singleton_ = new KSyncObjectManager();
+    return singleton_;
 }
 
 void KSyncObjectManager::Shutdown() {
     delete singleton_;
     singleton_ = NULL;
 }
+
+// Create a dummy KSync Entry. This entry will all ways be in deferred state
+// Any back-ref added to it will never get resolved.
+// Can be used to defer an incomplete entry
+
+class KSyncDummyEntry : public KSyncEntry {
+public:
+    KSyncDummyEntry() : KSyncEntry() { }
+    virtual ~KSyncDummyEntry() { }
+    virtual bool IsLess(const KSyncEntry &rhs) const {
+        return false;
+    }
+    std::string ToString() const { return "Dummy"; }
+    bool Add() { return false;}
+    bool Change() { return false; }
+    bool Delete() { return false; }
+    KSyncObject *GetObject() { return NULL; }
+    KSyncEntry *UnresolvedReference() { return NULL; }
+    bool IsDataResolved() {return false;}
+private:
+    DISALLOW_COPY_AND_ASSIGN(KSyncDummyEntry);
+};
+
+KSyncEntry *KSyncObjectManager::default_defer_entry() {
+    if (default_defer_entry_.get() == NULL) {
+        default_defer_entry_.reset(new KSyncDummyEntry());
+    }
+    return default_defer_entry_.get();
+}