Repository: cablelabs/snaps-kubernetes

Issue:
Complete config refactor
The initial configuration refactor did not address validation_utils.py and a few places in k8_utils.py & ansible_configuration.py 

Discussion:

Patch:
diff --git a/snaps_k8s/common/consts/consts.py b/snaps_k8s/common/consts/consts.py
index 3b2d86e..eae80a5 100644
--- a/snaps_k8s/common/consts/consts.py
+++ b/snaps_k8s/common/consts/consts.py
@@ -38,8 +38,8 @@ NO_PROXY_KEY = 'no_proxy'
 NODE_CONF_KEY = 'node_configuration'
 CEPH_VOLUME_KEY = 'Ceph_Volume'
 NODE_TYPE_KEY = 'node_type'
-CEPH_CTRL_TYPE_KEY = 'ceph_controller'
-CEPH_OSD_TYPE_KEY = 'ceph_osd'
+CEPH_CTRL_TYPE = 'ceph_controller'
+CEPH_OSD_TYPE = 'ceph_osd'
 PERSIS_VOL_KEY = 'Persistent_Volumes'
 HOST_KEY = 'host'
 CEPH_CLAIMS_KEY = 'Ceph_claims'
@@ -53,6 +53,7 @@ TYPE_KEY = 'type'
 GATEWAY_KEY = 'gateway'
 RANGE_START_KEY = 'rangeStart'
 RANGE_END_KEY = 'rangeEnd'
+ROUTES_DST_KEY = 'routes_dst'
 
 DPDK_DRIVER = 'vfio-pci'
 DPDK_TOOL = '/etc/cni/scripts/dpdk-devbind.py'
@@ -64,7 +65,10 @@ ANSIBLE_PKG = 'snaps_k8s.ansible_p.ansible_utils'
 K8S_KEY = 'kubernetes'
 HA_CONFIG_KEY = 'ha_configuration'
 HA_API_EXT_LB_KEY = 'api_ext_loadbalancer'
+ACCESS_SEC_KEY = 'access_and_security'
+AUTH_KEY = 'authentication'
 BASIC_AUTH_KEY = 'basic_authentication'
+TOKEN_AUTH_KEY = 'token_authentication'
 USER_PASS_KEY = 'user_password'
 USER_ID_KEY = 'user_id'
 USER_NAME_KEY = 'user_name'
@@ -73,6 +77,7 @@ HOST_VOL_KEY = 'Host_Volume'
 PORT_KEY = 'port'
 STORAGE_KEY = 'storage'
 CEPH_STORAGE_KEY = 'storage'
+CEPH_CLAIM_NAME_KEY = 'claim_name'
 CLAIM_NAME_KEY = 'Claim_name'
 CLAIM_PARAMS_KEY = 'claim_parameters'
 LBL_VAL_KEY = 'label_value'
@@ -96,6 +101,9 @@ MACVLAN_TYPE = 'macvlan'
 SRIOV_TYPE = 'sriov'
 WEAVE_TYPE = 'weave'
 DHCP_TYPE = 'dhcp'
+NET_TYPE_LOCAL_TYPE = 'host-local'
+
+# Dict keys
 NETWORK_KEY = 'network'
 SUBNET_KEY = 'subnet'
 MASTER_PLUGIN_KEY = 'isMaster'
@@ -110,9 +118,6 @@ DFLT_NET_KEY = 'Default_Network'
 MULTUS_NET_KEY = 'Multus_network'
 MULTUS_CNI_KEY = 'CNI'
 MULTUS_CNI_CONFIG_KEY = 'CNI_Configuration'
-NET_TYPE_LOCAL_KEY = 'host-local'
-
-# Dict keys
 CPU_ALLOC_KEY = 'Exclusive_CPU_alloc_support'
 FLANNEL_NET_TYPE = 'Flannel'
 FLANNEL_NET_DTLS_KEY = 'flannel_network'
@@ -120,10 +125,14 @@ WEAVE_NET_TYPE = 'Weave'
 WEAVE_NET_DTLS_KEY = 'weave_network'
 MACVLAN_NET_TYPE = 'Macvlan'
 MACVLAN_NET_DTLS_KEY = 'macvlan_networks'
+MACVLAN_PARENT_INTF_KEY = 'parent_interface'
+MACVLAN_VLAN_ID_KEY = 'vlanid'
 SRIOV_NET_TYPE = 'Sriov'
-SRIOV_NET_DTLS_KEY = 'sriov_networks'
+SRIOV_NETWORKS_KEY = 'networks'
 SRIOV_DPDK_ENABLE_KEY = 'dpdk_enable'
-SRIOV_INTF_KEY = 'intf'
+SRIOV_INTF_KEY = 'sriov_intf'
+SRIOV_GATEWAY_KEY = 'sriov_gateway'
+SRIOV_SUBNET_KEY = 'sriov_subnet'
 
 # Consider making the log directory configurable
 CWD = os.getcwd()
diff --git a/snaps_k8s/common/utils/config_utils.py b/snaps_k8s/common/utils/config_utils.py
index 53473c5..bdd1fb5 100644
--- a/snaps_k8s/common/utils/config_utils.py
+++ b/snaps_k8s/common/utils/config_utils.py
@@ -24,6 +24,16 @@ Utilities for parsing the k8s deployment configuration
 logger = logging.getLogger('config_utils')
 
 
+def get_k8s_dict(k8s_conf):
+    """
+    Returns a dict of proxy settings
+    :param k8s_conf: the config dict
+    :return: a dict containing all of the proxy settings
+    :raises: Exception if not exists
+    """
+    return k8s_conf[consts.K8S_KEY]
+
+
 def get_proxy_dict(k8s_conf):
     """
     Returns a dict of proxy settings
@@ -31,7 +41,7 @@ def get_proxy_dict(k8s_conf):
     :return: a dict containing all of the proxy settings
     :raises: Exception if not exists
     """
-    return k8s_conf[consts.K8S_KEY][consts.PROXIES_KEY]
+    return get_k8s_dict(k8s_conf)[consts.PROXIES_KEY]
 
 
 def get_networks(k8s_conf):
@@ -41,7 +51,7 @@ def get_networks(k8s_conf):
     :return: a list containing all of the network settings
     :raises: Exception if not exists
     """
-    return k8s_conf[consts.K8S_KEY][consts.NETWORKS_KEY]
+    return get_k8s_dict(k8s_conf)[consts.NETWORKS_KEY]
 
 
 def get_multus_network(k8s_conf):
@@ -98,6 +108,27 @@ def get_multus_cni_weave_cfgs(k8s_conf):
     return list()
 
 
+def is_multus_cni_enabled(k8s_conf):
+    """
+    This function is used to get multus cni value
+    """
+    sriov_cni = False
+    flannel_cni = False
+    weave_cni = False
+    macvlan_cni = False
+    multus_cni = get_multus_net_elems(k8s_conf)
+    for cni in multus_cni:
+        if consts.SRIOV_TYPE == cni:
+            sriov_cni = True
+        elif consts.FLANNEL_TYPE == cni:
+            flannel_cni = True
+        elif consts.WEAVE_TYPE == cni:
+            weave_cni = True
+        elif consts.MACVLAN_TYPE == cni:
+            macvlan_cni = True
+    return sriov_cni or flannel_cni or weave_cni or macvlan_cni
+
+
 def get_default_network(k8s_conf):
     networks = get_networks(k8s_conf)
     for network in networks:
@@ -124,20 +155,29 @@ def get_pod_subnet(k8s_conf):
 
 
 def get_version(k8s_conf):
-    return k8s_conf[consts.K8S_KEY][consts.K8_VER_KEY]
+    return get_k8s_dict(k8s_conf)[consts.K8_VER_KEY]
 
 
 def get_ha_config(k8s_conf):
-    return k8s_conf[consts.K8S_KEY].get(consts.HA_CONFIG_KEY)
+    return get_k8s_dict(k8s_conf).get(consts.HA_CONFIG_KEY)
+
+
+def get_ha_lb_ips(k8s_conf):
+    out = list()
+    ha_configs = get_ha_config(k8s_conf)
+    if ha_configs:
+        for ha_config in ha_configs:
+            out.append(ha_config[consts.HA_API_EXT_LB_KEY][consts.IP_KEY])
+    return out
 
 
 def get_node_configs(k8s_conf):
-    return k8s_conf[consts.K8S_KEY][consts.NODE_CONF_KEY]
+    return get_k8s_dict(k8s_conf)[consts.NODE_CONF_KEY]
 
 
 def get_hostname_ips_dict(k8s_conf):
     out = dict()
-    node_confs = k8s_conf[consts.K8S_KEY][consts.NODE_CONF_KEY]
+    node_confs = get_node_configs(k8s_conf)
     for node_conf in node_confs:
         host_conf = node_conf[consts.HOST_KEY]
         out[host_conf[consts.HOSTNAME_KEY]] = host_conf[consts.IP_KEY]
@@ -160,7 +200,7 @@ def get_host_reg_port_dict(k8s_conf):
 
 def get_host_ips(k8s_conf):
     out = list()
-    node_confs = k8s_conf[consts.K8S_KEY][consts.NODE_CONF_KEY]
+    node_confs = get_k8s_dict(k8s_conf)[consts.NODE_CONF_KEY]
     for node_conf in node_confs:
         host_conf = node_conf[consts.HOST_KEY]
         out.append(host_conf[consts.IP_KEY])
@@ -169,7 +209,7 @@ def get_host_ips(k8s_conf):
 
 def get_hosts(k8s_conf):
     out = list()
-    node_confs = k8s_conf[consts.K8S_KEY][consts.NODE_CONF_KEY]
+    node_confs = get_k8s_dict(k8s_conf)[consts.NODE_CONF_KEY]
     for node_conf in node_confs:
         host_conf = node_conf[consts.HOST_KEY]
         out.append(host_conf[consts.HOSTNAME_KEY])
@@ -177,15 +217,15 @@ def get_hosts(k8s_conf):
 
 
 def get_basic_auth(k8s_conf):
-    return k8s_conf[consts.K8S_KEY][consts.BASIC_AUTH_KEY]
+    return get_k8s_dict(k8s_conf)[consts.BASIC_AUTH_KEY]
 
 
 def get_project_name(k8s_conf):
-    return k8s_conf[consts.K8S_KEY][consts.PROJECT_NAME_KEY]
+    return get_k8s_dict(k8s_conf)[consts.PROJECT_NAME_KEY]
 
 
 def get_artifact_dir(k8s_conf):
-    directory = k8s_conf[consts.K8S_KEY].get(consts.ARTIFACT_DIR_KEY, '/tmp')
+    directory = get_k8s_dict(k8s_conf).get(consts.ARTIFACT_DIR_KEY, '/tmp')
     return os.path.expanduser(directory)
 
 
@@ -200,33 +240,25 @@ def get_kubespray_dir(k8s_conf):
     return "{}/{}".format(directory, consts.KUBESPRAY_FOLDER_NAME)
 
 
-def get_metrics_server(k8s_conf):
-    return k8s_conf[consts.K8S_KEY].get(consts.METRICS_SERVER_KEY)
-
-
-def get_macvlan_nets(k8s_conf):
-    return k8s_conf[consts.K8S_KEY].get(consts.NETWORKS_KEY)
-
-
 def get_docker_repo(k8s_conf):
-    return k8s_conf[consts.K8S_KEY].get(consts.DOCKER_REPO_KEY)
+    return get_k8s_dict(k8s_conf).get(consts.DOCKER_REPO_KEY)
 
 
 def get_git_branch(k8s_conf):
-    return k8s_conf[consts.K8S_KEY][consts.GIT_BRANCH_KEY]
+    return get_k8s_dict(k8s_conf)[consts.GIT_BRANCH_KEY]
 
 
 def get_persis_vol(k8s_conf):
-    return k8s_conf[consts.K8S_KEY][consts.PERSIS_VOL_KEY]
+    return get_k8s_dict(k8s_conf)[consts.PERSIS_VOL_KEY]
 
 
 def get_ceph_vol(k8s_conf):
-    persist_vol = k8s_conf[consts.K8S_KEY][consts.PERSIS_VOL_KEY]
+    persist_vol = get_k8s_dict(k8s_conf)[consts.PERSIS_VOL_KEY]
     return persist_vol.get(consts.CEPH_VOLUME_KEY)
 
 
 def get_ceph_hosts(k8s_conf):
-    persist_vol = k8s_conf[consts.K8S_KEY][consts.PERSIS_VOL_KEY]
+    persist_vol = get_k8s_dict(k8s_conf)[consts.PERSIS_VOL_KEY]
     ceph_vol = persist_vol.get(consts.CEPH_VOLUME_KEY)
 
     out = list()
@@ -262,7 +294,7 @@ def get_ceph_ctrls(k8s_conf):
     out = list()
     ceph_hosts = get_ceph_hosts(k8s_conf)
     for ceph_host in ceph_hosts:
-        if ceph_host[consts.NODE_TYPE_KEY] == consts.CEPH_CTRL_TYPE_KEY:
+        if ceph_host[consts.NODE_TYPE_KEY] == consts.CEPH_CTRL_TYPE:
             out.append(ceph_host)
     return out
 
@@ -292,7 +324,7 @@ def get_ceph_osds(k8s_conf):
     out = list()
     ceph_hosts = get_ceph_hosts(k8s_conf)
     for ceph_host in ceph_hosts:
-        if ceph_host[consts.NODE_TYPE_KEY] == consts.CEPH_OSD_TYPE_KEY:
+        if ceph_host[consts.NODE_TYPE_KEY] == consts.CEPH_OSD_TYPE:
             out.append(ceph_host)
     return out
 
@@ -329,7 +361,7 @@ def get_ceph_osd_ips(k8s_conf):
 
 
 def get_host_vol(k8s_conf):
-    persist_vol = k8s_conf[consts.K8S_KEY][consts.PERSIS_VOL_KEY]
+    persist_vol = get_k8s_dict(k8s_conf)[consts.PERSIS_VOL_KEY]
     return persist_vol.get(consts.HOST_VOL_KEY)
 
 
@@ -427,3 +459,55 @@ def get_minion_node_ips(k8s_conf):
     for hostname, ip, node_type in node_tuple_3:
         out.append(ip)
     return out
+
+
+def is_logging_enabled(k8s_conf):
+    """
+    Returns T/F based on the kubernetes.enable_logging value
+    :param k8s_conf: the configuration dict
+    :return: T/F
+    """
+    value = get_k8s_dict(k8s_conf).get(consts.ENABLE_LOG_KEY, False)
+    return bool_val(value)
+
+
+def get_log_level(k8s_conf):
+    return get_k8s_dict(k8s_conf)[consts.LOG_LEVEL_KEY]
+
+
+def get_logging_port(k8s_conf):
+    return str(get_k8s_dict(k8s_conf)[consts.LOG_PORT_KEY])
+
+
+def is_cpu_alloc(k8s_conf):
+    """
+    Returns T/F based on the kubernetes.enable_logging value
+    :param k8s_conf: the configuration dict
+    :return: T/F
+    """
+    value = get_k8s_dict(k8s_conf).get(consts.CPU_ALLOC_KEY, False)
+    return bool_val(value)
+
+
+def is_metrics_server_enabled(k8s_conf):
+    """
+    Returns T/F based on the kubernetes.enable_logging value
+    :param k8s_conf: the configuration dict
+    :return: T/F
+    """
+    value = get_k8s_dict(k8s_conf).get(consts.METRICS_SERVER_KEY, False)
+    return bool_val(value)
+
+
+def bool_val(value):
+    if not value:
+        return False
+    elif isinstance(value, str):
+        if value.upper() == 'false'.upper() or value.upper() == 'no'.upper():
+            return False
+        if value.upper() == 'true'.upper() or value.upper() == 'yes'.upper():
+            return True
+    elif isinstance(value, bool):
+        return value
+    else:
+        return False
diff --git a/snaps_k8s/common/utils/validation_utils.py b/snaps_k8s/common/utils/validation_utils.py
index 5ef5786..8bb471f 100644
--- a/snaps_k8s/common/utils/validation_utils.py
+++ b/snaps_k8s/common/utils/validation_utils.py
@@ -16,10 +16,10 @@
 # Kubernetes Services
 
 
-import subprocess
 import logging
 import string
 from snaps_k8s.common.consts import consts
+from snaps_k8s.common.utils import config_utils
 
 logger = logging.getLogger('validation_utils')
 
@@ -31,68 +31,42 @@ def validate_deployment_file(config):
     Calls all the validations
     """
     logger.info("validate_deployment_file function")
