How to use the charmhelpers.core.hookenv.relation_get function in charmhelpers

def peer_retrieve(key, relation_name='cluster'):
    """Retrieve a named key from peer relation `relation_name`."""
    cluster_rels = relation_ids(relation_name)
    if len(cluster_rels) > 0:
        cluster_rid = cluster_rels[0]
        return relation_get(attribute=key, rid=cluster_rid,
                            unit=local_unit())
    else:
        raise ValueError('Unable to detect'
                         'peer relation {}'.format(relation_name))

def _neutron_url(rid, unit):
    # supports legacy relation settings.
    return (relation_get('neutron_url', rid=rid, unit=unit) or
            relation_get('quantum_url', rid=rid, unit=unit))

'''
    Determines whether enough data has been provided in configuration
    or relation data to configure HTTPS
    .
    returns: boolean
    '''
    use_https = config_get('use-https')
    if use_https and bool_from_string(use_https):
        return True
    if config_get('ssl_cert') and config_get('ssl_key'):
        return True
    for r_id in relation_ids('identity-service'):
        for unit in relation_list(r_id):
            # TODO - needs fixing for new helper as ssl_cert/key suffixes with CN
            rel_state = [
                relation_get('https_keystone', rid=r_id, unit=unit),
                relation_get('ca_cert', rid=r_id, unit=unit),
            ]
            # NOTE: works around (LP: #1203241)
            if (None not in rel_state) and ('' not in rel_state):
                return True
    return False

def ensure_ceph_keyring(service, user=None, group=None, relation='ceph'):
    """Ensures a ceph keyring is created for a named service and optionally
    ensures user and group ownership.

    Returns False if no ceph key is available in relation state.
    """
    key = None
    for rid in relation_ids(relation):
        for unit in related_units(rid):
            key = relation_get('key', rid=rid, unit=unit)
            if key:
                break

    if not key:
        return False

    create_keyring(service=service, key=key)
    keyring = _keyring_path(service)
    if user and group:
        check_call(['chown', '%s.%s' % (user, group), keyring])

    return True

Consolidate requested osd settings from all clients. Check that the
    requested setting is on the whitelist and it does not conflict with
    any other requested settings.

    :returns: Dictionary of settings
    :rtype: dict

    :raises: OSDSettingNotAllowed
    :raises: OSDSettingConflict
    """
    rel_ids = relation_ids(relation_name)
    osd_settings = {}
    for relid in rel_ids:
        for unit in related_units(relid):
            unit_settings = relation_get('osd-settings', unit, relid) or '{}'
            unit_settings = json.loads(unit_settings)
            for key, value in unit_settings.items():
                if key not in OSD_SETTING_WHITELIST:
                    msg = 'Illegal settings "{}"'.format(key)
                    raise OSDSettingNotAllowed(msg)
                if key in osd_settings:
                    if osd_settings[key] != unit_settings[key]:
                        msg = 'Conflicting settings for "{}"'.format(key)
                        raise OSDSettingConflict(msg)
                else:
                    osd_settings[key] = value
    return _order_dict_by_key(osd_settings)

def relation_get(attribute=None, unit=None, rid=None):
    """Attempt to use leader-get if supported in the current version of Juju,
    otherwise falls back on relation-get.

    Note that we only attempt to use leader-get if the provided rid is a peer
    relation id or no relation id is provided (in which case we assume we are
    within the peer relation context).
    """
    try:
        if rid in relation_ids('cluster'):
            return leader_get(attribute, rid)
        else:
            raise NotImplementedError
    except NotImplementedError:
        return _relation_get(attribute=attribute, rid=rid, unit=unit)

def determine_purge_packages_dashboard_plugin():
    """Determine the packages to purge from the 'dashboard-plugin' relation.

    The relation defines two keys 'conflicting-packages' and 'install-packages'
    that are used by the plugin to signal to this charm which packages should
    be installed and which are conflicting.

    :returns: List of packages to purge from dashboard plugins
    :rtype: List[str]
    """
    conflict_packages = []
    for rid in relation_ids("dashboard-plugin"):
        for unit in related_units(rid):
            rdata = relation_get(unit=unit, rid=rid)
            conflicting_packages_json = rdata.get("conflicting-packages", "[]")
            try:
                conflict_packages.extend(json.loads(conflicting_packages_json))
            except json.JSONDecodeError as e:
                log("Error decoding json from {}/{}: on dashboard-plugin "
                    " relation - ignoring '{}' - error is:{}"
                    .format(rid, unit, conflicting_packages_json, str(e)),
                    level=ERROR)
    return list(set(conflict_packages))

'rabbitmq_user': username,
                    'rabbitmq_password': relation_get('password', rid=rid,
                                                      unit=unit),
                    'rabbitmq_virtual_host': vhost,
                })

                ssl_port = relation_get('ssl_port', rid=rid, unit=unit)
                if ssl_port:
                    ctxt['rabbit_ssl_port'] = ssl_port
                    rabbitmq_port = ssl_port

                ssl_ca = relation_get('ssl_ca', rid=rid, unit=unit)
                if ssl_ca:
                    ctxt['rabbit_ssl_ca'] = ssl_ca

                if relation_get('ha_queues', rid=rid, unit=unit) is not None:
                    ctxt['rabbitmq_ha_queues'] = True

                ha_vip_only = relation_get('ha-vip-only',
                                           rid=rid, unit=unit) is not None

                if self.context_complete(ctxt):
                    if 'rabbit_ssl_ca' in ctxt:
                        if not self.ssl_dir:
                            log("Charm not setup for ssl support but ssl ca "
                                "found", level=INFO)
                            break

                        ca_path = os.path.join(
                            self.ssl_dir, 'rabbit-client-ca.pem')
                        with open(ca_path, 'wb') as fh:
                            fh.write(b64decode(ctxt['rabbit_ssl_ca']))

def neutron_context(self):
        # generate config context for neutron or quantum. these get converted
        # directly into flags in nova.conf
        # NOTE: Its up to release templates to set correct driver
        neutron_ctxt = {'neutron_url': None}
        for rid in relation_ids('cloud-compute'):
            for unit in related_units(rid):
                rel = {'rid': rid, 'unit': unit}

                url = _neutron_url(**rel)
                if not url:
                    # only bother with units that have a neutron url set.
                    continue

                neutron_ctxt = {
                    'auth_protocol': relation_get(
                        'auth_protocol', **rel) or 'http',
                    'service_protocol': relation_get(
                        'service_protocol', **rel) or 'http',
                    'service_port': relation_get(
                        'service_port', **rel) or '5000',
                    'neutron_auth_strategy': 'keystone',
                    'keystone_host': relation_get(
                        'auth_host', **rel),
                    'auth_port': relation_get(
                        'auth_port', **rel),
                    'neutron_admin_tenant_name': relation_get(
                        'service_tenant_name', **rel),
                    'neutron_admin_username': relation_get(
                        'service_username', **rel),
                    'neutron_admin_password': relation_get(
                        'service_password', **rel),