-    index = 1
-
-    if not validate_kubernetes_tag(config):
-        exit(1)
-    if not validate_kubernetes_params(config):
-        exit(1)
-    if not validate_node_config_tag(config):
-        exit(1)
-    if not validate_node_config_params(config):
-        exit(1)
-    if not validate_count_master_minion(config):
-        exit(1)
-    if not validate_ha_config(config):
-        pass
-    else:
-        if not validate_api_ext_loadbalancer_tag_params(config):
-            exit(1)
-        if not validate_countmasters(config):
-            exit(1)
-    if not validate_access_and_security_tag(config):
-        pass
-    else:
-        if not validate_access_and_security_params(config):
-            exit(1)
-
-    if not validate_docker_repo_tag(config):
-        exit(1)
-    if not validate_docker_repo_params(config):
-        exit(1)
-    if not validate_proxies__tag(config):
-        pass
-    else:
-        if not validate_proxy__params(config):
-            exit(1)
-
-    if not validate_network__tag(config):
-        exit(1)
-    if not validate_default_network__params(config):
-        exit(1)
-    if not validate_multus_network_tag(config):
-        return True
-    else:
-        if not validate_multus_network_cni(config, index):
-            exit(1)
-        if not validate_multus_network_cni_conf(config, index):
-            exit(1)
-        if not validate_cni_params(config):
-            exit(1)
-        if not validate_duplicatein_cni_and_networkplugin(config):
-            exit(1)
-        if not ismaster_count_for_deployment(config):
-            exit(1)
-
-    if not validate_ceph_vol_tag(config):
-        if not validate_nodetype_data(config):
-            exit(1)
-        if not validate_ceph_vol_params(config):
-            exit(1)
-        if not validate_ceph_controller_params(config):
-            exit(1)
-        if not validate_ceph_osd__params(config):
-            exit(1)
+
+    validate_kubernetes_tag(config)
+    validate_kubernetes_params(config)
+    validate_hostnames(config)
+    validate_node_config_tag(config)
+    validate_node_config_params(config)
+    validate_count_master_minion(config)
+
+    if consts.HA_CONFIG_KEY in config:
+        validate_api_ext_loadbalancer_tag_params(config)
+
+    validate_countmasters(config)
+
+    if consts.ACCESS_SEC_KEY in config:
+        validate_access_and_security_params(config)
+
+    validate_docker_repo_tag(config)
+    validate_docker_repo_params(config)
+
+    validate_proxy_params(config)
+
+    validate_network_tag(config)
+    validate_default_network_params(config)
+
+    validate_multus_network_cni(config)
+    validate_multus_network_cni_conf(config)
+    validate_cni_params(config)
+    validate_duplicatein_cni_and_networkplugin(config)
+    ismaster_count_for_deployment(config)
+
+    if config_utils.get_ceph_vol(config):
+        validate_nodetype_data(config)
+        validate_ceph_vol_params(config)
+        validate_ceph_controller_params(config)
+        validate_ceph_osd_params(config)
+
     logger.info('Deployment file is valid')
 
 
@@ -101,10 +75,7 @@ def validate_kubernetes_tag(config):
     Checks the presence of Kubernetes tag
     """
     logger.info("checking kubernetes tag")
-    if validate_dict_data(config, consts.K8S_KEY):
-        return True
-    else:
-        return False
+    validate_dict_data(config, consts.K8S_KEY)
 
 
 def validate_kubernetes_params(config):
@@ -113,153 +84,102 @@ def validate_kubernetes_params(config):
     """
     logger.info("checking kubernetes params")
 
-    all_data_dictforkubernetesparams = config.get("kubernetes")
-    if not validate_dict_data(all_data_dictforkubernetesparams,
-                              consts.PROJECT_NAME_KEY):
-        return False
-    if not validate_dict_data(all_data_dictforkubernetesparams,
-                              consts.GIT_BRANCH_KEY):
-        return False
-    if not validate_dict_data(all_data_dictforkubernetesparams,
-                              consts.METRICS_SERVER_KEY):
-        return False
-    if not validate_dict_data(all_data_dictforkubernetesparams,
-                              consts.NODE_CONF_KEY):
-        return False
-    if not validate_dict_data(all_data_dictforkubernetesparams,
-                              consts.DOCKER_REPO_KEY):
-        return False
-    if not validate_dict_data(all_data_dictforkubernetesparams,
-                              consts.NETWORKS_KEY):
-        return False
-    if not validate_dict_data(all_data_dictforkubernetesparams,
-                              consts.PERSIS_VOL_KEY):
-        return False
-    if validate_dict_data2(all_data_dictforkubernetesparams,
-                           "Exclusive_CPU_alloc_support"):
-        if not (all_data_dictforkubernetesparams['Exclusive_CPU_alloc_support']
-                or not
-                all_data_dictforkubernetesparams /
-                ['Exclusive_CPU_alloc_support']):
-            logger.error("Value of Exclusive_CPU_alloc_support "
-                         "should be either true or false")
-            return False
-    return True
-
-
-def validate_ha_config(config):
-    logger.info("checking ha_config_tag")
-    all_data_dictforkubernetesparams = config.get("kubernetes")
-    if validate_dict_data2(all_data_dictforkubernetesparams,
-                           "ha_configuration"):
-        return True
-    return False
+    k8_config = config.get(consts.K8S_KEY)
+    validate_dict_data(k8_config, consts.PROJECT_NAME_KEY)
+    validate_dict_data(k8_config, consts.GIT_BRANCH_KEY)
+    validate_dict_data(k8_config, consts.METRICS_SERVER_KEY)
+    validate_dict_data(k8_config, consts.NODE_CONF_KEY)
+    validate_dict_data(k8_config, consts.DOCKER_REPO_KEY)
+    validate_dict_data(k8_config, consts.NETWORKS_KEY)
+    validate_dict_data(k8_config, consts.PERSIS_VOL_KEY)
+    validate_dict_data(k8_config, consts.CPU_ALLOC_KEY)
+
+
+def validate_hostnames(config):
+    """
+    Ensures that each configured hostname is unique
+    :param config: the k8s config
+    :raises ValidationException
+    """
+    logger.info('Checking to ensure all hostnames are unique')
+    nodes_info = config_utils.get_nodes_ip_name_type(config)
+    hostnames = set()
+    for hostname, ip, node_type in nodes_info:
+        hostnames.add(hostname)
+
+    if len(nodes_info) != len(hostnames):
+        raise ValidationException('Hostnames must be unique - {}'.format(
+            nodes_info))
 
 
 def validate_api_ext_loadbalancer_tag_params(config):
     logger.info("checking api_ext_loadbalancer_tag")
-    all_data_dictforkubernetesparams = config.get("kubernetes")
-    all_data_dict_for_node_configurationparams = config.get("kubernetes"). \
-        get("node_configuration")
-    all_data_dict_for_ha_params = config.get("kubernetes"). \
-        get("ha_configuration")
-    if validate_dict_data2(all_data_dictforkubernetesparams,
-                           "ha_configuration"):
-        if validate_dict_data(all_data_dict_for_ha_params[0],
-                              "api_ext_loadbalancer"):
-            if validate_dict_data(all_data_dict_for_ha_params[0].
-                                  get("api_ext_loadbalancer"), "ip"):
-                if validate_dict_data(
-                        all_data_dict_for_node_configurationparams[0], "host"):
-                    for all_data_for_host in \
-                            all_data_dict_for_node_configurationparams:
-                        if all_data_for_host.get("host")[consts.IP_KEY] == \
-                                all_data_dict_for_ha_params[0].get(
-                                    "api_ext_loadbalancer")['ip']:
-                            logger.error("bootstrap ip should never match "
-                                         "with the master or node")
-                            return False
-            else:
-                return False
-            if not validate_dict_data(all_data_dict_for_ha_params[0].
-                                      get("api_ext_loadbalancer"),
-                                      "user"):
-                return False
-            if not validate_dict_data(all_data_dict_for_ha_params[0].
-                                      get("api_ext_loadbalancer"),
-                                      "password"):
-                return False
-            if validate_dict_data(all_data_dict_for_ha_params[0].
-                                  get("api_ext_loadbalancer"), "port"):
-                if all_data_dict_for_ha_params[0]. \
-                        get("api_ext_loadbalancer")['port'] == "" or \
-                        all_data_dict_for_ha_params[0]. \
-                        get("api_ext_loadbalancer")['port'] == 6443:
-                    logger.error("Port shloud not be empty or 6443")
-                    return False
-            else:
-                return False
-        else:
-            return False
-    return True
+    k8s_dict = config_utils.get_k8s_dict(config)
+    node_configs = config_utils.get_node_configs(config)
+    ha_configs = config_utils.get_ha_config(config)
+
+    for ha_config in ha_configs:
+        validate_dict_data(k8s_dict, consts.HA_CONFIG_KEY)
+        validate_dict_data(ha_config, consts.HA_API_EXT_LB_KEY)
+        ha_lb_conf = ha_config[consts.HA_API_EXT_LB_KEY]
+        validate_dict_data(ha_lb_conf, consts.IP_KEY)
+        validate_dict_data(node_configs[0], consts.HOST_KEY)
+
+        for node_conf in node_configs:
+            if (node_conf.get(consts.HOST_KEY)[consts.IP_KEY] ==
+                    ha_lb_conf[consts.IP_KEY]):
+                raise ValidationException(
+                    'Bootstrap ip should never match with the master or node')
+
+        validate_dict_data(ha_lb_conf, consts.USER_KEY)
+        validate_dict_data(ha_lb_conf, consts.PASSWORD_KEY)
+        validate_dict_data(ha_lb_conf, consts.PORT_KEY)
+
+        ha_lb_port = ha_lb_conf.get(consts.PORT_KEY)
+        if not ha_lb_port or ha_lb_port == "" or ha_lb_port == 6443:
+            raise ValidationException('Port shoud not be empty or 6443')
 
 
 def validate_count_master_minion(config):
     logger.info("checking count master and minion")
-    countformaster = 0
-    countforminion = 0
-    all_data_dict_for_node_configuration_params = config.get("kubernetes").get(
-        "node_configuration")
-    if validate_dict_data(all_data_dict_for_node_configuration_params[0],
-                          "host"):
-        for all_data_for_host in all_data_dict_for_node_configuration_params:
-            if all_data_for_host.get("host")[consts.NODE_TYPE_KEY] == "master":
-                countformaster = countformaster + 1
-            if all_data_for_host.get("host")[consts.NODE_TYPE_KEY] == "minion":
-                countforminion = countforminion + 1
-        if countforminion > 0:
-            pass
-        else:
-            logger.error("Atleast one minion is required")
-            return False
-        if countformaster > 0:
-            pass
-        else:
-            logger.error("Atleast master is required")
-            return False
-
-    return True
+    master_count = 0
+    minion_count = 0
+    node_configs = config_utils.get_node_configs(config)
+    validate_dict_data(node_configs[0], consts.HOST_KEY)
+
+    for node_config in node_configs:
+        host = node_config[consts.HOST_KEY]
+        if host[consts.NODE_TYPE_KEY] == consts.NODE_TYPE_MASTER:
+            master_count = master_count + 1
+        if host[consts.NODE_TYPE_KEY] == "minion":
+            minion_count = minion_count + 1
+    if minion_count > 0:
+        pass
+    else:
+        raise ValidationException("At least one minion is required")
+    if master_count > 0:
+        pass
+    else:
+        raise ValidationException("At least master is required")
 
 
 def validate_countmasters(config):
-    logger.info("checking Count the no of masters")
-    count = 0
-    all_data_dict_for_node_configuration_params = config.get("kubernetes").get(
-        "node_configuration")
-    if validate_dict_data(all_data_dict_for_node_configuration_params[0],
-                          "host"):
-        for all_data_for_host in all_data_dict_for_node_configuration_params:
-            if all_data_for_host.get("host")[consts.NODE_TYPE_KEY] == "master":
-                count = count + 1
-        if count % 2 and count > 1:
-            return True
-        logger.error(
-            "Number of masters for HA should be odd and greater than one")
-        return False
-    return False
-
-
-def validate_access_and_security_tag(config):
     """
-    Checks the presence of basic_authentication tag
+    Raises an ValidationException when the master node count is even or < 1
+    :param config: the k8s config dict
+    :raises ValidationException
     """
-    logger.info("checking access_and_security tag")
+    logger.info("checking Count the no of masters")
+    node_info = config_utils.get_nodes_ip_name_type(config)
+
+    master_count = 0
+    for hostname, ip, node_type in node_info:
+        if node_type == consts.NODE_TYPE_MASTER:
+            master_count += 1
 
-    all_data_dict_for_kubernetesparams = config.get("kubernetes")
-    if not validate_dict_data(all_data_dict_for_kubernetesparams,
-                              "access_and_security"):
-        return False
-    return True
+    if master_count % 2 == 1 and master_count > 0:
+        return
+    raise ValidationException("Number of masters must be odd")
 
 
 def validate_access_and_security_params(config):
@@ -268,24 +188,18 @@ def validate_access_and_security_params(config):
     """
     logger.info("checking basic_authentication params")
 
-    all_data_dict_for_access_and_security_params = config.get(
-        "kubernetes").get("access_and_security")
-    if "authentication" in all_data_dict_for_access_and_security_params:
-        if "basic_authentication" not in \
-                all_data_dict_for_access_and_security_params.get(
-                    "authentication") \
-                or "token_authentication" not in \
-                all_data_dict_for_access_and_security_params.get(
-                            "authentication"):
-            logger.error(
+    sec_params = config_utils.get_k8s_dict(config).get(consts.ACCESS_SEC_KEY)
+    if consts.AUTH_KEY in sec_params:
+        auth_key = sec_params[consts.AUTH_KEY]
+        if (consts.BASIC_AUTH_KEY not in auth_key
+                or consts.TOKEN_AUTH_KEY not in auth_key):
+            raise ValidationException(
                 "Atleast one out of basic_authentication or "
                 "token_authentication must be present")
-            return False
         else:
-            return True
+            return
     else:
-        logger.error("authentication is not present")
-        return False
+        raise ValidationException("authentication is not present")
 
 
 def validate_node_config_tag(config):
@@ -293,11 +207,8 @@ def validate_node_config_tag(config):
     Checks the presence of node configuration tag
     """
     logger.info("checking node config tag")
-    all_data_dictfor_kubernetes_params = config.get("kubernetes")
-    if not validate_dict_data(all_data_dictfor_kubernetes_params,
-                              consts.NODE_CONF_KEY):
-        return False
-    return True
+    k8s_dict = config_utils.get_k8s_dict(config)
+    validate_dict_data(k8s_dict, consts.NODE_CONF_KEY)
 
 
 def validate_node_config_params(config):
@@ -306,45 +217,25 @@ def validate_node_config_params(config):
     """
     logger.info("checking node configuration params")
 
-    all_data_dict_for_node_configuration_params = config.get("kubernetes").get(
-        "node_configuration")
-    if validate_dict_data(all_data_dict_for_node_configuration_params[0],
-                          "host"):
-        for all_data_for_host in all_data_dict_for_node_configuration_params:
-            if not validate_dict_data(all_data_for_host.get("host"),
-                                      consts.HOSTNAME_KEY):
-                return False
-            if not validate_dict_data(all_data_for_host.get("host"),
-                                      consts.IP_KEY):
-                return False
-            if not validate_dict_data(all_data_for_host.get("host"),
-                                      consts.NODE_TYPE_KEY):
-                return False
-            if not validate_dict_data(all_data_for_host.get("host"),
-                                      consts.LABEL_KEY):
-                return False
-            if not validate_dict_data(all_data_for_host.get("host"),
-                                      consts.LBL_VAL_KEY):
-                return False
-            if not validate_dict_data(all_data_for_host.get("host"),
-                                      "registry_port"):
-                return False
-            else:
-                if not (all_data_for_host.get("host")[
-                            consts.NODE_TYPE_KEY] == 'master' or
-                        'minion' == all_data_for_host.get("host")[
-                                consts.NODE_TYPE_KEY]):
-                    logger.error("Node type should be either master or minion")
-                    return False
-            if not validate_dict_data(all_data_for_host.get("host"),
-                                      consts.PASSWORD_KEY):
-                return False
-            if not validate_dict_data(all_data_for_host.get("host"), "user"):
-                return False
-    else:
-        logger.error("host not present")
-        return False
-    return True
+    node_configs = config_utils.get_node_configs(config)
+    validate_dict_data(node_configs[0], consts.HOST_KEY)
+
+    for node_conf in node_configs:
+        host_conf = node_conf[consts.HOST_KEY]
+        validate_dict_data(host_conf, consts.HOSTNAME_KEY)
+        validate_dict_data(host_conf, consts.IP_KEY)
+        validate_dict_data(host_conf, consts.NODE_TYPE_KEY)
+        validate_dict_data(host_conf, consts.LABEL_KEY)
+        validate_dict_data(host_conf, consts.LBL_VAL_KEY)
+
+        if consts.REG_PORT_KEY in host_conf:
+            node_type = host_conf[consts.NODE_TYPE_KEY]
+            if not (node_type != consts.NODE_TYPE_MASTER
+                    or node_type != consts.NODE_TYPE_MINION):
+                raise ValidationException(
+                    'Node type should be either master or minion')
+        validate_dict_data(host_conf, consts.PASSWORD_KEY)
+        validate_dict_data(host_conf, consts.USER_KEY)
 
 
 def validate_docker_repo_tag(config):
@@ -353,11 +244,8 @@ def validate_docker_repo_tag(config):
     """
     logger.info("checking docker repo tag")
 
-    all_data_dict_for_kubernetes_params = config.get("kubernetes")
-    if not validate_dict_data(all_data_dict_for_kubernetes_params,
-                              consts.DOCKER_REPO_KEY):
-        return False
-    return True
+    k8s_dict = config.get(consts.K8S_KEY)
+    validate_dict_data(k8s_dict, consts.DOCKER_REPO_KEY)
 
 
 def validate_docker_repo_params(config):
@@ -365,238 +253,107 @@ def validate_docker_repo_params(config):
     Checks the presence of docker repo parameters
     """
     logger.info("checking docker repo  params")
-    all_data_dict_for_docker_repo_params = config.get("kubernetes").get(
-        "Docker_Repo")
-    if not validate_dict_data(all_data_dict_for_docker_repo_params,
-                              consts.IP_KEY):
-        return False
-    if not validate_dict_data(all_data_dict_for_docker_repo_params,
-                              consts.PASSWORD_KEY):
-        return False
-    if not validate_dict_data(all_data_dict_for_docker_repo_params, "user"):
-        return False
-    if not validate_dict_data(all_data_dict_for_docker_repo_params,
-                              consts.PORT_KEY):
-        return False
-    return True
-
-
-def validate_proxies__tag(config):
-    """
-    Checks the presence of proxies tag
-    """
-    logger.info("checking proxies tag")
-
-    all_data_dict_for_kubernetes_params = config.get("kubernetes")
-    if not validate_dict_data(all_data_dict_for_kubernetes_params,
-                              consts.PROXIES_KEY):
-        return False
-    return True
+    docker_repo_params = config_utils.get_docker_repo(config)
+    validate_dict_data(docker_repo_params, consts.IP_KEY)
+    validate_dict_data(docker_repo_params, consts.PASSWORD_KEY)
+    validate_dict_data(docker_repo_params, consts.USER_KEY)
+    validate_dict_data(docker_repo_params, consts.PORT_KEY)
 
 
-def validate_proxy__params(config):
+def validate_proxy_params(config):
     """
     Checks the presence of proxy parameters
     """
     logger.info("checking proxy  params")
-    all_data_dict_for_proxy_params = config.get("kubernetes").get("proxies")
+    proxy_params = config_utils.get_proxy_dict(config)
 
-    if consts.HTTP_PROXY_KEY in all_data_dict_for_proxy_params:
-        pass
-    else:
-        logger.error("HTTP proxy tag is mandatory")
-        return False
-    if consts.HTTPS_PROXY_KEY in all_data_dict_for_proxy_params:
-        pass
-    else:
-        logger.error("HTTPS proxy tag is mandatory")
-        return False
-    if consts.NO_PROXY_KEY in all_data_dict_for_proxy_params:
-        pass
-    else:
-        logger.error("No proxy tag is mandatory")
-        return False
-    return True
+    validate_dict_data(proxy_params, consts.FTP_PROXY_KEY)
+    validate_dict_data(proxy_params, consts.HTTP_PROXY_KEY)
+    validate_dict_data(proxy_params, consts.HTTPS_PROXY_KEY)
+    validate_dict_data(proxy_params, consts.NO_PROXY_KEY)
 
 
-def validate_network__tag(config):
+def validate_network_tag(config):
     """
     Checks the presence of network tag
     """
     logger.info("checking networks tag")
 
-    all_data_dict_for_kubernetes_params = config.get("kubernetes")
-    if not validate_dict_data(all_data_dict_for_kubernetes_params,
-                              consts.NETWORKS_KEY):
-        return False
-    return True
+    k8s_dict = config_utils.get_k8s_dict(config)
+    validate_dict_data(k8s_dict, consts.NETWORKS_KEY)
 
 
-def validate_default_network__params(config):
+def validate_default_network_params(config):
     """
     Checks the presence of default network tag and its parameters
     """
     logger.info("checking def networks  params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    if validate_dict_data(all_data_dict_for_net_params[0],
-                          consts.DFLT_NET_KEY):
-        if not validate_dict_data(all_data_dict_for_net_params[0].values()[0],
-                                  consts.NET_PLUGIN_KEY):
-            return False
-        else:
-            if all_data_dict_for_net_params[0].values()[0][
-               'networking_plugin']:
-                if not validate_dict_data(
-                        all_data_dict_for_net_params[0].values()[0],
-                        "isMaster"):
-                    return False
-        if not validate_dict_data(all_data_dict_for_net_params[0].values()[0],
-                                  consts.SRVC_SUB_KEY):
-            return False
-        if not validate_dict_data(all_data_dict_for_net_params[0].values()[0],
-                                  consts.POD_SUB_KEY):
-            return False
-        if not validate_dict_data(all_data_dict_for_net_params[0].values()[0],
-                                  consts.NETWORK_NAME_KEY):
-            return False
-    else:
-        logger.error("def network not present")
-        return False
-    return True
-
-
-def validate_multus_network_tag(config):
-    """
-    Checks the presence of multus network tag
-    """
-    logger.info("checking multus networks tag ")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    count = len(all_data_dict_for_net_params)
-    if count > 1:
-        if consts.MULTUS_NET_KEY in all_data_dict_for_net_params[1]:
-            return True
-        else:
-            return False
-    return False
-
-
-def validate_multus_network_tag_network_yaml(config):
-    """
-    Checks the presence of multus network tag for network yaml
-    """
-    logger.info("checking multus networks tag ")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
+    default_net = config_utils.get_default_network(config)
+    if not default_net:
+        raise ValidationException('Default network must be defined')
 
-    if consts.MULTUS_NET_KEY in all_data_dict_for_net_params[0]:
-        return True
-    return False
+    validate_dict_data(default_net, consts.NET_PLUGIN_KEY)
+    validate_dict_data(default_net, consts.MASTER_PLUGIN_KEY)
+    validate_dict_data(default_net, consts.SRVC_SUB_KEY)
+    validate_dict_data(default_net, consts.POD_SUB_KEY)
+    validate_dict_data(default_net, consts.NETWORK_NAME_KEY)
 
 
-def validate_multus_network_cni(config, index):
+def validate_multus_network_cni(config):
     """
     Checks the presence of CNI tag in Multus network and also checks
     presence of multus network tag
     """
     logger.info("checking multus networks CNI ")
-    net_params = config.get("kubernetes").get("Networks")
-
-    if validate_dict_data(net_params[index],
-                          consts.MULTUS_NET_KEY):
-        params_data = net_params[index][consts.MULTUS_NET_KEY]
-        key_to_append_multus_network_params = []
-        for element in params_data:
-            key_to_append_multus_network_params.append(element.keys())
-
-        if ['CNI'] in key_to_append_multus_network_params:
-            return True
-        else:
-            logger.error("CNI does not exist")
-            return False
-    else:
-        logger.error("Multus network does not exist")
-        return False
+    mult_nets = config_utils.get_multus_network(config)
+    for mult_net in mult_nets:
+        if consts.MULTUS_CNI_KEY in mult_net:
+            return
+    raise ValidationException(
+        '{} config does not exist'.format(consts.MULTUS_CNI_KEY))
 
 
-def validate_multus_network_cni_conf(config, index):
+def validate_multus_network_cni_conf(config):
     """
     Checks the presence of CNI Configuration tag in Multus network
     and also checks presence of multus network tag
     """
     logger.info("checking multus networks CNI CONF tag")
-    net_params = config.get("kubernetes").get("Networks")
-    if validate_dict_data(net_params[index],
-                          consts.MULTUS_NET_KEY):
-        params_data = net_params[index][consts.MULTUS_NET_KEY]
-        params_key = []
-        for element in params_data:
-            params_key.append(element.keys())
-        if [consts.MULTUS_CNI_CONFIG_KEY] not in params_key:
-            logger.error("CNIconfig does not exist")
-            return False
-    return True
+    mult_nets = config_utils.get_multus_network(config)
+    for mult_net in mult_nets:
+        if consts.MULTUS_CNI_CONFIG_KEY in mult_net:
+            return
+    raise ValidationException('{} config does not exist'.format(
+        consts.MULTUS_CNI_CONFIG_KEY))
 
 
 def validate_cni_params(config):
     """
     Checks the presence of atleast one plugin in Cni tag
     """
-    index = 1
     logger.info("checking multus networks  params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    list_for_cni_params = []
-    item_weave = consts.WEAVE_TYPE
-    item_flannel = consts.FLANNEL_TYPE
-    item_sriov = "sriov"
-    item_macvlan = "macvlan"
-    val = ""
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            list_for_cni_params.append(keys_in_all_keys)
+    net_configs = config_utils.get_networks(config)
+    cni_params = []
+
+    for all_keys in net_configs[1]:
+        for keys_in_all_keys in net_configs[1][all_keys]:
+            cni_params.append(keys_in_all_keys)
             break
 
-    for item in list_for_cni_params:
-        val = item.get('CNI')
-
-    if val is not None:
-        if item_weave in list_for_cni_params[0].get("CNI"):
-            if not validate_multus_network_weave_params(config):
-                logger.error("Weave network parameters are wrong")
-                return False
-            if not validate_masterflag_for_weave(config):
-                logger.error("master flag is true in weave ")
-                return False
-
-        if item_flannel in list_for_cni_params[0].get("CNI"):
-            if not validate_multus_network_flannelnet__params(config):
-                logger.error("flannel network parameters are wrong")
-                return False
-            if not validate_masterflag_for_flannel(config):
-                logger.error("master flag is true in flannel")
-                return False
-
-        if item_sriov in list_for_cni_params[0].get("CNI"):
-            if not validate_multus_network_sriov__params(config, index):
-                logger.error("sriov network parameters are wrong ")
-                return False
-            if not validate_masterflag_for_sriov(config):
-                logger.error("master flag is true in sriov")
-                return False
-            if not validate_dhcpmandatory(config, index):
-                logger.error("dhcp mandatory in cni if dhcp in sriov")
-                return False
-
-        if item_macvlan in list_for_cni_params[0].get("CNI"):
-            if not validate_multus_network_macvlan__params(config, index):
-                logger.error("macvlan network parameters are wrong ")
-                return False
-            if not validate_masterflag_for_macvlan(config):
-                logger.error("master flag is true in macvlan ")
-                return False
-            if not validate_dhcpmandatory(config, index):
-                logger.error("dhcp mandatory in cni if dhcp in macvlan")
-                return False
-
-    return True
+    for cni_param in cni_params:
+        if consts.WEAVE_TYPE in cni_param.get(consts.MULTUS_CNI_KEY):
+            validate_multus_network_weave_params(config)
+
+        if consts.FLANNEL_TYPE in cni_param.get(consts.MULTUS_CNI_KEY):
+            validate_multus_network_flannel_params(config)
+
+        if consts.SRIOV_TYPE in cni_param.get(consts.MULTUS_CNI_KEY):
+            validate_multus_network_sriov_params(config)
+
+        if consts.MACVLAN_TYPE in cni_param.get(consts.MULTUS_CNI_KEY):
+            validate_multus_network_macvlan_params(config)
+
+    validate_dhcpmandatory(config)
 
 
 def validate_duplicatein_cni_and_networkplugin(config):
@@ -605,318 +362,119 @@ def validate_duplicatein_cni_and_networkplugin(config):
     plugin tag and in Cni parameters
     """
     logger.info("checking duplicate values")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    networkpluginvalue = all_data_dict_for_net_params[0].values()[0][
-        'networking_plugin']
-
-    list_for_cni_params = []
-    item_weave = consts.WEAVE_TYPE
-    item_flannel = consts.FLANNEL_TYPE
-    item_sriov = "sriov"
-    item_macvlan = "macvlan"
-    val = ""
-
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            list_for_cni_params.append(keys_in_all_keys)
-            break
-
-    for item in list_for_cni_params:
-        val = item.get('CNI')
-
-    if val is not None:
-        if item_weave in list_for_cni_params[0].get(
-                "CNI") and item_weave == networkpluginvalue:
-            logger.error("duplicate weave")
-            return False
-        if item_flannel in list_for_cni_params[0].get(
-                "CNI") and item_flannel == networkpluginvalue:
-            logger.error("duplicate flannel")
-            return False
-        if item_sriov in list_for_cni_params[0].get(
-                "CNI") and item_sriov == networkpluginvalue:
-            logger.error("duplicate Sriov")
-            return False
-        if item_macvlan in list_for_cni_params[0].get(
-                "CNI") and item_macvlan == networkpluginvalue:
-            logger.error("duplicate macvlan")
-            return False
-    return True
-
-
-def validate_multus_network_flannelnet__params(config):
+    net_configs = config_utils.get_networks(config)
+    networkpluginvalue = net_configs[0].values()[0][
+        consts.NET_PLUGIN_KEY]
+
+    net_elems = config_utils.get_multus_net_elems(config)
+    if (consts.WEAVE_TYPE in net_elems
+            and consts.WEAVE_TYPE == networkpluginvalue):
+        raise ValidationException("duplicate weave")
+    if (consts.FLANNEL_TYPE in net_elems
+            and consts.FLANNEL_TYPE == networkpluginvalue):
+        raise ValidationException("duplicate flannel")
+    if (consts.SRIOV_TYPE in net_elems
+            and consts.SRIOV_TYPE == networkpluginvalue):
+        raise ValidationException("duplicate Sriov")
+    if (consts.MACVLAN_TYPE in net_elems
+            and consts.MACVLAN_TYPE == networkpluginvalue):
+        raise ValidationException("duplicate macvlan")
+
+
+def validate_multus_network_flannel_params(config):
     """
     Checks the presence of Flannel network parameters
     """
     logger.info("checking flannelnet params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-
-    keysofallnetworks = []
-    flag = False
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            cni_config_data = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-        for element in cni_config_data:
-            for all_keys in element:
-                keysofallnetworks.extend(element.values()[0])
-    counter = 0
-    for element in keysofallnetworks:
-        if 'flannel_network' in element:
-            counter = counter + 1
-    if counter > 0:
-        pass
-    else:
-        logger.error("flannel_network should be present atleast once")
-        return False
-    for element in keysofallnetworks:
-        if 'flannel_network' in element:
-            if "isMaster" in element.get("flannel_network"):
-                pass
-            else:
-                logger.error("isMaster Flag is absent in flannel network")
-                return False
-
-            if validate_dict_data(element['flannel_network'],
-                                  "network_name") and \
-                    validate_dict_data(element['flannel_network'],
-                                       "network") and \
-                    validate_dict_data(element['flannel_network'], "subnet"):
-                return True
-            else:
-                return False
-        else:
-            logger.error("flannel network does not exist")
-            return False
-    if not flag:
-        return False
+    flannel_nets = config_utils.get_multus_cni_flannel_cfgs(config)
+    if len(flannel_nets) == 0:
+        raise ValidationException('Requires at least one flannel network')
 
-    return True
+    for flannel_net in flannel_nets:
+        validate_dict_data(flannel_net, consts.FLANNEL_NET_DTLS_KEY)
+        flannel_dtls = flannel_net[consts.FLANNEL_NET_DTLS_KEY]
+        validate_dict_data(flannel_dtls, consts.MASTER_PLUGIN_KEY)
+        validate_dict_data(flannel_dtls, consts.NETWORK_NAME_KEY)
+        validate_dict_data(flannel_dtls, consts.NETWORK_KEY)
+        validate_dict_data(flannel_dtls, consts.SUBNET_KEY)
 
 
-def validate_multus_network_macvlan__params(config, index):
+def validate_multus_network_macvlan_params(config):
     """
     Checks the presence of Macvlan parameters also check Macvlan
     network name format and validations of "type"
     """
-    logger.info("checking Macvlan  params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-
-    keysofallnetworks = []
-    for all_keys in all_data_dict_for_net_params[index]:
-        for keys_in_all_keys in all_data_dict_for_net_params[index][all_keys]:
-            cni_config_data = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-
-        for element in cni_config_data:
-            for all_keys in element:
-                keysofallnetworks.extend(element.values()[0])
-    counter = 0
-    for element in keysofallnetworks:
-        if 'macvlan_networks' in element:
-            counter = counter + 1
-    if counter > 0:
-        pass
-    else:
-        logger.error("macvlan_networks should be present atleast once")
-        return False
-    for element in keysofallnetworks:
-        if 'macvlan_networks' in element:
-            if "isMaster" in element.get("macvlan_networks"):
-                pass
-            else:
-                logger.error("isMaster Flag is absent in macvlan_networks")
-                return False
-            if validate_dict_data(element['macvlan_networks'],
-                                  "parent_interface") and \
-                    validate_dict_data(element['macvlan_networks'], "ip") and \
-                    validate_dict_data(element['macvlan_networks'],
-                                       "hostname") and \
-                    validate_dict_data(element['macvlan_networks'],
-                                       "vlanid") and \
-                    validate_dict_data(element['macvlan_networks'],
-                                       "master") and \
-                    validate_dict_data(element['macvlan_networks'], "type") \
-                    and validate_dict_data(element['macvlan_networks'],
-                                           "network_name"):
-                stringfornwname = element['macvlan_networks']['network_name']
-                to_find = "_"
-                count = stringfornwname.find(to_find)
-                count2 = len(
-                    filter(lambda x: x in string.uppercase, stringfornwname))
-
-                if not (count < 1 and count2 < 1):
-                    logger.error("Network_name value format is wrong ")
-                    return False
-
-                if element['macvlan_networks']['type'] == "host-local":
-                    if not (validate_dict_data(element['macvlan_networks'],
-                                               "rangeEnd") and
-                            validate_dict_data(
-                                    element['macvlan_networks'],
-                                    "rangeStart") and
-                            validate_dict_data(
-                                    element['macvlan_networks'],
-                                    "routes_dst") and
-                            validate_dict_data(
-                                    element['macvlan_networks'],
-                                    "subnet") and
-                            validate_dict_data(
-                                    element['macvlan_networks'],
-                                    "gateway")):
-                        return False
-            else:
-                return False
-    return True
+    logger.info("checking Macvlan params")
+    macvlan_nets = config_utils.get_multus_cni_macvlan_cfgs(config)
+    if len(macvlan_nets) == 0:
+        raise ValidationException('At least one macvlan network required')
 
+    for macvlan_net in macvlan_nets:
+        macvlan_conf = macvlan_net[consts.MACVLAN_NET_DTLS_KEY]
+        validate_dict_data(macvlan_conf, consts.MACVLAN_PARENT_INTF_KEY)
+        validate_dict_data(macvlan_conf, consts.HOSTNAME_KEY)
+        validate_dict_data(macvlan_conf, consts.IP_KEY)
+        validate_dict_data(macvlan_conf, consts.NODE_TYPE_MASTER)
+        validate_dict_data(macvlan_conf, consts.TYPE_KEY)
+        validate_dict_data(macvlan_conf, consts.NETWORK_NAME_KEY)
 
-def validate_multus_network_sriov__params(config, index):
-    """
-    Checks the presence of Sriov parameters and validations of "type"
-    """
-    logger.info("checking SRIOV  params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-
-    keysofallnetworks = []
-    numberofnetworkinonehost = 0
-    for all_keys in all_data_dict_for_net_params[index]:
-        for keys_in_all_keys in all_data_dict_for_net_params[index][all_keys]:
-            cni_config_data = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-
-        for element in cni_config_data:
-            for all_keys in element:
-                keysofallnetworks.extend(element.values()[0])
-    counter = 0
-    for element in keysofallnetworks:
-        if type(element) == dict and 'host' in element:
-            counter = counter + 1
-    if counter > 0:
-        pass
-    else:
-        logger.error("Atleast one host must be there")
-        return False
-    i = 0
-    for element in keysofallnetworks:
-        if 'host' in element:
-            if validate_dict_data(element['host'], "networks") and \
-                    validate_dict_data(element['host'], "hostname"):
-                for itemnetwork in element.get("host").get("networks"):
-                    if "isMaster" in element.get("host").get("networks")[i]:
-                        pass
-                    else:
-                        logger.error(
-                            "isMaster Flag is absent in host in Sriov")
-                        return False
-
-                    numberofnetworkinonehost = numberofnetworkinonehost + 1
-
-                    stringfornwname = element['host']['networks'][i][
-                        'network_name']
-                    to_find = "_"
-                    count = stringfornwname.find(to_find)
-                    count2 = len(filter(lambda x: x in string.uppercase,
-                                        stringfornwname))
-
-                    if count < 1 and count2 < 1:
-                        pass
-                    else:
-                        logger.error("Network_name value format is wrong ")
-                        return False
-
-                    if not validate_dict_data(element['host']['networks'][i],
-                                              "type"):
-                        return False
-                    else:
-                        if element['host']['networks'][i]['type'] == \
-                                "host-local":
-                            if not validate_dict_data(
-                                    element['host']['networks'][i],
-                                    "rangeStart"):
-                                return False
-                            if not validate_dict_data(
-                                    element['host']['networks'][i],
-                                    "sriov_intf"):
-                                return False
-                            if not validate_dict_data(
-                                    element['host']['networks'][i],
-                                    "rangeEnd"):
-                                return False
-                            if not validate_dict_data(
-                                    element['host']['networks'][i],
-                                    "network_name"):
-                                return False
-                            if not validate_dict_data(
-                                    element['host']['networks'][i],
-                                    "dpdk_enable"):
-                                return False
-                            if not validate_dict_data(
-                                    element['host']['networks'][i],
-                                    "sriov_gateway"):
-                                return False
-                            if not validate_dict_data(
-                                    element['host']['networks'][i],
-                                    "sriov_subnet"):
-                                return False
-                            i = i + 1
-            else:
-                return False
-    return True
+        net_name = macvlan_conf[consts.NETWORK_NAME_KEY]
+        to_find = "_"
+        count = net_name.find(to_find)
+        count2 = len(filter(lambda x: x in string.uppercase, net_name))
 
+        if not (count < 1 and count2 < 1):
+            raise ValidationException("Network_name value format is wrong ")
 
-def validate_multus_network_weave_params(config):
+        if macvlan_conf[consts.TYPE_KEY] == consts.NET_TYPE_LOCAL_TYPE:
+            validate_dict_data(macvlan_conf, consts.RANGE_END_KEY)
+            validate_dict_data(macvlan_conf, consts.RANGE_START_KEY)
+            validate_dict_data(macvlan_conf, consts.ROUTES_DST_KEY)
+            validate_dict_data(macvlan_conf, consts.SUBNET_KEY)
+            validate_dict_data(macvlan_conf, consts.GATEWAY_KEY)
+
+
+def validate_multus_network_sriov_params(config):
     """
-    Checks the presence of weave parameters
+    Checks the presence of Sriov parameters and validations of "type"
     """
-    logger.info("checking weave_params params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
+    logger.info("checking SRIOV  params")
 
-    keysofallnetworks = []
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            cni_config_data = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
+    sriov_hosts = config_utils.get_multus_cni_sriov_cfgs(config)
 
-        for element in cni_config_data:
+    for sriov_host in sriov_hosts:
+        validate_dict_data(sriov_host, consts.HOST_KEY)
+        host_data = sriov_host[consts.HOST_KEY]
+        validate_dict_data(host_data, consts.SRIOV_NETWORKS_KEY)
+        net_configs = host_data[consts.SRIOV_NETWORKS_KEY]
 
-            for all_keys in element:
-                keysofallnetworks.extend(element.values()[0])
-    counter = 0
-    for element in keysofallnetworks:
-        if 'weave_network' in element:
-            counter = counter + 1
+        for net_config in net_configs:
+            validate_dict_data(net_config, consts.MASTER_PLUGIN_KEY)
+            validate_dict_data(net_config, consts.HOSTNAME_KEY)
+            validate_dict_data(net_config, consts.NETWORK_NAME_KEY)
+            validate_dict_data(net_config, consts.TYPE_KEY)
 
-    if counter > 0:
-        pass
-    else:
-        logger.error("weave_network should be present atleast once")
-        return False
-    for element in keysofallnetworks:
-        if 'weave_network' in element:
-            if "isMaster" in element.get("weave_network"):
-                pass
-            else:
-                logger.error("isMaster Flag is absent in weave_network")
-                return False
-            if not (validate_dict_data(element['weave_network'],
-                                       "network_name") and
-                    validate_dict_data(element['weave_network'], "subnet")):
-                return False
-    return True
+            if net_config[consts.TYPE_KEY] == consts.NET_TYPE_LOCAL_TYPE:
+                validate_dict_data(net_config, consts.RANGE_START_KEY)
+                validate_dict_data(net_config, consts.RANGE_END_KEY)
+                validate_dict_data(net_config, consts.SRIOV_INTF_KEY)
+                validate_dict_data(net_config, consts.NETWORK_NAME_KEY)
+                validate_dict_data(net_config, consts.SRIOV_DPDK_ENABLE_KEY)
+                validate_dict_data(net_config, consts.SRIOV_GATEWAY_KEY)
+                validate_dict_data(net_config, consts.SRIOV_SUBNET_KEY)
 
 
-def validate_ceph_vol_tag(config):
+def validate_multus_network_weave_params(config):
     """
-    Checks the presence of Ceph Volume tag
+    Checks the presence of weave parameters
     """
-    logger.info("checking ceph_vol_tag")
-    all_data_dict_for_net_params = config.get("kubernetes").get(
-        consts.PERSIS_VOL_KEY)
-    if 'Ceph_Volume' not in all_data_dict_for_net_params.keys():
-        return False
-    if not validate_dict_data(all_data_dict_for_net_params, "Host_Volume"):
-        return False
-    return True
+    logger.info("checking weave_params params")
+    weave_nets = config_utils.get_multus_cni_weave_cfgs(config)
+    for weave_net in weave_nets:
+        weave_details = weave_net[consts.WEAVE_NET_DTLS_KEY]
+        validate_dict_data(weave_details, consts.MASTER_PLUGIN_KEY)
+        validate_dict_data(weave_details, consts.NETWORK_NAME_KEY)
+        validate_dict_data(weave_details, consts.SUBNET_KEY)
 
 
 def validate_ceph_vol_params(config):
@@ -925,25 +483,16 @@ def validate_ceph_vol_params(config):
     """
     logger.info("checking ceph_vol_params")
 
-    all_data_dict_for_ceph_volume_param = config.get("kubernetes").get(
-        consts.PERSIS_VOL_KEY).get(consts.CEPH_VOLUME_KEY)
-    for all_ceph_colume_param_data in all_data_dict_for_ceph_volume_param:
-        if not validate_dict_data(all_ceph_colume_param_data.get("host"),
-                                  consts.HOSTNAME_KEY):
-            return False
-        if not validate_dict_data(all_ceph_colume_param_data.get("host"),
-                                  consts.IP_KEY):
-            return False
-        if not validate_dict_data(all_ceph_colume_param_data.get("host"),
-                                  consts.NODE_TYPE_KEY):
-            return False
-        if not validate_dict_data(all_ceph_colume_param_data.get("host"),
-                                  consts.PASSWORD_KEY):
-            return False
-        if not validate_dict_data(all_ceph_colume_param_data.get("host"),
-                                  "user"):
-            return False
-    return True
+    ceph_vols = config_utils.get_ceph_vol(config)
+
+    for ceph_vol in ceph_vols:
+        validate_dict_data(ceph_vol, consts.HOST_KEY)
+
+        ceph_host = ceph_vol[consts.HOST_KEY]
+        validate_dict_data(ceph_host, consts.IP_KEY)
+        validate_dict_data(ceph_host, consts.NODE_TYPE_KEY)
+        validate_dict_data(ceph_host, consts.PASSWORD_KEY)
+        validate_dict_data(ceph_host, consts.USER_KEY)
 
 
 def validate_nodetype_data(config):
@@ -951,49 +500,17 @@ def validate_nodetype_data(config):
     Checks the presence of nodetype datatype
     """
     logger.info("checking nodetype_data")
-    all_data_dict_for_ceph_volume_param = config.get("kubernetes").get(
-        consts.PERSIS_VOL_KEY).get(consts.CEPH_VOLUME_KEY)
-
-    for all_ceph_colume_param_data in all_data_dict_for_ceph_volume_param:
-        if validate_dict_data(all_ceph_colume_param_data.get("host"),
-                              consts.NODE_TYPE_KEY):
-            if all_ceph_colume_param_data.get("host")[
-                'node_type'] == "ceph_controller" or \
-                            all_ceph_colume_param_data.get("host")[
-                                'node_type'] == "ceph_osd":
-                return True
-            else:
-                logger.error(
-                    "ceph_controller or ceph_osd both are not "
-                    "present in node_type")
-                return False
-        else:
-            logger.error("Nodetype tag not present")
-            return False
-    return True
+    ceph_vol_hosts = config_utils.get_ceph_vol(config)
+    for ceph_vol_host in ceph_vol_hosts:
+        host_conf = ceph_vol_host[consts.HOST_KEY]
+        validate_dict_data(host_conf, consts.NODE_TYPE_KEY)
+        node_type = host_conf[consts.NODE_TYPE_KEY]
 
-
-def validate_ceph_claim_params(config):
-    """
-    Checks the presence of Ceph Claim tag and its parameters
-    """
-    logger.info("checking ceph_claim_params")
-    all_data_dict_for_ceph_volume_param = config.get("kubernetes").get(
-        consts.PERSIS_VOL_KEY).get(consts.CEPH_VOLUME_KEY)
-
-    for all_ceph_colume_param_data in all_data_dict_for_ceph_volume_param:
-        if consts.CEPH_CLAIMS_KEY in all_ceph_colume_param_data.get("host"):
-            for element in all_ceph_colume_param_data.get("host").get(
-                    "Ceph_claims"):
-                dict_claim_param = element['claim_parameters']
-                if not validate_dict_data(dict_claim_param, "claim_name"):
-                    return False
-                if not validate_dict_data(dict_claim_param, "storage"):
-                    return False
-        else:
-            logger.error("Ceph claims tag not present ")
-            return False
-    return True
+        if (node_type != consts.CEPH_CTRL_TYPE
+                and node_type != consts.CEPH_OSD_TYPE):
+            raise ValidationException(
+                'Ceph node type is not {} or {}'.format(
+                    consts.CEPH_CTRL_TYPE, consts.CEPH_OSD_TYPE))
 
 
 def validate_ceph_controller_params(config):
@@ -1001,623 +518,123 @@ def validate_ceph_controller_params(config):
     Checks the presence of Ceph Controller parameters for ceph claim
     """
     logger.info("checking ceph_controller_params")
-    all_data_dict_for_ceph_volume_param = config.get("kubernetes").get(
-        consts.PERSIS_VOL_KEY).get(consts.CEPH_VOLUME_KEY)
-
-    for all_ceph_colume_param_data in all_data_dict_for_ceph_volume_param:
-        if all_ceph_colume_param_data.get("host")['node_type'] == \
-                "ceph_controller":
-            if consts.CEPH_CLAIMS_KEY in \
-                    all_ceph_colume_param_data.get("host") and \
-                    "second_storage" not in \
-                    all_ceph_colume_param_data.get("host"):
-                return True
-            else:
-                logger.error(
-                    "for ceph_controller only CephClaim should be present")
-                return False
-    return True
+    ceph_hosts = config_utils.get_ceph_vol(config)
+    for ceph_host in ceph_hosts:
+        ceph_host_data = ceph_host[consts.HOST_KEY]
+        if ceph_host_data[consts.NODE_TYPE_KEY] == consts.CEPH_CTRL_TYPE:
+            validate_dict_data(ceph_host_data, consts.CEPH_CLAIMS_KEY)
+            claims = ceph_host_data[consts.CEPH_CLAIMS_KEY]
+            for claim in claims:
+                claim_params = claim[consts.CLAIM_PARAMS_KEY]
+                validate_dict_data(claim_params, consts.CEPH_CLAIM_NAME_KEY)
+                validate_dict_data(claim_params, consts.CEPH_STORAGE_KEY)
+        else:
+            validate_dict_data(ceph_host_data, consts.STORAGE_TYPE_KEY)
 
 
-def validate_ceph_osd__params(config):
+def validate_ceph_osd_params(config):
     """
     Checks the presence of Ceph osd parameters foe secondary storage presence
     """
     logger.info("checking ceph_osd_params")
-    all_data_dict_for_ceph_volume_param = config.get("kubernetes").get(
-        consts.PERSIS_VOL_KEY).get(consts.CEPH_VOLUME_KEY)
-
-    for all_ceph_colume_param_data in all_data_dict_for_ceph_volume_param:
-        if all_ceph_colume_param_data.get("host")['node_type'] == "ceph_osd":
-            if consts.CEPH_CLAIMS_KEY not in all_ceph_colume_param_data.get(
-                    "host") and \
-                            "second_storage" in all_ceph_colume_param_data.get(
-                        "host"):
-                return True
+    ceph_hosts = config_utils.get_ceph_vol(config)
+
+    for ceph_host in ceph_hosts:
+        ceph_host_data = ceph_host[consts.HOST_KEY]
+        if ceph_host_data[consts.NODE_TYPE_KEY] == consts.CEPH_OSD_TYPE:
+            if (consts.CEPH_CLAIMS_KEY not in ceph_host_data
+                    and consts.STORAGE_TYPE_KEY in ceph_host_data):
+                return
             else:
-                logger.error(
+                raise ValidationException(
                     "for ceph_osd only secondary storage should be present")
-                return False
-    return True
 
 
-def validate_dhcpmandatory(config, index):
+def validate_dhcpmandatory(config):
     """
     Checks the presence of DHCP CNI Plugin with Multus, if SRIOV or Multus
     uses dhcp as network type
     """
     logger.info("checking dhcp mandatory values")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-
-    li_for_cni_params = []
-    itemdhcp = "dhcp"
-    for all_keys in all_data_dict_for_net_params[index]:
-        for keys_in_all_keys in all_data_dict_for_net_params[index][all_keys]:
-            li_for_cni_params.append(keys_in_all_keys)
+    has_dhcp = False
+    macvlan_nets = config_utils.get_multus_cni_macvlan_cfgs(config)
+    for macvlan_net in macvlan_nets:
+        macvlan_conf = macvlan_net[consts.MACVLAN_NET_DTLS_KEY]
+        if macvlan_conf[consts.TYPE_KEY] == consts.DHCP_TYPE:
+            has_dhcp = True
             break
-    count = 0
-    val = ""
-
-    for item in li_for_cni_params:
-        val = item.get('CNI')
-
-    if val is not None:
-        if itemdhcp in li_for_cni_params[0].get("CNI"):
-            count = count + 1
-
-    li_for_cni_conf_params = []
-    for all_keys in all_data_dict_for_net_params[index]:
-        for keys_in_all_keys in all_data_dict_for_net_params[index][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-
-        for element in datain_cni_conf:
-            for all_keys in element:
-                li_for_cni_conf_params.extend(element.values()[0])
-    i = 0
-    for element in li_for_cni_conf_params:
-        if 'host' in element:
-            if (validate_dict_data(element['host'], "networks") and
-                    validate_dict_data(element['host'], "hostname")):
-                for itemnetwork in element.get("host").get("networks"):
-                    if element['host']['networks'][i]['type'] == "dhcp":
-                        if count <= 0:
-                            logger.error(
-                                "if dhcp in sriov then dhcp must be cni")
-                            return False
-                    i = i + 1
-    list_for_cni_conf2 = []
-    for all_keys in all_data_dict_for_net_params[index]:
-        for keys_in_all_keys in all_data_dict_for_net_params[index][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-        for element in datain_cni_conf:
-            list_for_cni_conf2.extend(element.values()[0])
-
-    for element in list_for_cni_conf2:
-        if 'macvlan_networks' in element:
-            if element['macvlan_networks']['type'] == "dhcp":
-                if count <= 0:
-                    logger.error("if dhcp in macvlan then dhcp must be cni")
-                    return False
-    return True
-
-
-counterforIsmaster = 0
-
-
-def validate_count_in_deployment(config):
-    """
-    Checks the presence of master fag must be true for only once
-    """
-    global counterforIsmaster
-    logger.info("checking count masterflag in default")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    count = 0
-    is_master_val = all_data_dict_for_net_params[0].values()[0]["isMaster"]
-
-    if is_master_val == "true":
-        count = count + 1
-
-    return count
 
+    if not has_dhcp:
+        sriov_nets = config_utils.get_multus_cni_sriov_cfgs(config)
+        for sriov_net in sriov_nets:
+            sriov_conf = sriov_net[consts.HOST_KEY]
+            sriov_net_confs = sriov_conf[consts.SRIOV_NETWORKS_KEY]
+            for sriov_net_conf in sriov_net_confs:
+                if sriov_net_conf[consts.TYPE_KEY] == consts.DHCP_TYPE:
+                    has_dhcp = True
+                    break
 
-counterforIsmaster = 0
-
-
-def validate_masterflag_for_weave(config):
-    """
-    Checks the presence of master fag must be true for only once
-    """
-    global counterforIsmaster
-    logger.info("checking Master Flag params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    list_for_cni_conf_params = []
-    count = 0
-    is_master_val = all_data_dict_for_net_params[0].values()[0]["isMaster"]
-
-    if is_master_val == "true":
-        count = count + 1
-
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-        for element in datain_cni_conf:
-            list_for_cni_conf_params.extend(element.values()[0])
-
-    for element in list_for_cni_conf_params:
-
-        if 'weave_network' in element:
-            is_master_for_weave = element['weave_network']['isMaster']
-            if is_master_for_weave == "true":
-                count = count + 1
-                counterforIsmaster = counterforIsmaster + 1
-    if count == 0:
-        return True
-    if count != 1:
-        logger.info("isMaster is true more than 1 time")
-        return False
-
-    return True
-
-
-def validate_masterflag_for_flannel(config):
-    """
-    Checks the presence of master fag must be true for only once
-    """
-    global counterforIsmaster
-    logger.info("checking Master Flag params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    list_for_cni_conf_params = []
-    count = 0
-    is_master_val = all_data_dict_for_net_params[0].values()[0]["isMaster"]
-
-    if is_master_val == "true":
-        count = count + 1
-
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-        for element in datain_cni_conf:
-            list_for_cni_conf_params.extend(element.values()[0])
-
-    for element in list_for_cni_conf_params:
-        if 'flannel_network' in element:
-            is_master_for_flannel = element['flannel_network']['isMaster']
-            if is_master_for_flannel == "true":
-                count = count + 1
-                counterforIsmaster = counterforIsmaster + 1
-    if count == 0:
-        return True
-    if count != 1:
-        logger.info("isMaster is true more than 1 time")
-        return False
-    return True
-
-
-def validate_masterflag_for_macvlan(config):
-    """
-    Checks the presence of master fag must be true for only once
-    """
-    global counterforIsmaster
-    logger.info("checking Master Flag params")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    list_for_cni_conf_params = []
-    count = 0
-    is_master_val = all_data_dict_for_net_params[0].values()[0]["isMaster"]
-
-    if is_master_val == "true":
-        count = count + 1
-
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-        for element in datain_cni_conf:
-            list_for_cni_conf_params.extend(element.values()[0])
-
-    for element in list_for_cni_conf_params:
-        if 'macvlan_networks' in element:
-            is_master_for_macvlan = element['macvlan_networks']['isMaster']
-            if is_master_for_macvlan == "true":
-                count = count + 1
-                counterforIsmaster = counterforIsmaster + 1
-
-    if count == 0:
-        return True
-    if count != 1:
-        logger.info("isMaster is true more than 1 time")
-        return False
-
-    return True
-
-
-def validate_masterflag_for_sriov(config):
-    """
-    Checks the presence of master fag must be true for only once
-    """
-    global counterforIsmaster
-    logger.info("checking Master Flag params for Sriov")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    list_for_cni_conf_params = []
-    count = 0
-    is_master_val = all_data_dict_for_net_params[0].values()[0]["isMaster"]
-
-    if is_master_val == "true":
-        count = count + 1
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-        for element in datain_cni_conf:
-            list_for_cni_conf_params.extend(element.values()[0])
-    i = 0
-    for element in list_for_cni_conf_params:
-        if 'host' in element:
-            if validate_dict_data(element['host'], "networks") and \
-                    validate_dict_data(element['host'], "hostname"):
-
-                for itemnetwork in element.get("host").get("networks"):
-                    is_master_for_sriov = \
-                        element['host']['networks'][i]['isMaster']
-
-                    if is_master_for_sriov == "true":
-                        count = count + 1
-                        counterforIsmaster = counterforIsmaster + 1
-                    i = i + 1
-    if count == 0:
-        return True
-    if count != 1:
-        logger.info("isMaster is true more than 1 time")
-        return False
-
-    return True
+    if has_dhcp:
+        cni_types = config_utils.get_multus_net_elems(config)
+        if consts.DHCP_TYPE not in cni_types:
+            raise ValidationException(
+                'DHCP must be in the {} list'.format(consts.MULTUS_CNI_KEY))
 
 
 def ismaster_count_for_deployment(config):
     """
    Checks the presence of master fag must be true atleast once in deployment
     """
-    global counterforIsmaster
-    if counterforIsmaster > 1:
-        logger.error("Ismaster is present more than once")
-        return False
-    if counterforIsmaster == 0 and validate_count_in_deployment(config) == 0:
-        logger.error("isMaster should be true atleast once in deployment")
-        return False
-
-    if counterforIsmaster == 1 and validate_count_in_deployment(config) > 0:
-        logger.error("Ismaster is present more than once")
-        return False
-    if counterforIsmaster > 0 and validate_count_in_deployment(config) == 1:
-        logger.error("Ismaster is present more than once")
-        return False
-    if counterforIsmaster > 0 and validate_count_in_deployment(config) > 0:
-        logger.error("Ismaster is present more than once")
-        return False
-    return True
-
-
-def validate_dict_data(dict_name, dict_item):
-    if not dict_name.get(dict_item):
-        logger.error(dict_item + " item not exists !! validation failed")
-        return False
-    return True
-
-
-def validate_dict_data2(dict_name, dict_item):
-    if not dict_name.get(dict_item):
-        return False
-    return True
-
-
-def validate_cni_params_for_network_deployment(config):
-    """
-    Checks the presence of atleast one plugin in Cni tag
-    """
-    index = 0
-    logger.info("checking multus networks params for network deployment")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    list_for_cni_params = []
-    item_sriov = "sriov"
-    item_macvlan = "macvlan"
-    val = ""
-    for all_keys in all_data_dict_for_net_params[0]:
-        for keys_in_all_keys in all_data_dict_for_net_params[0][all_keys]:
-            list_for_cni_params.append(keys_in_all_keys)
-            break
-
-    for item in list_for_cni_params:
-        val = item.get('CNI')
-
-    if val is not None:
-        if item_sriov in list_for_cni_params[0].get("CNI"):
-
-            if not validate_multus_network_sriov__params(config, index):
-                logger.error("Sriov network or  parameters are not defined")
-                return False
-            if not validate_masterflag_network_dep_sriov(config):
-                logger.error("master flag is true in sriov")
-                return False
-            if not validate_dhcpmandatory(config, index):
-                logger.error("dhcp mandatory in cni if dhcp in sriov")
-                return False
-
-        if item_macvlan in list_for_cni_params[0].get("CNI"):
-            if not validate_masterflag_network_dep_macvlan(config):
-                logger.error("master flag is true in macvlan")
-                return False
-            if not validate_dhcpmandatory(config, index):
-                logger.error("dhcp mandatory in cni if dhcp in macvlan")
-                return False
-            if not validate_multus_network_macvlan__params(config, index):
-                logger.error("Macvlan network or parameters are not defined")
-                return False
-    return True
-
-
-def validate_multus_network_cniconf__params_for_network_deployment(config):
-    """
-    Checks the presence of all plugins in Cni Configuration parameters
-    """
-    logger.info("checking cniconf params for dynamic deployment")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-
-    list_cni_config_params = []
-
-    for all_keys in all_data_dict_for_net_params[0]:
-        for keys_in_all_keys in all_data_dict_for_net_params[0][all_keys]:
-            cni_config_data = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-        for element in cni_config_data:
-            list_cni_config_params.append(element.keys())
-        if ['Sriov'] not in list_cni_config_params:
-            logger.error("Sriov does not exist")
-            return False
-        if ['Macvlan'] not in list_cni_config_params:
-            logger.error("Macvlan does not exist")
-            return False
-    return True
-
-
-def validate_ismaster_for_network_dep_and_dep_file(config,
-                                                   config_deployment_bkup):
-    """
-    Checks the presence of master fag must be true for only once
+    master_count = 0
+    dflt_net = config_utils.get_default_network(config)
+    if config_utils.bool_val(dflt_net[consts.MASTER_PLUGIN_KEY]):
+        master_count += 1
+
+    multus_nets = config_utils.get_multus_cni_cfgs(config)
+    for multus_net in multus_nets:
+        if consts.FLANNEL_NET_TYPE in multus_net:
+            networks = multus_net[consts.FLANNEL_NET_TYPE]
+            for network in networks:
+                validate_dict_data(network, consts.FLANNEL_NET_DTLS_KEY)
+                details = network[consts.FLANNEL_NET_DTLS_KEY]
+                if config_utils.bool_val(details[consts.MASTER_PLUGIN_KEY]):
+                    master_count += 1
+        if consts.WEAVE_NET_TYPE in multus_net:
+            networks = multus_net[consts.WEAVE_NET_TYPE]
+            for network in networks:
+                validate_dict_data(network, consts.WEAVE_NET_DTLS_KEY)
+                details = network[consts.WEAVE_NET_DTLS_KEY]
+                if config_utils.bool_val(details[consts.MASTER_PLUGIN_KEY]):
+                    master_count += 1
+        if consts.MACVLAN_NET_TYPE in multus_net:
+            networks = multus_net[consts.MACVLAN_NET_TYPE]
+            for network in networks:
+                validate_dict_data(network, consts.MACVLAN_NET_DTLS_KEY)
+                details = network[consts.MACVLAN_NET_DTLS_KEY]
+                if config_utils.bool_val(details[consts.MASTER_PLUGIN_KEY]):
+                    master_count += 1
+        if consts.SRIOV_NET_TYPE in multus_net:
+            net_hosts = multus_net[consts.SRIOV_NET_TYPE]
+            for net_host in net_hosts:
+                validate_dict_data(net_host, consts.HOST_KEY)
+                host_conf = net_host[consts.HOST_KEY]
+                validate_dict_data(host_conf, consts.SRIOV_NETWORKS_KEY)
+                networks = host_conf[consts.SRIOV_NETWORKS_KEY]
+                for network in networks:
+                    if config_utils.bool_val(network[
+                                                 consts.MASTER_PLUGIN_KEY]):
+                        master_count += 1
+
+    if master_count > 1:
+        raise ValidationException('isMaster is present more than once')
+
+
+def validate_dict_data(dict_to_validate, dict_item):
+    if dict_to_validate.get(dict_item) is None:
+        raise ValidationException('Missing tag {}'.format(dict_item))
+
+
+class ValidationException(Exception):
+    """
+    Exception to raise when there are issues with the configuration
     """
-    logger.info("checking Master Flag params for dynamic deployment")
-    all_data_dict_for_net_params = config_deployment_bkup.get("kubernetes"). \
-        get("Networks")
-    all_data_dict_for_net_params_dynamic_dep = config.get("kubernetes"). \
-        get("Networks")
-    list_for_cni_conf_params = []
-    list_for_cni_conf_params_dynamic_dep = []
-    count = 0
-    is_master_val = all_data_dict_for_net_params[0].values()[0]["isMaster"]
-
-    if is_master_val == "true":
-        count = count + 1
-
-    for all_keys in all_data_dict_for_net_params[1]:
-        for keys_in_all_keys in all_data_dict_for_net_params[1][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-
-        for element in datain_cni_conf:
-            list_for_cni_conf_params.extend(element.values()[0])
-    i = 0
-    for element in list_for_cni_conf_params:
-        if 'macvlan_networks' in element:
-            is_master_for_macvlan = element['macvlan_networks']['isMaster']
-            if is_master_for_macvlan == "true":
-                count = count + 1
-        if 'weave_network' in element:
-            is_master_for_weave = element['weave_network']['isMaster']
-            if is_master_for_weave == "true":
-                count = count + 1
-        if 'flannel_network' in element:
-            is_master_for_flannel = element['flannel_network']['isMaster']
-            if is_master_for_flannel == "true":
-                count = count + 1
-        if 'host' in element:
-            for itemnetwork in element.get("host").get("networks"):
-                is_master_for_sriov = \
-                    element['host']['networks'][i]['isMaster']
-                if is_master_for_sriov == "true":
-                    count = count + 1
-                i = i + 1
-    for all_keys in all_data_dict_for_net_params_dynamic_dep[0]:
-        for keys_in_all_keys in \
-                all_data_dict_for_net_params_dynamic_dep[0][all_keys]:
-            datain_cni_conf_dynamicdep = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-        for element in datain_cni_conf_dynamicdep:
-            list_for_cni_conf_params_dynamic_dep.extend(element.values()[0])
-
-    for element in list_for_cni_conf_params_dynamic_dep:
-        if 'macvlan_networks' in element:
-            if element['macvlan_networks']['isMaster'] == "true":
-                count = count + 1
-        else:
-            pass
-        if 'host' in element:
-            is_master_for_sriov1 = element['host']['networks'][0]['isMaster']
-            if is_master_for_sriov1 == "true":
-                count = count + 1
-        else:
-            pass
-
-    if count != 1:
-        logger.info("isMaster is true more than 1 time")
-        return False
-    return True
-
-
-def validate_masterflag_network_dep_sriov(config):
-    """
-    Checks the presence of master fag must be true for only once
-    """
-    logger.info("checking Master Flag  params for dynamic deployment")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    list_for_cni_conf_params = []
-    count = 0
-
-    for all_keys in all_data_dict_for_net_params[0]:
-        for keys_in_all_keys in all_data_dict_for_net_params[0][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-
-        for element in datain_cni_conf:
-            list_for_cni_conf_params.extend(element.values()[0])
-
-    for element in list_for_cni_conf_params:
-        if 'host' in element:
-            for itemnetwork in element.get("host").get("networks"):
-                is_master_for_sriov = \
-                    element['host']['networks'][0]['isMaster']
-                if is_master_for_sriov == "true":
-                    count = count + 1
-
-    if count != 0:
-        logger.info("isMaster is true more than 1 time")
-        return False
-    return True
-
-
-def validate_masterflag_network_dep_macvlan(config):
-    """
-    Checks the presence of master fag must be true for only once for macvlan
-    """
-    logger.info("checking Master Flag  params for dynamic deployment")
-    all_data_dict_for_net_params = config.get("kubernetes").get("Networks")
-    list_for_cni_conf_params = []
-    count = 0
-
-    for all_keys in all_data_dict_for_net_params[0]:
-        for keys_in_all_keys in all_data_dict_for_net_params[0][all_keys]:
-            datain_cni_conf = keys_in_all_keys.get(
-                consts.MULTUS_CNI_CONFIG_KEY)
-
-        for element in datain_cni_conf:
-            list_for_cni_conf_params.extend(element.values()[0])
-
-    for element in list_for_cni_conf_params:
-
-        if 'macvlan_networks' in element:
-            is_master_for_macvlan = element['macvlan_networks']['isMaster']
-            if is_master_for_macvlan == "true":
-                count = count + 1
-    if count != 0:
-        logger.info("isMaster is true more than 1 time")
-        return False
-    return True
-
-
-def validate_clean_up_dynamic(config):
-    noofhosts = 0
-    all_data_dict_for_nodeconfigurationparams = \
-        config.get("kubernetes").get("node_configuration")
-    if validate_dict_data(all_data_dict_for_nodeconfigurationparams[0],
-                          "host"):
-        for all_data_for_host in all_data_dict_for_nodeconfigurationparams:
-            noofhosts = noofhosts + 1
-            hostname = all_data_for_host.get("host")["hostname"]
-            return node_del_check(hostname)
-    if not get_masterandminion_count(noofhosts):
-        logger.error("Minion could not be deleted")
-        return False
-    else:
-        return True
-
-
-def validate_add_dynamic(config):
-    all_data_dict_for_nodeconfigurationparams = \
-        config.get("kubernetes").get("node_configuration")
-    if validate_dict_data(
-            all_data_dict_for_nodeconfigurationparams[0], "host"):
-        for all_data_for_host in all_data_dict_for_nodeconfigurationparams:
-            hostname = all_data_for_host.get("host")["hostname"]
-            return node_add_check(hostname)
-    return True
-
-
-def node_add_check(hostname):
-    command = "ansible kube-node -i /home/1906/Ensconcek8\
-    /snaps_k8s/projects/My_project/inventory.cfg --list-host \
-     | awk '{if(NR>1)print}' | awk '{$1=$1};1'"
-    node_name = subprocess.check_output(command, shell=True)
-    if hostname in node_name:
-        logger.error("given node already exist in the cluster: cannot add")
-        return False
-    else:
-        pass
-    return True
-
-
-def get_masterandminion_count(noofhosts):
-    command = "ansible kube-node -i /home/1906/Ensconcek8\
-    /snaps_k8s/projects/My_project/inventory.cfg --list-host /" \
-              "  | awk '{if(NR>1)print}' | awk '{$1=$1};1' | wc -l"
-    count_for_minion = subprocess.check_output(command, shell=True)
-    difference = int(count_for_minion) - noofhosts
-    if difference > 0:
-        return True
-    else:
-        logger.error("Atleast one minion must be in the cluster")
-        return False
-
-
-def node_del_check(hostname):
-    command = "ansible kube-node -i /home/1906/Ensconcek8\
-    /snaps_k8s/projects/My_project/inventory.cfg --list-host\
-      | awk '{if(NR>1)print}' | awk '{$1=$1};1'"
-    node_name = subprocess.check_output(command, shell=True)
-    if hostname in node_name:
-        pass
-    else:
-        logger.error("given node does not exist in the cluster: cannot delete")
-        return False
-    return True
-
-
-def validate_dynamic_deployment_file(config):
-    """
-    Calls all the validations
-    """
-    logger.info("validate_dynamic_deployment_file \
-     function for dynamic deployment")
-    if not validate_kubernetes_tag(config):
-        exit(1)
-    if not validate_node_config_tag(config):
-        exit(1)
-    if not validate_node_config_params(config):
-        exit(1)
-    if not validate_add_dynamic(config):
-        exit(1)
-    logger.info('Dynamic Deployment file is valid')
-
-
-def validate_network_deployment_file(config, config_deployment_bkup):
-    """
-    Calls all the validations
-    """
-    logger.info("validate_network_deployment_file \
-    function for network deployment")
-    logger.info("validate network yaml")
-    if not validate_kubernetes_tag(config):
-        exit(1)
-    if not validate_network__tag(config):
-        exit(1)
-    else:
-        if not validate_multus_network_tag_network_yaml(config):
-            return True
-
-        else:
-            if not validate_cni_params_for_network_deployment(config):
-                exit(1)
-            if not validate_ismaster_for_network_dep_and_dep_file(
-                    config, config_deployment_bkup):
-                exit(1)
-    logger.info('Network file is valid')
diff --git a/snaps_k8s/provision/ansible_configuration.py b/snaps_k8s/provision/ansible_configuration.py
index 8d1104f..9e6691f 100644
--- a/snaps_k8s/provision/ansible_configuration.py
+++ b/snaps_k8s/provision/ansible_configuration.py
@@ -101,7 +101,8 @@ def start_k8s_install(k8s_conf):
     logger.info('Completed Kubernetes installation')
 
 
-def __set_hostnames(host_name_map, base_pb_vars):
+def __set_hostnames(k8s_conf, base_pb_vars):
+    host_name_map = config_utils.get_hostname_ips_dict(k8s_conf)
     ips = list()
     for host_name, ip_val in host_name_map.items():
         ips.append(ip_val)
@@ -119,7 +120,10 @@ def __set_hostnames(host_name_map, base_pb_vars):
         variables=pb_vars)
 
 
-def __configure_docker(host_name_map, host_port_map, base_pb_vars):
+def __configure_docker(k8s_conf, base_pb_vars):
+    host_name_map = config_utils.get_hostname_ips_dict(k8s_conf)
+    host_port_map = config_utils.get_host_reg_port_dict(k8s_conf)
+
     ip_val = None
     registry_port = None
     for host_name, ip_val in host_name_map.items():
@@ -137,31 +141,35 @@ def __configure_docker(host_name_map, host_port_map, base_pb_vars):
         variables=pb_vars)
 
 
-def __prepare_docker_repo(docker_repo, host_name_map, base_pb_vars):
-    docker_ip = docker_repo.get(consts.IP_KEY)
-    docker_port = docker_repo.get(consts.PORT_KEY)
-    pb_vars = {
-        'docker_ip': docker_ip,
-        'docker_port': docker_port,
-        'HTTP_PROXY_DEST': consts.NODE_HTTP_PROXY_DEST,
-    }
-    pb_vars.update(base_pb_vars)
-    ansible_utils.apply_playbook(consts.K8_PRIVATE_DOCKER,
-                                 variables=pb_vars)
+def __prepare_docker_repo(k8s_conf, base_pb_vars):
+    docker_repo = config_utils.get_docker_repo(k8s_conf)
+    if docker_repo:
+        docker_ip = docker_repo.get(consts.IP_KEY)
+        docker_port = docker_repo.get(consts.PORT_KEY)
+        pb_vars = {
+            'docker_ip': docker_ip,
+            'docker_port': docker_port,
+            'HTTP_PROXY_DEST': consts.NODE_HTTP_PROXY_DEST,
+        }
+        pb_vars.update(base_pb_vars)
+        ansible_utils.apply_playbook(consts.K8_PRIVATE_DOCKER,
+                                     variables=pb_vars)
 
-    ips = list()
-    for host_name, ip in host_name_map.items():
-        ips.append(ip)
+        host_name_map = config_utils.get_hostname_ips_dict(k8s_conf)
+        ips = list()
+        for host_name, ip in host_name_map.items():
+            ips.append(ip)
 
-    pb_vars = {
-        'docker_ip': docker_ip,
-        'docker_port': docker_port,
-        'HTTP_PROXY_DEST': consts.NODE_HTTP_PROXY_DEST,
-        'DAEMON_FILE': consts.NODE_DOCKER_DAEMON_FILE
-    }
-    pb_vars.update(base_pb_vars)
-    ansible_utils.apply_playbook(
-        consts.K8_CONF_DOCKER_REPO, ips, consts.NODE_USER, variables=pb_vars)
+        pb_vars = {
+            'docker_ip': docker_ip,
+            'docker_port': docker_port,
+            'HTTP_PROXY_DEST': consts.NODE_HTTP_PROXY_DEST,
+            'DAEMON_FILE': consts.NODE_DOCKER_DAEMON_FILE
+        }
+        pb_vars.update(base_pb_vars)
+        ansible_utils.apply_playbook(
+            consts.K8_CONF_DOCKER_REPO, ips, consts.NODE_USER,
+            variables=pb_vars)
 
 
 def __prepare_docker(k8s_conf, base_pb_vars):
@@ -172,14 +180,9 @@ def __prepare_docker(k8s_conf, base_pb_vars):
     pb_vars.update(base_pb_vars)
     ansible_utils.apply_playbook(consts.K8_CLONE_PACKAGES, variables=pb_vars)
 
-    host_name_map = config_utils.get_hostname_ips_dict(k8s_conf)
-    host_port_map = config_utils.get_host_reg_port_dict(k8s_conf)
-    __set_hostnames(host_name_map, base_pb_vars)
-    __configure_docker(host_name_map, host_port_map, base_pb_vars)
-
-    docker_repo = config_utils.get_docker_repo(k8s_conf)
-    if docker_repo:
-        __prepare_docker_repo(docker_repo, host_name_map, base_pb_vars)
+    __set_hostnames(k8s_conf, base_pb_vars)
+    __configure_docker(k8s_conf, base_pb_vars)
+    __prepare_docker_repo(k8s_conf, base_pb_vars)
 
 
 def __kubespray(k8s_conf, base_pb_vars):
@@ -213,9 +216,8 @@ def __kubespray(k8s_conf, base_pb_vars):
         ansible_utils.apply_playbook(consts.KUBERNETES_CREATE_INVENTORY,
                                      variables=pb_vars)
 
-    git_branch = config_utils.get_git_branch(k8s_conf)
     pb_vars = {
-        'Git_branch': git_branch,
+        'Git_branch': config_utils.get_git_branch(k8s_conf),
         'KUBESPRAY_PATH': config_utils.get_kubespray_dir(k8s_conf),
         'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
             k8s_conf),
@@ -225,23 +227,19 @@ def __kubespray(k8s_conf, base_pb_vars):
 
     __enable_cluster_logging(k8s_conf)
 
-    if k8s_conf[consts.K8S_KEY].get(consts.CPU_ALLOC_KEY):
+    if config_utils.is_cpu_alloc(k8s_conf):
         ansible_utils.apply_playbook(
             consts.K8_CPU_PINNING_CONFIG,
             variables={'KUBESPRAY_PATH': config_utils.get_kubespray_dir(
                 k8s_conf)})
 
     logger.info('*** EXECUTING INSTALLATION OF KUBERNETES CLUSTER ***')
-    service_subnet = config_utils.get_service_subnet(k8s_conf)
-    pod_subnet = config_utils.get_pod_subnet(k8s_conf)
-    networking_plugin = config_utils.get_networking_plugin(k8s_conf)
-    kube_version = config_utils.get_version(k8s_conf)
     pb_vars = {
-        'service_subnet': service_subnet,
-        'pod_subnet': pod_subnet,
-        'networking_plugin': networking_plugin,
-        'kube_version': kube_version,
-        'Git_branch': git_branch,
+        'service_subnet': config_utils.get_service_subnet(k8s_conf),
+        'pod_subnet': config_utils.get_pod_subnet(k8s_conf),
+        'networking_plugin': config_utils.get_networking_plugin(k8s_conf),
+        'kube_version': config_utils.get_version(k8s_conf),
+        'Git_branch': config_utils.get_git_branch(k8s_conf),
         'host_name_map': host_name_map,
         'KUBESPRAY_PATH': config_utils.get_kubespray_dir(k8s_conf),
         'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
@@ -314,19 +312,24 @@ def launch_sriov_cni_configuration(k8s_conf):
 
     sriov_cfgs = config_utils.get_multus_cni_sriov_cfgs(k8s_conf)
     for sriov_cfg in sriov_cfgs:
-        sriov_net = sriov_cfg[consts.SRIOV_NET_DTLS_KEY]
-        hostname = sriov_net.get(consts.HOSTNAME_KEY)
-        dpdk_enable = bool(sriov_net.get(consts.SRIOV_DPDK_ENABLE_KEY, None))
-        pb_vars = {
-            'host_name': hostname,
-            'sriov_intf': sriov_net.get(consts.SRIOV_INTF_KEY),
-            'networking_plugin': networking_plugin,
-            'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
-                k8s_conf),
-        }
-        ansible_utils.apply_playbook(
-            consts.K8_SRIOV_ENABLE, [hostname], consts.NODE_USER,
-            variables=pb_vars)
+        sriov_host = sriov_cfg[consts.HOST_KEY]
+
+        # for sriov_net in sriov_hosts:
+        hostname = sriov_host[consts.HOSTNAME_KEY]
+
+        for sriov_net in sriov_host[consts.SRIOV_NETWORKS_KEY]:
+            dpdk_enable = config_utils.bool_val(
+                sriov_net.get(consts.SRIOV_DPDK_ENABLE_KEY, None))
+            pb_vars = {
+                'host_name': hostname,
+                'sriov_intf': sriov_net.get(consts.SRIOV_INTF_KEY),
+                'networking_plugin': networking_plugin,
+                'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
+                    k8s_conf),
+            }
+            ansible_utils.apply_playbook(
+                consts.K8_SRIOV_ENABLE, [hostname], consts.NODE_USER,
+                variables=pb_vars)
 
     pb_vars = config_utils.get_proxy_dict(k8s_conf)
     pb_vars.update(
@@ -378,71 +381,70 @@ def launch_sriov_cni_configuration(k8s_conf):
 def launch_sriov_network_creation(k8s_conf):
     sriov_cfgs = config_utils.get_multus_cni_sriov_cfgs(k8s_conf)
     for sriov_cfg in sriov_cfgs:
-        for key, network in sriov_cfg.items():
-            __launch_sriov_network(k8s_conf, network, sriov_cfg)
+        for key, host in sriov_cfg.items():
+            __launch_sriov_network(k8s_conf, host)
 
 
-def __launch_sriov_network(k8s_conf, network, sriov_cfg):
+def __launch_sriov_network(k8s_conf, sriov_host):
     master_host, ip = config_utils.get_first_master_host(k8s_conf)
 
-    sriov_host_data = sriov_cfg[consts.SRIOV_NET_DTLS_KEY]
-    dpdk_enable = sriov_host_data.get(consts.SRIOV_DPDK_ENABLE_KEY)
-    host_type = network.get(consts.TYPE_KEY)
-    sriov_intf = network.get(consts.SRIOV_INTF_KEY)
-    sriov_nw_name = network.get(consts.NETWORK_NAME_KEY)
-
-    if dpdk_enable is True:
-        logger.info(
-            'SRIOV NETWORK CREATION STARTED USING DPDK DRIVER')
-        pb_vars = {
-            'intf': sriov_intf,
-            'network_name': sriov_nw_name,
-            'dpdk_driver': consts.DPDK_DRIVER,
-            'dpdk_tool': consts.DPDK_TOOL,
-            'node_hostname': network.get(consts.HOSTNAME_KEY),
-            'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
-                k8s_conf),
-        }
-        ansible_utils.apply_playbook(
-            consts.K8_SRIOV_DPDK_CR_NW, [master_host], consts.NODE_USER,
-            variables=pb_vars)
+    for sriov_net in sriov_host[consts.SRIOV_NETWORKS_KEY]:
+        dpdk_enable = config_utils.bool_val(sriov_net.get(
+            consts.SRIOV_DPDK_ENABLE_KEY))
 
-    if dpdk_enable is True:
-        if host_type == consts.NET_TYPE_LOCAL_KEY:
-            logger.info(
-                'SRIOV NETWORK CREATION STARTED USING '
-                'KERNEL DRIVER WITH IPAM host-local')
+        if dpdk_enable:
+            logger.info('SRIOV NETWORK CREATION STARTED USING DPDK DRIVER')
 
+            host_type = sriov_net.get(consts.TYPE_KEY)
+            sriov_intf = sriov_net.get(consts.SRIOV_INTF_KEY)
+            sriov_nw_name = sriov_net.get(consts.NETWORK_NAME_KEY)
             pb_vars = {
-                'host_name': master_host,
                 'intf': sriov_intf,
                 'network_name': sriov_nw_name,
-                'rangeStart': network.get(consts.RANGE_START_KEY),
-                'rangeEnd': sriov_host_data.get(consts.RANGE_END_KEY),
-                'subnet': network.get(consts.SUBNET_KEY),
-                'gateway': network.get(consts.GATEWAY_KEY),
-                'masterPlugin': network.get(consts.MASTER_PLUGIN_KEY),
+                'dpdk_driver': consts.DPDK_DRIVER,
+                'dpdk_tool': consts.DPDK_TOOL,
+                'node_hostname': sriov_host.get(consts.HOSTNAME_KEY),
                 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
                     k8s_conf),
             }
             ansible_utils.apply_playbook(
-                consts.K8_SRIOV_CR_NW, [master_host], consts.NODE_USER,
-                variables=pb_vars)
+                consts.K8_SRIOV_DPDK_CR_NW, [master_host],
+                consts.NODE_USER, variables=pb_vars)
 
-        if host_type == consts.DHCP_TYPE:
-            logger.info(
-                'SRIOV NETWORK CREATION STARTED USING '
-                'KERNEL DRIVER WITH IPAM host-dhcp')
-            pb_vars = {
-                'intf': sriov_intf,
-                'network_name': sriov_nw_name,
-                'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
-                    k8s_conf),
-            }
-            pb_vars.update(config_utils.get_proxy_dict(k8s_conf))
-            ansible_utils.apply_playbook(
-                consts.K8_SRIOV_DHCP_CR_NW, [master_host], consts.NODE_USER,
-                variables=pb_vars)
+            if host_type == consts.NET_TYPE_LOCAL_TYPE:
+                logger.info('SRIOV NETWORK CREATION STARTED USING '
+                            'KERNEL DRIVER WITH IPAM host-local')
+
+                pb_vars = {
+                    'host_name': master_host,
+                    'intf': sriov_intf,
+                    'network_name': sriov_nw_name,
+                    'rangeStart': sriov_net.get(consts.RANGE_START_KEY),
+                    'rangeEnd': sriov_net.get(consts.RANGE_END_KEY),
+                    'subnet': sriov_net.get(consts.SUBNET_KEY),
+                    'gateway': sriov_net.get(consts.GATEWAY_KEY),
+                    'masterPlugin': sriov_net.get(consts.MASTER_PLUGIN_KEY),
+                    'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
+                        k8s_conf),
+                }
+                ansible_utils.apply_playbook(
+                    consts.K8_SRIOV_CR_NW, [master_host], consts.NODE_USER,
+                    variables=pb_vars)
+
+            if host_type == consts.DHCP_TYPE:
+                logger.info(
+                    'SRIOV NETWORK CREATION STARTED USING '
+                    'KERNEL DRIVER WITH IPAM host-dhcp')
+                pb_vars = {
+                    'intf': sriov_intf,
+                    'network_name': sriov_nw_name,
+                    'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
+                        k8s_conf),
+                }
+                pb_vars.update(config_utils.get_proxy_dict(k8s_conf))
+                ansible_utils.apply_playbook(
+                    consts.K8_SRIOV_DHCP_CR_NW, [master_host],
+                    consts.NODE_USER, variables=pb_vars)
 
 
 def create_default_network(k8s_conf):
@@ -559,17 +561,19 @@ def create_weave_interface(k8s_conf, weave_detail):
 
 def clean_up_metrics_server(k8s_conf):
     logger.info("clean_up_metrics_server")
-    master_nodes_tuple_3 = config_utils.get_master_nodes_ip_name_type(k8s_conf)
-    pb_vars = {
-        'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf),
-    }
-    pb_vars.update(config_utils.get_proxy_dict(k8s_conf))
+    if config_utils.is_metrics_server_enabled(k8s_conf):
+        masters_t3 = config_utils.get_master_nodes_ip_name_type(k8s_conf)
+        pb_vars = {
+            'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
+                k8s_conf),
+        }
+        pb_vars.update(config_utils.get_proxy_dict(k8s_conf))
 
-    for host_name, ip, node_type in master_nodes_tuple_3:
-        ansible_utils.apply_playbook(
-            consts.K8_METRICS_SERVER_CLEAN, [host_name], consts.NODE_USER,
-            variables=pb_vars)
-        break
+        for host_name, ip, node_type in masters_t3:
+            ansible_utils.apply_playbook(
+                consts.K8_METRICS_SERVER_CLEAN, [host_name], consts.NODE_USER,
+                variables=pb_vars)
+            break
 
 
 def launch_ceph_kubernetes(k8s_conf):
@@ -705,52 +709,30 @@ def launch_persitent_volume_kubernetes(k8s_conf):
             variables=pb_vars)
 
 
-def get_host_master_name(k8s_conf):
-    """
-    Returns the first hostname of type 'master'
-    :param k8s_conf: the k8s configuration dict
-    :return: the first master hostname
-    """
-    if ('kubernetes' in k8s_conf
-            and 'node_configuration' in k8s_conf['kubernetes']):
-        host_confs = k8s_conf['kubernetes']['node_configuration']
-        for host_conf in host_confs:
-            if host_conf['host']['node_type'] == 'master':
-                return host_conf['host']['hostname']
-
-    logger.warn('Unable to access the master host with conf %s', k8s_conf)
-
-
 def __enable_cluster_logging(k8s_conf):
     """
     This function is used to enable logging in cluster
     :param k8s_conf: k8s config
     """
-    enable_logging = k8s_conf[consts.K8S_KEY][consts.ENABLE_LOG_KEY]
-    if enable_logging is not None:
-        if enable_logging is not True and enable_logging is not False:
-            raise Exception('Either enabled logging or disabled logging')
-
-        if enable_logging:
-            value = "True"
-            log_level = k8s_conf[consts.K8S_KEY][consts.LOG_LEVEL_KEY]
-            if (log_level != "fatal" and log_level != "warning"
-                    and log_level != "info" and log_level != "debug"
-                    and log_level != "critical"):
-                raise Exception('Invalid log_level')
-            logging_port = k8s_conf[consts.K8S_KEY][consts.LOG_PORT_KEY]
-            pb_vars = {
-                "logging": value,
-                "log_level": log_level,
-                "file_path": consts.LOG_FILE_PATH,
-                "logging_port": logging_port,
-                'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
-                    k8s_conf),
-                'KUBESPRAY_PATH': config_utils.get_kubespray_dir(k8s_conf)
-            }
-            pb_vars.update(config_utils.get_proxy_dict(k8s_conf))
-            ansible_utils.apply_playbook(consts.K8_LOGGING_PLAY,
-                                         variables=pb_vars)
+    if config_utils.is_logging_enabled(k8s_conf):
+        log_level = config_utils.get_log_level(k8s_conf)
+        if (log_level != "fatal" and log_level != "warning"
+                and log_level != "info" and log_level != "debug"
+                and log_level != "critical"):
+            raise Exception('Invalid log_level')
+
+        pb_vars = {
+            "logging": 'True',
+            "log_level": log_level,
+            "file_path": consts.LOG_FILE_PATH,
+            "logging_port": config_utils.get_logging_port(k8s_conf),
+            'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
+                k8s_conf),
+            'KUBESPRAY_PATH': config_utils.get_kubespray_dir(k8s_conf)
+        }
+        pb_vars.update(config_utils.get_proxy_dict(k8s_conf))
+        ansible_utils.apply_playbook(consts.K8_LOGGING_PLAY,
+                                     variables=pb_vars)
     else:
         logger.warn('Logging not configured')
 
@@ -766,22 +748,16 @@ def __install_kubectl(k8s_conf):
     """
     This function is used to install kubectl at bootstrap node
     """
+    # TODO/FIXME - There can be many load balancer IPs
     lb_ip = "127.0.0.1"
-    ha_configuration = config_utils.get_ha_config(k8s_conf)
-    if ha_configuration:
-        for ha_config_list_data in ha_configuration:
-            lb_ip = ha_config_list_data.get(consts.HA_API_EXT_LB_KEY).get("ip")
+    lb_ips = config_utils.get_ha_lb_ips(k8s_conf)
+    if len(lb_ips) > 0:
+        lb_ip = lb_ips[0]
 
     logger.info("Load balancer ip %s", lb_ip)
 
     host_name, ip = config_utils.get_first_master_host(k8s_conf)
-    if not ip or not host_name:
-        raise Exception('Unable to locate IP or hostname')
-
-    # TODO/FIXME - need to add HA support
-    # ha_enabled = config_utils.get_ha_config(k8s_conf) is not None
-    ha_enabled = False
-
+    ha_enabled = len(lb_ips) > 0
     pb_vars = {
         'ip': ip,
         'host_name': host_name,
diff --git a/snaps_k8s/provision/k8_utils.py b/snaps_k8s/provision/k8_utils.py
index c6b98f8..78ed1c6 100644
--- a/snaps_k8s/provision/k8_utils.py
+++ b/snaps_k8s/provision/k8_utils.py
@@ -18,10 +18,7 @@ Created By :Aricent
 """
 import logging
 
-import netaddr
-
 from snaps_common.ansible_snaps import ansible_utils
-
 import snaps_k8s.provision.ansible_configuration as aconf
 from snaps_k8s.common.consts import consts
 from snaps_k8s.common.utils import config_utils
@@ -60,7 +57,7 @@ def __create_persist_vol(k8s_conf):
 
 def __create_crd_net(k8s_conf):
     logger.info("Additional N/W plugins multus_cni installation")
-    multus_enabled = __is_multus_cni_enabled(k8s_conf)
+    multus_enabled = config_utils.is_multus_cni_enabled(k8s_conf)
 
     if multus_enabled:
         aconf.launch_crd_network(k8s_conf)
@@ -69,7 +66,7 @@ def __create_crd_net(k8s_conf):
 
 
 def __create_multus_cni(k8s_conf):
-    multus_enabled = __is_multus_cni_enabled(k8s_conf)
+    multus_enabled = config_utils.is_multus_cni_enabled(k8s_conf)
     if multus_enabled:
         multus_elems = config_utils.get_multus_net_elems(k8s_conf)
         if consts.DHCP_TYPE in multus_elems:
@@ -101,44 +98,6 @@ def __create_multus_cni(k8s_conf):
         logger.info('MULTUS CNI IS DISABLED')
 
 
-def __ip_var_args(*argv):
-    if len(argv) % 2:
-        logger.error("Invalid configuration")
-        exit(1)
-
-    for i in range(len(argv)):
-        if i % 2:
-            continue
-
-        start_ip = int(netaddr.IPAddress(argv[i]))
-        end_ip = int(netaddr.IPAddress(argv[i + 1]))
-        for j in range(len(argv)):
-            if j % 2:
-                continue
-            if i == j:
-                continue
-            if int(netaddr.IPAddress(argv[j])) <= start_ip <= int(
-                    netaddr.IPAddress(argv[j + 1])) or int(
-                    netaddr.IPAddress(argv[j])) <= end_ip <= int(
-                    netaddr.IPAddress(argv[j + 1])):
-                logger.error('Alert ! IPs ranges are intermingled')
-                return False
-
-        return True
-
-
-def __check_dup_start_end_ip(net_names, range_dict):
-    final_list = []
-    for network in net_names:
-        if range_dict.get(network) not in final_list:
-            final_list.append(range_dict.get(network))
-        else:
-            logger.error("duplicate network name found - %s with ip %s",
-                         network, range_dict.get(network))
-            return False
-    return True
-
-
 def clean_k8(k8s_conf):
     """
     This method is used for cleanup of kubernetes cluster
@@ -167,30 +126,14 @@ def clean_k8(k8s_conf):
         aconf.clean_up_k8(k8s_conf, multus_enabled)
 
 
-def __get_hostname_map(k8s_conf):
-    """Get hostname map function"""
-    node_confs = config_utils.get_node_configs(k8s_conf)
-    hostname_map = {}
-    for node_conf in node_confs:
-        hostname = node_conf[consts.HOST_KEY].get(consts.HOSTNAME_KEY)
-        host_ip = ""
-        ip = node_conf[consts.HOST_KEY].get(consts.IP_KEY)
-        if ip:
-            host_ip = ip
-        hostname_map[hostname] = host_ip
-
-    return hostname_map
-
-
 def __enabling_basic_authentication(k8s_conf):
-    basic_authentication = config_utils.get_basic_auth(k8s_conf)
     """Basic Authentication function"""
-    for i in range(len(basic_authentication)):
-        user_name = basic_authentication[i].get(
-            consts.USER_KEY).get(consts.USER_NAME_KEY)
-        user_password = basic_authentication[i].get(
-            consts.USER_KEY).get(consts.USER_PASS_KEY)
-        user_id = basic_authentication[i].get(
+    basic_authentications = config_utils.get_basic_auth(k8s_conf)
+    for basic_authentication in basic_authentications:
+        user = basic_authentication[consts.USER_KEY]
+        user_name = user[consts.USER_NAME_KEY]
+        user_password = user[consts.USER_PASS_KEY]
+        user_id = basic_authentication.get(
             consts.USER_KEY).get(consts.USER_ID_KEY)
         pb_vars = {
             'user_name': user_name,
@@ -201,13 +144,13 @@ def __enabling_basic_authentication(k8s_conf):
         ansible_utils.apply_playbook(consts.KUBERNETES_USER_LIST,
                                      variables=pb_vars)
 
-    master_host_name = aconf.get_host_master_name(k8s_conf)
+    master_host, ip = config_utils.get_first_master_host(k8s_conf)
     pb_vars = {
         'SRC_PACKAGE_PATH': config_utils.get_artifact_dir(k8s_conf),
         'KUBERNETES_PATH': consts.NODE_K8S_PATH,
     }
     ansible_utils.apply_playbook(
-        consts.KUBERNETES_AUTHENTICATION, [master_host_name], consts.NODE_USER,
+        consts.KUBERNETES_AUTHENTICATION, [ip], consts.NODE_USER,
         variables=pb_vars)
 
 
@@ -220,17 +163,19 @@ def __modifying_etcd_node(k8s_conf):
 
 
 def __metrics_server(k8s_conf):
-    logger.info("launch metrics_server")
-    master_nodes_tuple_3 = config_utils.get_master_nodes_ip_name_type(k8s_conf)
-    pb_vars = {
-        'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf),
-    }
-    pb_vars.update(config_utils.get_proxy_dict(k8s_conf))
-    for host_name, ip, node_type in master_nodes_tuple_3:
-        ansible_utils.apply_playbook(
-            consts.K8_METRICS_SERVER, [host_name], consts.NODE_USER,
-            variables=pb_vars)
-        break
+    if config_utils.is_metrics_server_enabled(k8s_conf):
+        logger.info("launch metrics_server")
+        masters_t3 = config_utils.get_master_nodes_ip_name_type(k8s_conf)
+        pb_vars = {
+            'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(
+                k8s_conf),
+        }
+        pb_vars.update(config_utils.get_proxy_dict(k8s_conf))
+        for host_name, ip, node_type in masters_t3:
+            ansible_utils.apply_playbook(
+                consts.K8_METRICS_SERVER, [host_name], consts.NODE_USER,
+                variables=pb_vars)
+            break
 
 
 def __remove_macvlan_networks(k8s_conf):
@@ -259,7 +204,7 @@ def __removal_macvlan_interface(k8s_conf):
     for mac_vlan in mac_vlans:
         iface_dict = mac_vlan[consts.MACVLAN_NET_DTLS_KEY]
         pb_vars = {
-            'parentInterface': iface_dict.get("parent_interface"),
+            'parentInterface': iface_dict.get(consts.MACVLAN_PARENT_INTF_KEY),
             'vlanId': str(iface_dict.get("vlanid")),
         }
         ansible_utils.apply_playbook(
@@ -269,9 +214,7 @@ def __removal_macvlan_interface(k8s_conf):
 
 def __macvlan_cleanup(k8s_conf):
     logger.info("MACVLAN PLUGIN REMOVAL")
-    macvlan_cni = __get_macvlan_value(k8s_conf)
-    logger.info('macvlan value n __macvlan_cleanup function:%s', macvlan_cni)
-    if macvlan_cni:
+    if consts.MACVLAN_TYPE in config_utils.get_multus_net_elems(k8s_conf):
         logger.info('REMOVING MACVLAN')
         __removal_macvlan_interface(k8s_conf)
         __remove_macvlan_networks(k8s_conf)
@@ -286,14 +229,6 @@ def __macvlan_installation(k8s_conf):
     __config_macvlan_networks(k8s_conf)
 
 
-def __get_macvlan_value(k8s_conf):
-    """
-    This function is used to get multus cni value
-    """
-    multus_cnis = config_utils.get_multus_net_elems(k8s_conf)
-    return consts.MACVLAN_TYPE in multus_cnis
-
-
 def __dhcp_cleanup(k8s_conf):
     logger.info('REMOVING DHCP')
     multus_elems = config_utils.get_multus_net_elems(k8s_conf)
@@ -303,27 +238,6 @@ def __dhcp_cleanup(k8s_conf):
             consts.K8_DHCP_REMOVAL_PATH, ips, consts.NODE_USER)
 
 
-def __is_multus_cni_enabled(k8s_conf):
-    """
-    This function is used to get multus cni value
-    """
-    sriov_cni = False
-    flannel_cni = False
-    weave_cni = False
-    macvlan_cni = False
-    multus_cni = config_utils.get_multus_net_elems(k8s_conf)
-    for cni in multus_cni:
-        if consts.SRIOV_TYPE == cni:
-            sriov_cni = True
-        elif consts.FLANNEL_TYPE == cni:
-            flannel_cni = True
-        elif consts.WEAVE_TYPE == cni:
-            weave_cni = True
-        elif consts.MACVLAN_TYPE == cni:
-            macvlan_cni = True
-    return sriov_cni or flannel_cni or weave_cni or macvlan_cni
-
-
 def __create_default_network_multus(k8s_conf):
     """
     This function is used to create default network
@@ -395,7 +309,7 @@ def __config_macvlan_networks(k8s_conf):
     This method is used for create macvlan network after multus
     :param k8s_conf: input configuration file
     """
-    macvlan_master_hostname = aconf.get_host_master_name(k8s_conf)
+    master_host, ip = config_utils.get_first_master_host(k8s_conf)
     macvlan_nets = config_utils.get_multus_cni_macvlan_cfgs(k8s_conf)
     for mvlan_net in macvlan_nets:
         iface_dict = mvlan_net.get(consts.MACVLAN_NET_DTLS_KEY)
@@ -417,24 +331,20 @@ def __config_macvlan_networks(k8s_conf):
             if macvlan_type == "host-local":
                 ansible_utils.apply_playbook(
                     consts.K8_MACVLAN_MASTER_NETWORK_PATH,
-                    [macvlan_master_hostname], consts.NODE_USER,
-                    variables=pb_vars)
+                    [ip], consts.NODE_USER, variables=pb_vars)
             elif macvlan_type == consts.DHCP_TYPE:
                 ansible_utils.apply_playbook(
                     consts.K8_MACVLAN_MASTER_NETWORK_DHCP_PATH,
-                    [macvlan_master_hostname], consts.NODE_USER,
-                    variables=pb_vars)
+                    [ip], consts.NODE_USER, variables=pb_vars)
         elif macvlan_masterplugin == "false":
             if macvlan_type == "host-local":
                 ansible_utils.apply_playbook(
                     consts.K8_MACVLAN_NETWORK_PATH,
-                    [macvlan_master_hostname], consts.NODE_USER,
-                    variables=pb_vars)
+                    [ip], consts.NODE_USER, variables=pb_vars)
             elif macvlan_type == consts.DHCP_TYPE:
                 ansible_utils.apply_playbook(
                     consts.K8_MACVLAN_NETWORK_DHCP_PATH,
-                    [macvlan_master_hostname], consts.NODE_USER,
-                    variables=pb_vars)
+                    [ip], consts.NODE_USER, variables=pb_vars)
 
 
 def __config_macvlan_intf(k8s_conf):
@@ -448,7 +358,7 @@ def __config_macvlan_intf(k8s_conf):
         hostname = iface_dict.get(consts.HOSTNAME_KEY)
         ip = iface_dict.get(consts.IP_KEY)
         pb_vars = {
-            'parentInterface': iface_dict.get("parent_interface"),
+            'parentInterface': iface_dict.get(consts.MACVLAN_PARENT_INTF_KEY),
             'vlanId': str(iface_dict['vlanid']),
             'ip': ip,
         }


Test patch:
diff --git a/tests/common/utils/config_utils.py b/tests/common/utils/config_utils.py
index 6a18d06..068369c 100644
--- a/tests/common/utils/config_utils.py
+++ b/tests/common/utils/config_utils.py
@@ -23,7 +23,7 @@ from snaps_k8s.common.utils import config_utils
 
 class ConfigUtilsTests(unittest.TestCase):
     """
-    Tests for snaps_k8s.provision.kubernetes.plugin.k8_impl.k8_utils.py
+    Tests for snaps_k8s.common.utils.config_utils.py
     """
     def setUp(self):
         config_file = pkg_resources.resource_filename(
@@ -56,3 +56,141 @@ class ConfigUtilsTests(unittest.TestCase):
 
         proj_dir = config_utils.get_kubespray_dir(self.config)
         self.assertEqual(expected, proj_dir)
+
+    def test_is_logging_enabled(self):
+        """
+        Tests to ensure that different string and boolean values return their
+        expected values
+        """
+        this_cfg = {}
+        this_cfg.update(self.config)
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = True
+        self.assertTrue(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = 'True'
+        self.assertTrue(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = 'true'
+        self.assertTrue(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = 'yes'
+        self.assertTrue(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = 'foo'
+        self.assertFalse(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = False
+        self.assertFalse(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = 'False'
+        self.assertFalse(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = 'false'
+        self.assertFalse(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = 'no'
+        self.assertFalse(config_utils.is_logging_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.ENABLE_LOG_KEY] = None
+        self.assertFalse(config_utils.is_logging_enabled(self.config))
+
+    def test_get_log_level(self):
+        """
+        Ensures that the logging level is getting properly parsed
+        """
+        expected_log_level = self.config[consts.K8S_KEY][consts.LOG_LEVEL_KEY]
+        log_level = config_utils.get_log_level(self.config)
+        self.assertEqual(expected_log_level, log_level)
+
+    def test_get_logging_port(self):
+        """
+        Ensures that the port returned is what is expected and is always a
+        string
+        """
+        expected_port = self.config[consts.K8S_KEY][consts.LOG_PORT_KEY]
+        port = config_utils.get_logging_port(self.config)
+        self.assertEqual(expected_port, port)
+
+        # tests that a numeric value is returned as a string
+        this_cfg = {}
+        this_cfg.update(self.config)
+        this_cfg[consts.K8S_KEY][consts.LOG_PORT_KEY] = 1000
+        port = config_utils.get_logging_port(this_cfg)
+        self.assertEqual('1000', port)
+
+    def test_is_cpu_alloc(self):
+        """
+        Tests to ensure that different string and boolean values return their
+        expected values
+        """
+        this_cfg = {}
+        this_cfg.update(self.config)
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = True
+        self.assertTrue(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = 'True'
+        self.assertTrue(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = 'true'
+        self.assertTrue(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = 'yes'
+        self.assertTrue(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = 'foo'
+        self.assertFalse(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = False
+        self.assertFalse(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = 'False'
+        self.assertFalse(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = 'false'
+        self.assertFalse(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = 'no'
+        self.assertFalse(config_utils.is_cpu_alloc(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.CPU_ALLOC_KEY] = None
+        self.assertFalse(config_utils.is_cpu_alloc(self.config))
+
+    def test_is_metrics_server(self):
+        """
+        Tests to ensure that different string and boolean values return their
+        expected values
+        """
+        this_cfg = {}
+        this_cfg.update(self.config)
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = True
+        self.assertTrue(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = 'True'
+        self.assertTrue(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = 'true'
+        self.assertTrue(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = 'yes'
+        self.assertTrue(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = 'foo'
+        self.assertFalse(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = False
+        self.assertFalse(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = 'False'
+        self.assertFalse(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = 'false'
+        self.assertFalse(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = 'no'
+        self.assertFalse(config_utils.is_metrics_server_enabled(self.config))
+
+        this_cfg[consts.K8S_KEY][consts.METRICS_SERVER_KEY] = None
+        self.assertFalse(config_utils.is_metrics_server_enabled(self.config))
diff --git a/tests/common/utils/validation_utils.py b/tests/common/utils/validation_utils.py
new file mode 100644
index 0000000..b4e6f2e
--- /dev/null
+++ b/tests/common/utils/validation_utils.py
@@ -0,0 +1,30 @@
+# Copyright 2018 ARICENT HOLDINGS LUXEMBOURG SARL and Cable Television
+# Laboratories, Inc.
+# 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.
+import unittest
+import pkg_resources
+from snaps_common.file import file_utils
+from snaps_k8s.common.utils import validation_utils
+
+
+class ValidationUtilsTests(unittest.TestCase):
+    """
+    Tests for snaps_k8s.common.utils.validation_utils.py
+    """
+    def setUp(self):
+        config_file = pkg_resources.resource_filename(
+            'tests.conf', 'deployment.yaml')
+        self.config = file_utils.read_yaml(config_file)
+
+    def test_validate(self):
+        validation_utils.validate_deployment_file(self.config)
diff --git a/tests/conf/deployment.yaml b/tests/conf/deployment.yaml
index 23cd0a0..ecb7c20 100644
--- a/tests/conf/deployment.yaml
+++ b/tests/conf/deployment.yaml
@@ -25,6 +25,13 @@ kubernetes:
   enable_logging: True
   log_level: debug
   logging_port: "30011"
+  ha_configuration:
+  - api_ext_loadbalancer:
+      ip: 10.0.1.31
+      user: root
+      password: password
+      port: 7777
+      hostname: lb1
   basic_authentication:
   - user:
       user_name: admin
@@ -32,7 +39,7 @@ kubernetes:
       user_id: admin
   node_configuration:
   - host:
-      hostname: master
+      hostname: master1
       ip: 10.0.1.11
       registry_port: 2376
       node_type: master
@@ -41,8 +48,35 @@ kubernetes:
       password: password
       user: root
   - host:
-      hostname: minion
+      hostname: master2
       ip: 10.0.1.12
+      registry_port: 2376
+      node_type: master
+      label_key: zone
+      label_value: master
+      password: password
+      user: root
+  - host:
+      hostname: master3
+      ip: 10.0.1.13
+      registry_port: 2376
+      node_type: master
+      label_key: zone
+      label_value: master
+      password: password
+      user: root
+  - host:
+      hostname: minion1
+      ip: 10.0.1.21
+      registry_port: 4386
+      node_type: minion
+      label_key: zone
+      label_value: minion
+      password: password
+      user: root
+  - host:
+      hostname: minion2
+      ip: 10.0.1.22
       registry_port: 4386
       node_type: minion
       label_key: zone
@@ -62,17 +96,24 @@ kubernetes:
   Persistent_Volumes:
       Ceph_Volume:
       - host:
-          hostname: master
+          hostname: master1
           ip: 10.0.1.11
           user: root
           password: password
-          node_type: 'ceph_controller'
+          node_type: ceph_controller
+          Ceph_claims:
+          - claim_parameters:
+              claim_name: claim1
+              storage: 4Gi
+          - claim_parameters:
+              claim_name: claim2
+              storage: 5Gi
       - host:
-          hostname: master
+          hostname: master2
           ip: 10.0.1.12
           user: root
           password: password
-          node_type: 'ceph_osd'
+          node_type: ceph_osd
           second_storage:
           - foo
           - bar
@@ -92,11 +133,10 @@ kubernetes:
       isMaster: "true"
   - Multus_network:
     - CNI:
-      - macvlan
       - flannel
-      - dhcp
-      - weave
+      - macvlan
       - sriov
+      - dhcp
     - CNI_Configuration:
       - Flannel:
         - flannel_network:
@@ -139,17 +179,19 @@ kubernetes:
             type: dhcp
             isMaster: "false"
       - Sriov:
-        - sriov_networks:
-            type: host-local
-            rangeStart: 1
-            rangeEnd: 100
+        - host:
             hostname: minion
-            dpdk_enable: yes
-            intf: foo
-            rangeEnd: 172.16.151.65
-            rangeStart: 172.16.151.61
-            gateway: 172.16.0.1
-            intf: bar
-            subnet: "172.16.151.0/24"
-            network_name: foo
-            isMaster: "False"
+            networks:
+            - type: host-local
+              rangeStart: 1
+              rangeEnd: 100
+              hostname: minion
+              dpdk_enable: yes
+              sriov_intf: foo
+              rangeEnd: 172.16.151.65
+              rangeStart: 172.16.151.61
+              sriov_gateway: 172.16.0.1
+              intf: bar
+              sriov_subnet: "172.16.151.0/24"
+              network_name: foo
+              isMaster: "False"
diff --git a/tests/provision/ansible_configuration.py b/tests/provision/k8_utils.py
similarity index 79%
rename from tests/provision/ansible_configuration.py
rename to tests/provision/k8_utils.py
index efc6848..296ff70 100644
--- a/tests/provision/ansible_configuration.py
+++ b/tests/provision/k8_utils.py
@@ -18,6 +18,8 @@ import pkg_resources
 from mock import patch
 
 from snaps_common.file import file_utils
+
+from snaps_k8s.common.utils import validation_utils
 from snaps_k8s.provision import k8_utils
 
 logging.basicConfig(level=logging.DEBUG)
@@ -33,28 +35,23 @@ class K8UtilsTests(unittest.TestCase):
             'tests.conf', 'deployment.yaml')
         self.config = file_utils.read_yaml(config_file)
 
-    @patch('os.makedirs')
     @patch('snaps_common.ansible_snaps.ansible_utils.apply_playbook')
-    @patch('subprocess.call')
-    @patch('snaps_k8s.provision.ansible_configuration.get_host_master_name',
-           return_value='master')
-    def test_install(self, m1, m2, m3, m4):
+    def test_install(self, m1):
         """
         Initial test to ensure main code path does not have any syntax or
         import errors
         :return:
         """
+        self.assertIsNotNone(m1)
+        validation_utils.validate_deployment_file(self.config)
         k8_utils.execute(self.config)
 
-    @patch('os.makedirs')
     @patch('snaps_common.ansible_snaps.ansible_utils.apply_playbook')
-    @patch('subprocess.call')
-    @patch('snaps_k8s.provision.ansible_configuration.get_host_master_name',
-           return_value='master')
-    def test_clean(self, m1, m2, m3, m4):
+    def test_clean(self, m1):
         """
         Initial test to ensure main code path does not have any syntax or
         import errors
         :return:
         """
+        self.assertIsNotNone(m1)
         k8_utils.clean_k8(self.config)