INSTRUCTION
stringlengths 1
8.43k
| RESPONSE
stringlengths 75
104k
|
|---|---|
Registers a hook callable to process tree items right before they are passed to templates.
|
def register_items_hook(func):
"""Registers a hook callable to process tree items right before they are passed to templates.
Callable should be able to:
a) handle ``tree_items`` and ``tree_sender`` key params.
``tree_items`` will contain a list of extended TreeItem objects ready to pass to template.
``tree_sender`` will contain navigation type identifier
(e.g.: `menu`, `sitetree`, `breadcrumbs`, `menu.children`, `sitetree.children`)
b) return a list of extended TreeItems objects to pass to template.
Example::
# Put the following code somewhere where it'd be triggered as expected. E.g. in app view.py.
# First import the register function.
from sitetree.sitetreeapp import register_items_hook
# The following function will be used as items processor.
def my_items_processor(tree_items, tree_sender):
# Suppose we want to process only menu child items.
if tree_sender == 'menu.children':
# Lets add 'Hooked: ' to resolved titles of every item.
for item in tree_items:
item.title_resolved = 'Hooked: %s' % item.title_resolved
# Return items list mutated or not.
return tree_items
# And we register items processor.
register_items_hook(my_items_processor)
:param func:
"""
global _ITEMS_PROCESSOR
global _ITEMS_PROCESSOR_ARGS_LEN
_ITEMS_PROCESSOR = func
if func:
args_len = len(getargspec(func).args)
if args_len not in {2, 3}:
raise SiteTreeError('`register_items_hook()` expects a function with two or three arguments.')
_ITEMS_PROCESSOR_ARGS_LEN = args_len
|
Registers dynamic trees to be available for sitetree runtime. Expects trees to be an iterable with structures created with compose_dynamic_tree ().
|
def register_dynamic_trees(trees, *args, **kwargs):
"""Registers dynamic trees to be available for `sitetree` runtime.
Expects `trees` to be an iterable with structures created with `compose_dynamic_tree()`.
Example::
register_dynamic_trees(
# Get all the trees from `my_app`.
compose_dynamic_tree('my_app'),
# Get all the trees from `my_app` and attach them to `main` tree root.
compose_dynamic_tree('my_app', target_tree_alias='main'),
# Get all the trees from `my_app` and attach them to `has_dynamic` aliased item in `main` tree.
compose_dynamic_tree('articles', target_tree_alias='main', parent_tree_item_alias='has_dynamic'),
# Define a tree right on the registration.
compose_dynamic_tree((
tree('dynamic', items=(
item('dynamic_1', 'dynamic_1_url', children=(
item('dynamic_1_sub_1', 'dynamic_1_sub_1_url'),
)),
item('dynamic_2', 'dynamic_2_url'),
)),
)),
)
Accepted kwargs:
bool reset_cache: Resets tree cache, to introduce all changes made to a tree immediately.
"""
global _DYNAMIC_TREES
if _IDX_ORPHAN_TREES not in _DYNAMIC_TREES:
_DYNAMIC_TREES[_IDX_ORPHAN_TREES] = {}
if isinstance(trees, dict): # New `less-brackets` style registration.
trees = [trees]
trees.extend(args)
for tree in trees or []:
if tree is not None and tree['sitetrees'] is not None:
if tree['tree'] is None:
# Register trees as they are defined in app.
for st in tree['sitetrees']:
if st.alias not in _DYNAMIC_TREES[_IDX_ORPHAN_TREES]:
_DYNAMIC_TREES[_IDX_ORPHAN_TREES][st.alias] = []
_DYNAMIC_TREES[_IDX_ORPHAN_TREES][st.alias].append(st)
else:
# Register tree items as parts of existing trees.
index = _IDX_TPL % (tree['tree'], tree['parent_item'])
if index not in _DYNAMIC_TREES:
_DYNAMIC_TREES[index] = []
_DYNAMIC_TREES[index].extend(tree['sitetrees'])
reset_cache = kwargs.get('reset_cache', False)
if reset_cache:
cache_ = get_sitetree().cache
cache_.empty()
cache_.reset()
|
Returns a structure describing a dynamic sitetree. utils The structure can be built from various sources
|
def compose_dynamic_tree(src, target_tree_alias=None, parent_tree_item_alias=None, include_trees=None):
"""Returns a structure describing a dynamic sitetree.utils
The structure can be built from various sources,
:param str|iterable src: If a string is passed to `src`, it'll be treated as the name of an app,
from where one want to import sitetrees definitions. `src` can be an iterable
of tree definitions (see `sitetree.toolbox.tree()` and `item()` functions).
:param str|unicode target_tree_alias: Static tree alias to attach items from dynamic trees to.
:param str|unicode parent_tree_item_alias: Tree item alias from a static tree to attach items from dynamic trees to.
:param list include_trees: Sitetree aliases to filter `src`.
:rtype: dict
"""
def result(sitetrees=src):
if include_trees is not None:
sitetrees = [tree for tree in sitetrees if tree.alias in include_trees]
return {
'app': src,
'sitetrees': sitetrees,
'tree': target_tree_alias,
'parent_item': parent_tree_item_alias}
if isinstance(src, six.string_types):
# Considered to be an application name.
try:
module = import_app_sitetree_module(src)
return None if module is None else result(getattr(module, 'sitetrees', None))
except ImportError as e:
if settings.DEBUG:
warnings.warn('Unable to register dynamic sitetree(s) for `%s` application: %s. ' % (src, e))
return None
return result()
|
Initializes local cache from Django cache.
|
def init(self):
"""Initializes local cache from Django cache."""
# Drop cache flag set by .reset() method.
cache.get('sitetrees_reset') and self.empty(init=False)
self.cache = cache.get(
'sitetrees', {'sitetrees': {}, 'parents': {}, 'items_by_ids': {}, 'tree_aliases': {}})
|
Empties cached sitetree data.
|
def empty(self, **kwargs):
"""Empties cached sitetree data."""
cache.delete('sitetrees')
cache.delete('sitetrees_reset')
kwargs.get('init', True) and self.init()
|
Returns cache entry parameter value by its name.
|
def get_entry(self, entry_name, key):
"""Returns cache entry parameter value by its name.
:param str|unicode entry_name:
:param key:
:return:
"""
return self.cache[entry_name].get(key, False)
|
Updates cache entry parameter with new data.
|
def update_entry_value(self, entry_name, key, value):
"""Updates cache entry parameter with new data.
:param str|unicode entry_name:
:param key:
:param value:
"""
if key not in self.cache[entry_name]:
self.cache[entry_name][key] = {}
self.cache[entry_name][key].update(value)
|
Replaces entire cache entry parameter data by its name with new data.
|
def set_entry(self, entry_name, key, value):
"""Replaces entire cache entry parameter data by its name with new data.
:param str|unicode entry_name:
:param key:
:param value:
"""
self.cache[entry_name][key] = value
|
Initializes sitetree to handle new request.
|
def init(self, context):
"""Initializes sitetree to handle new request.
:param Context|None context:
"""
self.cache = Cache()
self.current_page_context = context
self.current_request = context.get('request', None) if context else None
self.current_lang = get_language()
self._current_app_is_admin = None
self._current_user_permissions = _UNSET
self._items_urls = {} # Resolved urls are cache for a request.
self._current_items = {}
|
Resolves internationalized tree alias. Verifies whether a separate sitetree is available for currently active language. If so returns i18n alias. If not returns the initial alias.
|
def resolve_tree_i18n_alias(self, alias):
"""Resolves internationalized tree alias.
Verifies whether a separate sitetree is available for currently active language.
If so, returns i18n alias. If not, returns the initial alias.
:param str|unicode alias:
:rtype: str|unicode
"""
if alias not in _I18N_TREES:
return alias
current_language_code = self.current_lang
i18n_tree_alias = '%s_%s' % (alias, current_language_code)
trees_count = self.cache.get_entry('tree_aliases', i18n_tree_alias)
if trees_count is False:
trees_count = MODEL_TREE_CLASS.objects.filter(alias=i18n_tree_alias).count()
self.cache.set_entry('tree_aliases', i18n_tree_alias, trees_count)
if trees_count:
alias = i18n_tree_alias
return alias
|
Attaches dynamic sitetrees items registered with register_dynamic_trees () to an initial ( source ) items list.
|
def attach_dynamic_tree_items(tree_alias, src_tree_items):
"""Attaches dynamic sitetrees items registered with `register_dynamic_trees()`
to an initial (source) items list.
:param str|unicode tree_alias:
:param list src_tree_items:
:rtype: list
"""
if not _DYNAMIC_TREES:
return src_tree_items
# This guarantees that a dynamic source stays intact,
# no matter how dynamic sitetrees are attached.
trees = deepcopy(_DYNAMIC_TREES)
items = []
if not src_tree_items:
if _IDX_ORPHAN_TREES in trees and tree_alias in trees[_IDX_ORPHAN_TREES]:
for tree in trees[_IDX_ORPHAN_TREES][tree_alias]:
items.extend(tree.dynamic_items)
else:
# TODO Seems to be underoptimized %)
# Tree item attachment by alias.
for static_item in list(src_tree_items):
items.append(static_item)
if not static_item.alias:
continue
idx = _IDX_TPL % (tree_alias, static_item.alias)
if idx not in trees:
continue
for tree in trees[idx]:
tree.alias = tree_alias
for dyn_item in tree.dynamic_items:
if dyn_item.parent is None:
dyn_item.parent = static_item
# Unique IDs are required for the same trees attached
# to different parents.
dyn_item.id = generate_id_for(dyn_item)
items.append(dyn_item)
# Tree root attachment.
idx = _IDX_TPL % (tree_alias, None)
if idx in _DYNAMIC_TREES:
trees = deepcopy(_DYNAMIC_TREES)
for tree in trees[idx]:
tree.alias = tree_alias
items.extend(tree.dynamic_items)
return items
|
Returns boolean whether current application is Admin contrib.
|
def current_app_is_admin(self):
"""Returns boolean whether current application is Admin contrib.
:rtype: bool
"""
is_admin = self._current_app_is_admin
if is_admin is None:
context = self.current_page_context
current_app = getattr(
# Try from request.resolver_match.app_name
getattr(context.get('request', None), 'resolver_match', None), 'app_name',
# Try from global context obj.
getattr(context, 'current_app', None))
if current_app is None: # Try from global context dict.
current_app = context.get('current_app', '')
is_admin = current_app == ADMIN_APP_NAME
self._current_app_is_admin = is_admin
return is_admin
|
Gets site tree items from the given site tree. Caches result to dictionary. Returns ( tree alias tree items ) tuple.
|
def get_sitetree(self, alias):
"""Gets site tree items from the given site tree.
Caches result to dictionary.
Returns (tree alias, tree items) tuple.
:param str|unicode alias:
:rtype: tuple
"""
cache_ = self.cache
get_cache_entry = cache_.get_entry
set_cache_entry = cache_.set_entry
caching_required = False
if not self.current_app_is_admin():
# We do not need i18n for a tree rendered in Admin dropdown.
alias = self.resolve_tree_i18n_alias(alias)
sitetree = get_cache_entry('sitetrees', alias)
if not sitetree:
if DYNAMIC_ONLY:
sitetree = []
else:
sitetree = (
MODEL_TREE_ITEM_CLASS.objects.
select_related('parent', 'tree').
prefetch_related('access_permissions__content_type').
filter(tree__alias__exact=alias).
order_by('parent__sort_order', 'sort_order'))
sitetree = self.attach_dynamic_tree_items(alias, sitetree)
set_cache_entry('sitetrees', alias, sitetree)
caching_required = True
parents = get_cache_entry('parents', alias)
if not parents:
parents = defaultdict(list)
for item in sitetree:
parent = getattr(item, 'parent')
parents[parent].append(item)
set_cache_entry('parents', alias, parents)
# Prepare items by ids cache if needed.
if caching_required:
# We need this extra pass to avoid future problems on items depth calculation.
cache_update = cache_.update_entry_value
for item in sitetree:
cache_update('items_by_ids', alias, {item.id: item})
url = self.url
calculate_item_depth = self.calculate_item_depth
for item in sitetree:
if caching_required:
item.has_children = False
if not hasattr(item, 'depth'):
item.depth = calculate_item_depth(alias, item.id)
item.depth_range = range(item.depth)
# Resolve item permissions.
if item.access_restricted:
permissions_src = (
item.permissions if getattr(item, 'is_dynamic', False)
else item.access_permissions.all())
item.perms = set(
['%s.%s' % (perm.content_type.app_label, perm.codename) for perm in permissions_src])
# Contextual properties.
item.url_resolved = url(item)
item.title_resolved = LazyTitle(item.title) if VARIABLE_TAG_START in item.title else item.title
item.is_current = False
item.in_current_branch = False
# Get current item for the given sitetree.
self.get_tree_current_item(alias)
# Save sitetree data into cache if needed.
if caching_required:
cache_.save()
return alias, sitetree
|
Calculates depth of the item in the tree.
|
def calculate_item_depth(self, tree_alias, item_id, depth=0):
"""Calculates depth of the item in the tree.
:param str|unicode tree_alias:
:param int item_id:
:param int depth:
:rtype: int
"""
item = self.get_item_by_id(tree_alias, item_id)
if hasattr(item, 'depth'):
depth = item.depth + depth
else:
if item.parent is not None:
depth = self.calculate_item_depth(tree_alias, item.parent.id, depth + 1)
return depth
|
Resolves current tree item of tree_alias tree matching current request path against URL of given tree item.
|
def get_tree_current_item(self, tree_alias):
"""Resolves current tree item of 'tree_alias' tree matching current
request path against URL of given tree item.
:param str|unicode tree_alias:
:rtype: TreeItemBase
"""
current_item = self._current_items.get(tree_alias, _UNSET)
if current_item is not _UNSET:
if current_item is not None:
current_item.is_current = True # Could be reset by .get_sitetree()
return current_item
current_item = None
if self.current_app_is_admin():
self._current_items[tree_alias] = current_item
return None
# urlquote is an attempt to support non-ascii in url.
current_url = self.current_request.path
if isinstance(current_url, str):
current_url = current_url.encode('UTF-8')
if current_url:
current_url = urlquote(current_url)
for url_item, url in self._items_urls.items():
# Iterate each as this dict may contains "current" items for various trees.
if url != current_url:
continue
url_item.is_current = True
if url_item.tree.alias == tree_alias:
current_item = url_item
if current_item is not None:
self._current_items[tree_alias] = current_item
return current_item
|
Resolves item s URL.
|
def url(self, sitetree_item, context=None):
"""Resolves item's URL.
:param TreeItemBase sitetree_item: TreeItemBase heir object, 'url' property of which
is processed as URL pattern or simple URL.
:param Context context:
:rtype: str|unicode
"""
context = context or self.current_page_context
resolve_var = self.resolve_var
if not isinstance(sitetree_item, MODEL_TREE_ITEM_CLASS):
sitetree_item = resolve_var(sitetree_item, context)
resolved_url = self._items_urls.get(sitetree_item)
if resolved_url is not None:
return resolved_url
# Resolve only if item's URL is marked as pattern.
if sitetree_item.urlaspattern:
url = sitetree_item.url
view_path = url
all_arguments = []
if ' ' in url:
view_path = url.split(' ')
# We should try to resolve URL parameters from site tree item.
for view_argument in view_path[1:]:
resolved = resolve_var(view_argument)
# We enclose arg in double quotes as already resolved.
all_arguments.append('"%s"' % resolved)
view_path = view_path[0].strip('"\' ')
url_pattern = "'%s' %s" % (view_path, ' '.join(all_arguments))
else:
url_pattern = '%s' % sitetree_item.url
if sitetree_item.urlaspattern:
# Form token to pass to Django 'url' tag.
url_token = 'url %s as item.url_resolved' % url_pattern
url_tag(
Parser(None),
Token(token_type=TOKEN_BLOCK, contents=url_token)
).render(context)
resolved_url = context['item.url_resolved'] or UNRESOLVED_ITEM_MARKER
else:
resolved_url = url_pattern
self._items_urls[sitetree_item] = resolved_url
return resolved_url
|
Initializes sitetree in memory.
|
def init_tree(self, tree_alias, context):
"""Initializes sitetree in memory.
Returns tuple with resolved tree alias and items on success.
On fail returns (None, None).
:param str|unicode tree_alias:
:param Context context:
:rtype: tuple
"""
request = context.get('request', None)
if request is None:
raise SiteTreeError(
'Sitetree requires "django.core.context_processors.request" template context processor to be active. '
'If it is, check that your view pushes request data into the template.')
if id(request) != id(self.current_request):
self.init(context)
# Resolve tree_alias from the context.
tree_alias = self.resolve_var(tree_alias)
tree_alias, sitetree_items = self.get_sitetree(tree_alias)
if not sitetree_items:
return None, None
return tree_alias, sitetree_items
|
Returns an arbitrary attribute of a sitetree item resolved as current for current page.
|
def get_current_page_attr(self, attr_name, tree_alias, context):
"""Returns an arbitrary attribute of a sitetree item resolved as current for current page.
:param str|unicode attr_name:
:param str|unicode tree_alias:
:param Context context:
:rtype: str|unicode
"""
tree_alias, sitetree_items = self.init_tree(tree_alias, context)
current_item = self.get_tree_current_item(tree_alias)
if current_item is None:
if settings.DEBUG and RAISE_ITEMS_ERRORS_ON_DEBUG:
raise SiteTreeError(
'Unable to resolve current sitetree item to get a `%s` for current page. Check whether '
'there is an appropriate sitetree item defined for current URL.' % attr_name)
return ''
return getattr(current_item, attr_name, '')
|
Returns ancestor of level deep recursively
|
def get_ancestor_level(self, current_item, depth=1):
"""Returns ancestor of level `deep` recursively
:param TreeItemBase current_item:
:param int depth:
:rtype: TreeItemBase
"""
if current_item.parent is None:
return current_item
if depth <= 1:
return current_item.parent
return self.get_ancestor_level(current_item.parent, depth=depth-1)
|
Builds and returns menu structure for sitetree_menu tag.
|
def menu(self, tree_alias, tree_branches, context):
"""Builds and returns menu structure for 'sitetree_menu' tag.
:param str|unicode tree_alias:
:param str|unicode tree_branches:
:param Context context:
:rtype: list|str
"""
tree_alias, sitetree_items = self.init_tree(tree_alias, context)
if not sitetree_items:
return ''
tree_branches = self.resolve_var(tree_branches)
parent_isnull = False
parent_ids = []
parent_aliases = []
current_item = self.get_tree_current_item(tree_alias)
self.tree_climber(tree_alias, current_item)
# Support item addressing both through identifiers and aliases.
for branch_id in tree_branches.split(','):
branch_id = branch_id.strip()
if branch_id == ALIAS_TRUNK:
parent_isnull = True
elif branch_id == ALIAS_THIS_CHILDREN and current_item is not None:
branch_id = current_item.id
parent_ids.append(branch_id)
elif branch_id == ALIAS_THIS_ANCESTOR_CHILDREN and current_item is not None:
branch_id = self.get_ancestor_item(tree_alias, current_item).id
parent_ids.append(branch_id)
elif branch_id == ALIAS_THIS_SIBLINGS and current_item is not None and current_item.parent is not None:
branch_id = current_item.parent.id
parent_ids.append(branch_id)
elif branch_id == ALIAS_THIS_PARENT_SIBLINGS and current_item is not None:
branch_id = self.get_ancestor_level(current_item, depth=2).id
parent_ids.append(branch_id)
elif branch_id.isdigit():
parent_ids.append(int(branch_id))
else:
parent_aliases.append(branch_id)
check_access = self.check_access
menu_items = []
for item in sitetree_items:
if not item.hidden and item.inmenu and check_access(item, context):
if item.parent is None:
if parent_isnull:
menu_items.append(item)
else:
if item.parent.id in parent_ids or item.parent.alias in parent_aliases:
menu_items.append(item)
menu_items = self.apply_hook(menu_items, 'menu')
self.update_has_children(tree_alias, menu_items, 'menu')
return menu_items
|
Applies item processing hook registered with register_item_hook () to items supplied and returns processed list.
|
def apply_hook(self, items, sender):
"""Applies item processing hook, registered with ``register_item_hook()``
to items supplied, and returns processed list.
Returns initial items list if no hook is registered.
:param list items:
:param str|unicode sender: menu, breadcrumbs, sitetree, {type}.children, {type}.has_children
:rtype: list
"""
processor = _ITEMS_PROCESSOR
if processor is None:
return items
if _ITEMS_PROCESSOR_ARGS_LEN == 2:
return processor(tree_items=items, tree_sender=sender)
return processor(tree_items=items, tree_sender=sender, context=self.current_page_context)
|
Checks whether a current user has an access to a certain item.
|
def check_access(self, item, context):
"""Checks whether a current user has an access to a certain item.
:param TreeItemBase item:
:param Context context:
:rtype: bool
"""
if hasattr(self.current_request.user.is_authenticated, '__call__'):
authenticated = self.current_request.user.is_authenticated()
else:
authenticated = self.current_request.user.is_authenticated
if item.access_loggedin and not authenticated:
return False
if item.access_guest and authenticated:
return False
if item.access_restricted:
user_perms = self._current_user_permissions
if user_perms is _UNSET:
user_perms = set(context['user'].get_all_permissions())
self._current_user_permissions = user_perms
if item.access_perm_type == MODEL_TREE_ITEM_CLASS.PERM_TYPE_ALL:
if len(item.perms) != len(item.perms.intersection(user_perms)):
return False
else:
if not len(item.perms.intersection(user_perms)):
return False
return True
|
Builds and returns breadcrumb trail structure for sitetree_breadcrumbs tag.
|
def breadcrumbs(self, tree_alias, context):
"""Builds and returns breadcrumb trail structure for 'sitetree_breadcrumbs' tag.
:param str|unicode tree_alias:
:param Context context:
:rtype: list|str
"""
tree_alias, sitetree_items = self.init_tree(tree_alias, context)
if not sitetree_items:
return ''
current_item = self.get_tree_current_item(tree_alias)
breadcrumbs = []
if current_item is not None:
context_ = self.current_page_context
check_access = self.check_access
get_item_by_id = self.get_item_by_id
def climb(base_item):
"""Climbs up the site tree to build breadcrumb path.
:param TreeItemBase base_item:
"""
if base_item.inbreadcrumbs and not base_item.hidden and check_access(base_item, context_):
breadcrumbs.append(base_item)
if hasattr(base_item, 'parent') and base_item.parent is not None:
climb(get_item_by_id(tree_alias, base_item.parent.id))
climb(current_item)
breadcrumbs.reverse()
items = self.apply_hook(breadcrumbs, 'breadcrumbs')
self.update_has_children(tree_alias, items, 'breadcrumbs')
return items
|
Builds and returns tree structure for sitetree_tree tag.
|
def tree(self, tree_alias, context):
"""Builds and returns tree structure for 'sitetree_tree' tag.
:param str|unicode tree_alias:
:param Context context:
:rtype: list|str
"""
tree_alias, sitetree_items = self.init_tree(tree_alias, context)
if not sitetree_items:
return ''
tree_items = self.filter_items(self.get_children(tree_alias, None), 'sitetree')
tree_items = self.apply_hook(tree_items, 'sitetree')
self.update_has_children(tree_alias, tree_items, 'sitetree')
return tree_items
|
Builds and returns site tree item children structure for sitetree_children tag.
|
def children(self, parent_item, navigation_type, use_template, context):
"""Builds and returns site tree item children structure for 'sitetree_children' tag.
:param TreeItemBase parent_item:
:param str|unicode navigation_type: menu, sitetree
:param str|unicode use_template:
:param Context context:
:rtype: list
"""
# Resolve parent item and current tree alias.
parent_item = self.resolve_var(parent_item, context)
tree_alias, tree_items = self.get_sitetree(parent_item.tree.alias)
# Mark path to current item.
self.tree_climber(tree_alias, self.get_tree_current_item(tree_alias))
tree_items = self.get_children(tree_alias, parent_item)
tree_items = self.filter_items(tree_items, navigation_type)
tree_items = self.apply_hook(tree_items, '%s.children' % navigation_type)
self.update_has_children(tree_alias, tree_items, navigation_type)
my_template = get_template(use_template)
context.push()
context['sitetree_items'] = tree_items
rendered = my_template.render(context.flatten() if _CONTEXT_FLATTEN else context)
context.pop()
return rendered
|
Returns item s children.
|
def get_children(self, tree_alias, item):
"""Returns item's children.
:param str|unicode tree_alias:
:param TreeItemBase|None item:
:rtype: list
"""
if not self.current_app_is_admin():
# We do not need i18n for a tree rendered in Admin dropdown.
tree_alias = self.resolve_tree_i18n_alias(tree_alias)
return self.cache.get_entry('parents', tree_alias)[item]
|
Updates has_children attribute for tree items inplace.
|
def update_has_children(self, tree_alias, tree_items, navigation_type):
"""Updates 'has_children' attribute for tree items inplace.
:param str|unicode tree_alias:
:param list tree_items:
:param str|unicode navigation_type: sitetree, breadcrumbs, menu
"""
get_children = self.get_children
filter_items = self.filter_items
apply_hook = self.apply_hook
for tree_item in tree_items:
children = get_children(tree_alias, tree_item)
children = filter_items(children, navigation_type)
children = apply_hook(children, '%s.has_children' % navigation_type)
tree_item.has_children = len(children) > 0
|
Filters sitetree item s children if hidden and by navigation type.
|
def filter_items(self, items, navigation_type=None):
"""Filters sitetree item's children if hidden and by navigation type.
NB: We do not apply any filters to sitetree in admin app.
:param list items:
:param str|unicode navigation_type: sitetree, breadcrumbs, menu
:rtype: list
"""
if self.current_app_is_admin():
return items
items_filtered = []
context = self.current_page_context
check_access = self.check_access
for item in items:
if item.hidden:
continue
if not check_access(item, context):
continue
if not getattr(item, 'in%s' % navigation_type, True): # Hidden for current nav type
continue
items_filtered.append(item)
return items_filtered
|
Climbs up the site tree to resolve root item for chosen one.
|
def get_ancestor_item(self, tree_alias, base_item):
"""Climbs up the site tree to resolve root item for chosen one.
:param str|unicode tree_alias:
:param TreeItemBase base_item:
:rtype: TreeItemBase
"""
parent = None
if hasattr(base_item, 'parent') and base_item.parent is not None:
parent = self.get_ancestor_item(tree_alias, self.get_item_by_id(tree_alias, base_item.parent.id))
if parent is None:
return base_item
return parent
|
Climbs up the site tree to mark items of current branch.
|
def tree_climber(self, tree_alias, base_item):
"""Climbs up the site tree to mark items of current branch.
:param str|unicode tree_alias:
:param TreeItemBase base_item:
"""
if base_item is not None:
base_item.in_current_branch = True
if hasattr(base_item, 'parent') and base_item.parent is not None:
self.tree_climber(tree_alias, self.get_item_by_id(tree_alias, base_item.parent.id))
|
Resolves name as a variable in a given context.
|
def resolve_var(self, varname, context=None):
"""Resolves name as a variable in a given context.
If no context specified page context' is considered as context.
:param str|unicode varname:
:param Context context:
:return:
"""
context = context or self.current_page_context
if isinstance(varname, FilterExpression):
varname = varname.resolve(context)
else:
varname = varname.strip()
try:
varname = Variable(varname).resolve(context)
except VariableDoesNotExist:
varname = varname
return varname
|
Parses sitetree tag parameters.
|
def sitetree_tree(parser, token):
"""Parses sitetree tag parameters.
Two notation types are possible:
1. Two arguments:
{% sitetree_tree from "mytree" %}
Used to render tree for "mytree" site tree.
2. Four arguments:
{% sitetree_tree from "mytree" template "sitetree/mytree.html" %}
Used to render tree for "mytree" site tree using specific
template "sitetree/mytree.html"
"""
tokens = token.split_contents()
use_template = detect_clause(parser, 'template', tokens)
tokens_num = len(tokens)
if tokens_num in (3, 5):
tree_alias = parser.compile_filter(tokens[2])
return sitetree_treeNode(tree_alias, use_template)
else:
raise template.TemplateSyntaxError(
'%r tag requires two arguments. E.g. {%% sitetree_tree from "mytree" %%}.' % tokens[0])
|
Parses sitetree_children tag parameters.
|
def sitetree_children(parser, token):
"""Parses sitetree_children tag parameters.
Six arguments:
{% sitetree_children of someitem for menu template "sitetree/mychildren.html" %}
Used to render child items of specific site tree 'someitem'
using template "sitetree/mychildren.html" for menu navigation.
Basically template argument should contain path to current template itself.
Allowed navigation types: 1) menu; 2) sitetree.
"""
tokens = token.split_contents()
use_template = detect_clause(parser, 'template', tokens)
tokens_num = len(tokens)
clauses_in_places = (
tokens_num == 5 and tokens[1] == 'of' and tokens[3] == 'for' and tokens[4] in ('menu', 'sitetree')
)
if clauses_in_places and use_template is not None:
tree_item = tokens[2]
navigation_type = tokens[4]
return sitetree_childrenNode(tree_item, navigation_type, use_template)
else:
raise template.TemplateSyntaxError(
'%r tag requires six arguments. '
'E.g. {%% sitetree_children of someitem for menu template "sitetree/mychildren.html" %%}.' % tokens[0])
|
Parses sitetree_breadcrumbs tag parameters.
|
def sitetree_breadcrumbs(parser, token):
"""Parses sitetree_breadcrumbs tag parameters.
Two notation types are possible:
1. Two arguments:
{% sitetree_breadcrumbs from "mytree" %}
Used to render breadcrumb path for "mytree" site tree.
2. Four arguments:
{% sitetree_breadcrumbs from "mytree" template "sitetree/mycrumb.html" %}
Used to render breadcrumb path for "mytree" site tree using specific
template "sitetree/mycrumb.html"
"""
tokens = token.split_contents()
use_template = detect_clause(parser, 'template', tokens)
tokens_num = len(tokens)
if tokens_num == 3:
tree_alias = parser.compile_filter(tokens[2])
return sitetree_breadcrumbsNode(tree_alias, use_template)
else:
raise template.TemplateSyntaxError(
'%r tag requires two arguments. E.g. {%% sitetree_breadcrumbs from "mytree" %%}.' % tokens[0])
|
Parses sitetree_menu tag parameters.
|
def sitetree_menu(parser, token):
"""Parses sitetree_menu tag parameters.
{% sitetree_menu from "mytree" include "trunk,1,level3" %}
Used to render trunk, branch with id 1 and branch aliased 'level3'
elements from "mytree" site tree as a menu.
These are reserved aliases:
* 'trunk' - items without parents
* 'this-children' - items under item resolved as current for the current page
* 'this-siblings' - items under parent of item resolved as current for
the current page (current item included)
* 'this-ancestor-children' - items under grandparent item (closest to root)
for the item resolved as current for the current page
{% sitetree_menu from "mytree" include "trunk,1,level3" template "sitetree/mymenu.html" %}
"""
tokens = token.split_contents()
use_template = detect_clause(parser, 'template', tokens)
tokens_num = len(tokens)
if tokens_num == 5 and tokens[3] == 'include':
tree_alias = parser.compile_filter(tokens[2])
tree_branches = parser.compile_filter(tokens[4])
return sitetree_menuNode(tree_alias, tree_branches, use_template)
else:
raise template.TemplateSyntaxError(
'%r tag requires four arguments. '
'E.g. {%% sitetree_menu from "mytree" include "trunk,1,level3" %%}.' % tokens[0])
|
Render helper is used by template node functions to render given template with given tree items in context.
|
def render(context, tree_items, use_template):
"""Render helper is used by template node functions
to render given template with given tree items in context.
"""
context.push()
context['sitetree_items'] = tree_items
if isinstance(use_template, FilterExpression):
use_template = use_template.resolve(context)
content = get_template(use_template).render(context.flatten() if _CONTEXT_FLATTEN else context)
context.pop()
return content
|
Node constructor to be used in tags.
|
def for_tag(cls, parser, token, preposition, error_hint):
"""Node constructor to be used in tags."""
tokens = token.split_contents()
if len(tokens) >= 3 and tokens[1] == preposition:
as_var = cls.get_as_var(tokens)
tree_alias = parser.compile_filter(tokens[2])
return cls(tree_alias, as_var)
raise template.TemplateSyntaxError(
'%r tag requires at least two arguments. E.g. {%% %s %%}.' % (tokens[0], error_hint))
|
Returns a URL for a given Tree admin page type.
|
def get_model_url_name(model_nfo, page, with_namespace=False):
"""Returns a URL for a given Tree admin page type."""
prefix = ''
if with_namespace:
prefix = 'admin:'
return ('%s%s_%s' % (prefix, '%s_%s' % model_nfo, page)).lower()
|
Forces unregistration of tree admin class with following re - registration.
|
def _reregister_tree_admin():
"""Forces unregistration of tree admin class with following re-registration."""
try:
admin.site.unregister(MODEL_TREE_CLASS)
except NotRegistered:
pass
admin.site.register(MODEL_TREE_CLASS, _TREE_ADMIN())
|
Fixes Admin contrib redirects compatibility problems introduced in Django 1. 4 by url handling changes.
|
def redirects_handler(*args, **kwargs):
"""Fixes Admin contrib redirects compatibility problems
introduced in Django 1.4 by url handling changes.
"""
path = args[0].path
shift = '../'
if 'delete' in path:
# Weird enough 'delete' is not handled by TreeItemAdmin::response_change().
shift += '../'
elif 'history' in path:
if 'item_id' not in kwargs:
# Encountered request from history page to return to tree layout page.
shift += '../'
return HttpResponseRedirect(path + shift)
|
Generic redirect for item editor.
|
def _redirect(self, request, response):
"""Generic redirect for item editor."""
if '_addanother' in request.POST:
return HttpResponseRedirect('../item_add/')
elif '_save' in request.POST:
return HttpResponseRedirect('../')
elif '_continue' in request.POST:
return response
return HttpResponseRedirect('')
|
Redirects to the appropriate items continue page on item add.
|
def response_add(self, request, obj, post_url_continue=None, **kwargs):
"""Redirects to the appropriate items' 'continue' page on item add.
As we administer tree items within tree itself, we
should make some changes to redirection process.
"""
if post_url_continue is None:
post_url_continue = '../item_%s/' % obj.pk
return self._redirect(request, super(TreeItemAdmin, self).response_add(request, obj, post_url_continue))
|
Redirects to the appropriate items add page on item change.
|
def response_change(self, request, obj, **kwargs):
"""Redirects to the appropriate items' 'add' page on item change.
As we administer tree items within tree itself, we
should make some changes to redirection process.
"""
return self._redirect(request, super(TreeItemAdmin, self).response_change(request, obj))
|
Returns modified form for TreeItem model. Parent field choices are built by sitetree itself.
|
def get_form(self, request, obj=None, **kwargs):
"""Returns modified form for TreeItem model.
'Parent' field choices are built by sitetree itself.
"""
if obj is not None and obj.parent is not None:
self.previous_parent = obj.parent
previous_parent_id = self.previous_parent.id
else:
previous_parent_id = None
my_choice_field = TreeItemChoiceField(self.tree, initial=previous_parent_id)
form = super(TreeItemAdmin, self).get_form(request, obj, **kwargs)
my_choice_field.label = form.base_fields['parent'].label
my_choice_field.help_text = form.base_fields['parent'].help_text
my_choice_field.widget = form.base_fields['parent'].widget
# Replace 'parent' TreeItem field with new appropriate one
form.base_fields['parent'] = my_choice_field
# Try to resolve all currently registered url names including those in namespaces.
if not getattr(self, 'known_url_names', False):
self.known_url_names = []
self.known_url_rules = []
resolver = get_resolver(get_urlconf())
for ns, (url_prefix, ns_resolver) in resolver.namespace_dict.items():
if ns != 'admin':
self._stack_known_urls(ns_resolver.reverse_dict, ns)
self._stack_known_urls(resolver.reverse_dict)
self.known_url_rules = sorted(self.known_url_rules)
form.known_url_names_hint = _(
'You are seeing this warning because "URL as Pattern" option is active and pattern entered above '
'seems to be invalid. Currently registered URL pattern names and parameters: ')
form.known_url_names = self.known_url_names
form.known_url_rules = self.known_url_rules
return form
|
Fetches Tree for current or given TreeItem.
|
def get_tree(self, request, tree_id, item_id=None):
"""Fetches Tree for current or given TreeItem."""
if tree_id is None:
tree_id = self.get_object(request, item_id).tree_id
self.tree = MODEL_TREE_CLASS._default_manager.get(pk=tree_id)
self.tree.verbose_name_plural = self.tree._meta.verbose_name_plural
self.tree.urls = _TREE_URLS
return self.tree
|
Moves item up or down by swapping sort_order field values of neighboring items.
|
def item_move(self, request, tree_id, item_id, direction):
"""Moves item up or down by swapping 'sort_order' field values of neighboring items."""
current_item = MODEL_TREE_ITEM_CLASS._default_manager.get(pk=item_id)
if direction == 'up':
sort_order = 'sort_order'
else:
sort_order = '-sort_order'
siblings = MODEL_TREE_ITEM_CLASS._default_manager.filter(
parent=current_item.parent,
tree=current_item.tree
).order_by(sort_order)
previous_item = None
for item in siblings:
if item != current_item:
previous_item = item
else:
break
if previous_item is not None:
current_item_sort_order = current_item.sort_order
previous_item_sort_order = previous_item.sort_order
current_item.sort_order = previous_item_sort_order
previous_item.sort_order = current_item_sort_order
current_item.save()
previous_item.save()
return HttpResponseRedirect('../../')
|
Saves TreeItem model under certain Tree. Handles item s parent assignment exception.
|
def save_model(self, request, obj, form, change):
"""Saves TreeItem model under certain Tree.
Handles item's parent assignment exception.
"""
if change:
# No, you're not allowed to make item parent of itself
if obj.parent is not None and obj.parent.id == obj.id:
obj.parent = self.previous_parent
messages.warning(
request, _("Item's parent left unchanged. Item couldn't be parent to itself."), '', True)
obj.tree = self.tree
obj.save()
|
Manages not only TreeAdmin URLs but also TreeItemAdmin URLs.
|
def get_urls(self):
"""Manages not only TreeAdmin URLs but also TreeItemAdmin URLs."""
urls = super(TreeAdmin, self).get_urls()
prefix_change = 'change/' if DJANGO_POST_19 else ''
sitetree_urls = [
url(r'^change/$', redirects_handler, name=get_tree_item_url_name('changelist')),
url(r'^((?P<tree_id>\d+)/)?%sitem_add/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_add), name=get_tree_item_url_name('add')),
url(r'^(?P<tree_id>\d+)/%sitem_(?P<item_id>\d+)/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_edit), name=get_tree_item_url_name('change')),
url(r'^%sitem_(?P<item_id>\d+)/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_edit), name=get_tree_item_url_name('change')),
url(r'^((?P<tree_id>\d+)/)?%sitem_(?P<item_id>\d+)/delete/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_delete), name=get_tree_item_url_name('delete')),
url(r'^((?P<tree_id>\d+)/)?%sitem_(?P<item_id>\d+)/history/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_history), name=get_tree_item_url_name('history')),
url(r'^(?P<tree_id>\d+)/%sitem_(?P<item_id>\d+)/move_(?P<direction>(up|down))/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_move), name=get_tree_item_url_name('move')),
]
if not DJANGO_POST_19:
sitetree_urls = patterns_func('', *sitetree_urls)
if SMUGGLER_INSTALLED:
sitetree_urls += (url(r'^dump_all/$', self.admin_site.admin_view(self.dump_view), name='sitetree_dump'),)
return sitetree_urls + urls
|
Dumps sitetrees with items using django - smuggler.
|
def dump_view(cls, request):
"""Dumps sitetrees with items using django-smuggler.
:param request:
:return:
"""
from smuggler.views import dump_to_response
return dump_to_response(request, [MODEL_TREE, MODEL_TREE_ITEM], filename_prefix='sitetrees')
|
Dynamically creates and returns a sitetree.
|
def tree(alias, title='', items=None, **kwargs):
"""Dynamically creates and returns a sitetree.
:param str|unicode alias:
:param str|unicode title:
:param iterable items: dynamic sitetree items objects created by `item` function.
:param kwargs: Additional arguments to pass to tree item initializer.
:rtype: TreeBase
"""
tree_obj = get_tree_model()(alias=alias, title=title, **kwargs)
tree_obj.id = generate_id_for(tree_obj)
tree_obj.is_dynamic = True
if items is not None:
tree_obj.dynamic_items = []
def traverse(items):
for item in items:
item.tree = tree_obj
tree_obj.dynamic_items.append(item)
if hasattr(item, 'dynamic_children'):
traverse(item.dynamic_children)
traverse(items)
return tree_obj
|
Dynamically creates and returns a sitetree item object.
|
def item(
title, url, children=None, url_as_pattern=True, hint='', alias='', description='',
in_menu=True, in_breadcrumbs=True, in_sitetree=True,
access_loggedin=False, access_guest=False,
access_by_perms=None, perms_mode_all=True, **kwargs):
"""Dynamically creates and returns a sitetree item object.
:param str|unicode title:
:param str|unicode url:
:param list, set children: a list of children for tree item. Children should also be created by `item` function.
:param bool url_as_pattern: consider URL as a name of a named URL
:param str|unicode hint: hints are usually shown to users
:param str|unicode alias: item name to address it from templates
:param str|unicode description: additional information on item (usually is not shown to users)
:param bool in_menu: show this item in menus
:param bool in_breadcrumbs: show this item in breadcrumbs
:param bool in_sitetree: show this item in sitetrees
:param bool access_loggedin: show item to logged in users only
:param bool access_guest: show item to guest users only
:param list|str||unicode|int, Permission access_by_perms: restrict access to users with these permissions.
This can be set to one or a list of permission names, IDs or Permission instances.
Permission names are more portable and should be in a form `<app_label>.<perm_codename>`, e.g.:
my_app.allow_save
:param bool perms_mode_all: permissions set interpretation rule:
True - user should have all the permissions;
False - user should have any of chosen permissions.
:rtype: TreeItemBase
"""
item_obj = get_tree_item_model()(
title=title, url=url, urlaspattern=url_as_pattern,
hint=hint, alias=alias, description=description, inmenu=in_menu,
insitetree=in_sitetree, inbreadcrumbs=in_breadcrumbs,
access_loggedin=access_loggedin, access_guest=access_guest,
**kwargs)
item_obj.id = generate_id_for(item_obj)
item_obj.is_dynamic = True
item_obj.dynamic_children = []
cleaned_permissions = []
if access_by_perms:
# Make permissions a list if currently a single object
if not isinstance(access_by_perms, list):
access_by_perms = [access_by_perms]
for perm in access_by_perms:
if isinstance(perm, six.string_types):
# Get permission object from string
try:
app, codename = perm.split('.')
except ValueError:
raise ValueError(
'Wrong permission string format: supplied - `%s`; '
'expected - `<app_name>.<permission_name>`.' % perm)
try:
perm = Permission.objects.get(codename=codename, content_type__app_label=app)
except Permission.DoesNotExist:
raise ValueError('Permission `%s.%s` does not exist.' % (app, codename))
elif not isinstance(perm, (int, Permission)):
raise ValueError('Permissions must be given as strings, ints, or `Permission` instances.')
cleaned_permissions.append(perm)
item_obj.permissions = cleaned_permissions or []
item_obj.access_perm_type = item_obj.PERM_TYPE_ALL if perms_mode_all else item_obj.PERM_TYPE_ANY
if item_obj.permissions:
item_obj.access_restricted = True
if children is not None:
for child in children:
child.parent = item_obj
item_obj.dynamic_children.append(child)
return item_obj
|
Imports sitetree module from a given app.
|
def import_app_sitetree_module(app):
"""Imports sitetree module from a given app.
:param str|unicode app: Application name
:return: module|None
"""
module_name = settings.APP_MODULE_NAME
module = import_module(app)
try:
sub_module = import_module('%s.%s' % (app, module_name))
return sub_module
except ImportError:
if module_has_submodule(module, module_name):
raise
return None
|
Imports sitetrees modules from packages ( apps ). Returns a list of submodules.
|
def import_project_sitetree_modules():
"""Imports sitetrees modules from packages (apps).
Returns a list of submodules.
:rtype: list
"""
from django.conf import settings as django_settings
submodules = []
for app in django_settings.INSTALLED_APPS:
module = import_app_sitetree_module(app)
if module is not None:
submodules.append(module)
return submodules
|
Returns tuple with application and tree [ item ] model class names.
|
def get_app_n_model(settings_entry_name):
"""Returns tuple with application and tree[item] model class names.
:param str|unicode settings_entry_name:
:rtype: tuple
"""
try:
app_name, model_name = getattr(settings, settings_entry_name).split('.')
except ValueError:
raise ImproperlyConfigured(
'`SITETREE_%s` must have the following format: `app_name.model_name`.' % settings_entry_name)
return app_name, model_name
|
Returns a certain sitetree model as defined in the project settings.
|
def get_model_class(settings_entry_name):
"""Returns a certain sitetree model as defined in the project settings.
:param str|unicode settings_entry_name:
:rtype: TreeItemBase|TreeBase
"""
app_name, model_name = get_app_n_model(settings_entry_name)
try:
model = apps_get_model(app_name, model_name)
except (LookupError, ValueError):
model = None
if model is None:
raise ImproperlyConfigured(
'`SITETREE_%s` refers to model `%s` that has not been installed.' % (settings_entry_name, model_name))
return model
|
Called by the ASGI instance to send a message.
|
async def asgi_send(self, message: dict) -> None:
"""Called by the ASGI instance to send a message."""
if message["type"] == "http.response.start" and self.state == ASGIHTTPState.REQUEST:
self.response = message
elif message["type"] == "http.response.body" and self.state in {
ASGIHTTPState.REQUEST,
ASGIHTTPState.RESPONSE,
}:
if self.state == ASGIHTTPState.REQUEST:
headers = build_and_validate_headers(self.response["headers"])
headers.extend(self.response_headers())
await self.asend(
h11.Response(status_code=int(self.response["status"]), headers=headers)
)
self.state = ASGIHTTPState.RESPONSE
if (
not suppress_body(self.scope["method"], int(self.response["status"]))
and message.get("body", b"") != b""
):
await self.asend(h11.Data(data=bytes(message["body"])))
if not message.get("more_body", False):
if self.state != ASGIHTTPState.CLOSED:
await self.asend(h11.EndOfMessage())
await self.asgi_put({"type": "http.disconnect"})
self.state = ASGIHTTPState.CLOSED
else:
raise UnexpectedMessage(self.state, message["type"])
|
Called by the ASGI instance to send a message.
|
async def asgi_send(self, message: dict) -> None:
"""Called by the ASGI instance to send a message."""
if message["type"] == "websocket.accept" and self.state == ASGIWebsocketState.HANDSHAKE:
headers = build_and_validate_headers(message.get("headers", []))
raise_if_subprotocol_present(headers)
headers.extend(self.response_headers())
await self.asend(
AcceptConnection(
extensions=[PerMessageDeflate()],
extra_headers=headers,
subprotocol=message.get("subprotocol"),
)
)
self.state = ASGIWebsocketState.CONNECTED
self.config.access_logger.access(
self.scope, {"status": 101, "headers": []}, time() - self.start_time
)
elif (
message["type"] == "websocket.http.response.start"
and self.state == ASGIWebsocketState.HANDSHAKE
):
self.response = message
self.config.access_logger.access(self.scope, self.response, time() - self.start_time)
elif message["type"] == "websocket.http.response.body" and self.state in {
ASGIWebsocketState.HANDSHAKE,
ASGIWebsocketState.RESPONSE,
}:
await self._asgi_send_rejection(message)
elif message["type"] == "websocket.send" and self.state == ASGIWebsocketState.CONNECTED:
data: Union[bytes, str]
if message.get("bytes") is not None:
await self.asend(BytesMessage(data=bytes(message["bytes"])))
elif not isinstance(message["text"], str):
raise TypeError(f"{message['text']} should be a str")
else:
await self.asend(TextMessage(data=message["text"]))
elif message["type"] == "websocket.close" and self.state == ASGIWebsocketState.HANDSHAKE:
await self.send_http_error(403)
self.state = ASGIWebsocketState.HTTPCLOSED
elif message["type"] == "websocket.close":
await self.asend(CloseConnection(code=int(message["code"])))
self.state = ASGIWebsocketState.CLOSED
else:
raise UnexpectedMessage(self.state, message["type"])
|
Serve an ASGI framework app given the config.
|
async def serve(app: ASGIFramework, config: Config) -> None:
"""Serve an ASGI framework app given the config.
This allows for a programmatic way to serve an ASGI framework, it
can be used via,
.. code-block:: python
asyncio.run(serve(app, config))
It is assumed that the event-loop is configured before calling
this function, therefore configuration values that relate to loop
setup or process setup are ignored.
"""
if config.debug:
warnings.warn("The config `debug` has no affect when using serve", Warning)
if config.workers != 1:
warnings.warn("The config `workers` has no affect when using serve", Warning)
if config.worker_class != "asyncio":
warnings.warn("The config `worker_class` has no affect when using serve", Warning)
await worker_serve(app, config)
|
Serve an ASGI framework app given the config.
|
async def serve(
app: ASGIFramework,
config: Config,
*,
task_status: trio._core._run._TaskStatus = trio.TASK_STATUS_IGNORED,
) -> None:
"""Serve an ASGI framework app given the config.
This allows for a programmatic way to serve an ASGI framework, it
can be used via,
.. code-block:: python
trio.run(partial(serve, app, config))
It is assumed that the event-loop is configured before calling
this function, therefore configuration values that relate to loop
setup or process setup are ignored.
"""
if config.debug:
warnings.warn("The config `debug` has no affect when using serve", Warning)
if config.workers != 1:
warnings.warn("The config `workers` has no affect when using serve", Warning)
if config.worker_class != "asyncio":
warnings.warn("The config `worker_class` has no affect when using serve", Warning)
await worker_serve(app, config, task_status=task_status)
|
Create a configuration from a mapping.
|
def from_mapping(
cls: Type["Config"], mapping: Optional[Mapping[str, Any]] = None, **kwargs: Any
) -> "Config":
"""Create a configuration from a mapping.
This allows either a mapping to be directly passed or as
keyword arguments, for example,
.. code-block:: python
config = {'keep_alive_timeout': 10}
Config.from_mapping(config)
Config.form_mapping(keep_alive_timeout=10)
Arguments:
mapping: Optionally a mapping object.
kwargs: Optionally a collection of keyword arguments to
form a mapping.
"""
mappings: Dict[str, Any] = {}
if mapping is not None:
mappings.update(mapping)
mappings.update(kwargs)
config = cls()
for key, value in mappings.items():
try:
setattr(config, key, value)
except AttributeError:
pass
return config
|
Create a configuration from a Python file.
|
def from_pyfile(cls: Type["Config"], filename: FilePath) -> "Config":
"""Create a configuration from a Python file.
.. code-block:: python
Config.from_pyfile('hypercorn_config.py')
Arguments:
filename: The filename which gives the path to the file.
"""
file_path = os.fspath(filename)
spec = importlib.util.spec_from_file_location("module.name", file_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module) # type: ignore
return cls.from_object(module)
|
Load the configuration values from a TOML formatted file.
|
def from_toml(cls: Type["Config"], filename: FilePath) -> "Config":
"""Load the configuration values from a TOML formatted file.
This allows configuration to be loaded as so
.. code-block:: python
Config.from_toml('config.toml')
Arguments:
filename: The filename which gives the path to the file.
"""
file_path = os.fspath(filename)
with open(file_path) as file_:
data = toml.load(file_)
return cls.from_mapping(data)
|
Create a configuration from a Python object.
|
def from_object(cls: Type["Config"], instance: Union[object, str]) -> "Config":
"""Create a configuration from a Python object.
This can be used to reference modules or objects within
modules for example,
.. code-block:: python
Config.from_object('module')
Config.from_object('module.instance')
from module import instance
Config.from_object(instance)
are valid.
Arguments:
instance: Either a str referencing a python object or the
object itself.
"""
if isinstance(instance, str):
try:
path, config = instance.rsplit(".", 1)
except ValueError:
path = instance
instance = importlib.import_module(instance)
else:
module = importlib.import_module(path)
instance = getattr(module, config)
mapping = {
key: getattr(instance, key)
for key in dir(instance)
if not isinstance(getattr(instance, key), types.ModuleType)
}
return cls.from_mapping(mapping)
|
Main function to log all the annotations stored during the entire request. This is done if the request is sampled and the response was a success. It also logs the service ( ss and sr ) or the client ( cs and cr ) annotations.
|
def emit_spans(self):
"""Main function to log all the annotations stored during the entire
request. This is done if the request is sampled and the response was
a success. It also logs the service (`ss` and `sr`) or the client
('cs' and 'cr') annotations.
"""
# FIXME: Should have a single aggregate handler
if self.firehose_handler:
# FIXME: We need to allow different batching settings per handler
self._emit_spans_with_span_sender(
ZipkinBatchSender(self.firehose_handler,
self.max_span_batch_size,
self.encoder)
)
if not self.zipkin_attrs.is_sampled:
self._get_tracer().clear()
return
span_sender = ZipkinBatchSender(self.transport_handler,
self.max_span_batch_size,
self.encoder)
self._emit_spans_with_span_sender(span_sender)
self._get_tracer().clear()
|
Creates a set of zipkin attributes for a span.
|
def create_attrs_for_span(
sample_rate=100.0,
trace_id=None,
span_id=None,
use_128bit_trace_id=False,
):
"""Creates a set of zipkin attributes for a span.
:param sample_rate: Float between 0.0 and 100.0 to determine sampling rate
:type sample_rate: float
:param trace_id: Optional 16-character hex string representing a trace_id.
If this is None, a random trace_id will be generated.
:type trace_id: str
:param span_id: Optional 16-character hex string representing a span_id.
If this is None, a random span_id will be generated.
:type span_id: str
:param use_128bit_trace_id: If true, generate 128-bit trace_ids
:type use_128bit_trace_id: boolean
"""
# Calculate if this trace is sampled based on the sample rate
if trace_id is None:
if use_128bit_trace_id:
trace_id = generate_random_128bit_string()
else:
trace_id = generate_random_64bit_string()
if span_id is None:
span_id = generate_random_64bit_string()
if sample_rate == 0.0:
is_sampled = False
else:
is_sampled = (random.random() * 100) < sample_rate
return ZipkinAttrs(
trace_id=trace_id,
span_id=span_id,
parent_span_id=None,
flags='0',
is_sampled=is_sampled,
)
|
Generate the headers for a new zipkin span.
|
def create_http_headers_for_new_span(context_stack=None, tracer=None):
"""
Generate the headers for a new zipkin span.
.. note::
If the method is not called from within a zipkin_trace context,
empty dict will be returned back.
:returns: dict containing (X-B3-TraceId, X-B3-SpanId, X-B3-ParentSpanId,
X-B3-Flags and X-B3-Sampled) keys OR an empty dict.
"""
if tracer:
zipkin_attrs = tracer.get_zipkin_attrs()
elif context_stack:
zipkin_attrs = context_stack.get()
else:
zipkin_attrs = get_default_tracer().get_zipkin_attrs()
if not zipkin_attrs:
return {}
return {
'X-B3-TraceId': zipkin_attrs.trace_id,
'X-B3-SpanId': generate_random_64bit_string(),
'X-B3-ParentSpanId': zipkin_attrs.span_id,
'X-B3-Flags': '0',
'X-B3-Sampled': '1' if zipkin_attrs.is_sampled else '0',
}
|
Returns the current ZipkinAttrs and generates new ones if needed.
|
def _get_current_context(self):
"""Returns the current ZipkinAttrs and generates new ones if needed.
:returns: (report_root_timestamp, zipkin_attrs)
:rtype: (bool, ZipkinAttrs)
"""
# This check is technically not necessary since only root spans will have
# sample_rate, zipkin_attrs or a transport set. But it helps making the
# code clearer by separating the logic for a root span from the one for a
# child span.
if self._is_local_root_span:
# If sample_rate is set, we need to (re)generate a trace context.
# If zipkin_attrs (trace context) were passed in as argument there are
# 2 possibilities:
# is_sampled = False --> we keep the same trace_id but re-roll the dice
# for is_sampled.
# is_sampled = True --> we don't want to stop sampling halfway through
# a sampled trace, so we do nothing.
# If no zipkin_attrs were passed in, we generate new ones and start a
# new trace.
if self.sample_rate is not None:
# If this trace is not sampled, we re-roll the dice.
if self.zipkin_attrs_override and \
not self.zipkin_attrs_override.is_sampled:
# This will be the root span of the trace, so we should
# set timestamp and duration.
return True, create_attrs_for_span(
sample_rate=self.sample_rate,
trace_id=self.zipkin_attrs_override.trace_id,
)
# If zipkin_attrs_override was not passed in, we simply generate
# new zipkin_attrs to start a new trace.
elif not self.zipkin_attrs_override:
return True, create_attrs_for_span(
sample_rate=self.sample_rate,
use_128bit_trace_id=self.use_128bit_trace_id,
)
if self.firehose_handler and not self.zipkin_attrs_override:
# If it has gotten here, the only thing that is
# causing a trace is the firehose. So we force a trace
# with sample rate of 0
return True, create_attrs_for_span(
sample_rate=0.0,
use_128bit_trace_id=self.use_128bit_trace_id,
)
# If we arrive here it means the sample_rate was not set while
# zipkin_attrs_override was, so let's simply return that.
return False, self.zipkin_attrs_override
else:
# Check if there's already a trace context in _context_stack.
existing_zipkin_attrs = self.get_tracer().get_zipkin_attrs()
# If there's an existing context, let's create new zipkin_attrs
# with that context as parent.
if existing_zipkin_attrs:
return False, ZipkinAttrs(
trace_id=existing_zipkin_attrs.trace_id,
span_id=generate_random_64bit_string(),
parent_span_id=existing_zipkin_attrs.span_id,
flags=existing_zipkin_attrs.flags,
is_sampled=existing_zipkin_attrs.is_sampled,
)
return False, None
|
Enter the new span context. All annotations logged inside this context will be attributed to this span. All new spans generated inside this context will have this span as their parent.
|
def start(self):
"""Enter the new span context. All annotations logged inside this
context will be attributed to this span. All new spans generated
inside this context will have this span as their parent.
In the unsampled case, this context still generates new span IDs and
pushes them onto the threadlocal stack, so downstream services calls
made will pass the correct headers. However, the logging handler is
never attached in the unsampled case, so the spans are never logged.
"""
self.do_pop_attrs = False
report_root_timestamp, self.zipkin_attrs = self._get_current_context()
# If zipkin_attrs are not set up by now, that means this span is not
# configured to perform logging itself, and it's not in an existing
# Zipkin trace. That means there's nothing else to do and it can exit
# early.
if not self.zipkin_attrs:
return self
self.get_tracer().push_zipkin_attrs(self.zipkin_attrs)
self.do_pop_attrs = True
self.start_timestamp = time.time()
if self._is_local_root_span:
# Don't set up any logging if we're not sampling
if not self.zipkin_attrs.is_sampled and not self.firehose_handler:
return self
# If transport is already configured don't override it. Doing so would
# cause all previously recorded spans to never be emitted as exiting
# the inner logging context will reset transport_configured to False.
if self.get_tracer().is_transport_configured():
log.info('Transport was already configured, ignoring override'
'from span {}'.format(self.span_name))
return self
endpoint = create_endpoint(self.port, self.service_name, self.host)
self.logging_context = ZipkinLoggingContext(
self.zipkin_attrs,
endpoint,
self.span_name,
self.transport_handler,
report_root_timestamp or self.report_root_timestamp_override,
self.get_tracer,
self.service_name,
binary_annotations=self.binary_annotations,
add_logging_annotation=self.add_logging_annotation,
client_context=self.kind == Kind.CLIENT,
max_span_batch_size=self.max_span_batch_size,
firehose_handler=self.firehose_handler,
encoding=self.encoding,
)
self.logging_context.start()
self.get_tracer().set_transport_configured(configured=True)
return self
|
Exit the span context. Zipkin attrs are pushed onto the threadlocal stack regardless of sampling so they always need to be popped off. The actual logging of spans depends on sampling and that the logging was correctly set up.
|
def stop(self, _exc_type=None, _exc_value=None, _exc_traceback=None):
"""Exit the span context. Zipkin attrs are pushed onto the
threadlocal stack regardless of sampling, so they always need to be
popped off. The actual logging of spans depends on sampling and that
the logging was correctly set up.
"""
if self.do_pop_attrs:
self.get_tracer().pop_zipkin_attrs()
# If no transport is configured, there's no reason to create a new Span.
# This also helps avoiding memory leaks since without a transport nothing
# would pull spans out of get_tracer().
if not self.get_tracer().is_transport_configured():
return
# Add the error annotation if an exception occurred
if any((_exc_type, _exc_value, _exc_traceback)):
error_msg = u'{0}: {1}'.format(_exc_type.__name__, _exc_value)
self.update_binary_annotations({
ERROR_KEY: error_msg,
})
# Logging context is only initialized for "root" spans of the local
# process (i.e. this zipkin_span not inside of any other local
# zipkin_spans)
if self.logging_context:
try:
self.logging_context.stop()
except Exception as ex:
err_msg = 'Error emitting zipkin trace. {}'.format(
repr(ex),
)
log.error(err_msg)
finally:
self.logging_context = None
self.get_tracer().clear()
self.get_tracer().set_transport_configured(configured=False)
return
# If we've gotten here, that means that this span is a child span of
# this context's root span (i.e. it's a zipkin_span inside another
# zipkin_span).
end_timestamp = time.time()
# If self.duration is set, it means the user wants to override it
if self.duration:
duration = self.duration
else:
duration = end_timestamp - self.start_timestamp
endpoint = create_endpoint(self.port, self.service_name, self.host)
self.get_tracer().add_span(Span(
trace_id=self.zipkin_attrs.trace_id,
name=self.span_name,
parent_id=self.zipkin_attrs.parent_span_id,
span_id=self.zipkin_attrs.span_id,
kind=self.kind,
timestamp=self.timestamp if self.timestamp else self.start_timestamp,
duration=duration,
annotations=self.annotations,
local_endpoint=endpoint,
remote_endpoint=self.remote_endpoint,
tags=self.binary_annotations,
))
|
Updates the binary annotations for the current span.
|
def update_binary_annotations(self, extra_annotations):
"""Updates the binary annotations for the current span."""
if not self.logging_context:
# This is not the root span, so binary annotations will be added
# to the log handler when this span context exits.
self.binary_annotations.update(extra_annotations)
else:
# Otherwise, we're in the context of the root span, so just update
# the binary annotations for the logging context directly.
self.logging_context.tags.update(extra_annotations)
|
Adds a sa binary annotation to the current span.
|
def add_sa_binary_annotation(
self,
port=0,
service_name='unknown',
host='127.0.0.1',
):
"""Adds a 'sa' binary annotation to the current span.
'sa' binary annotations are useful for situations where you need to log
where a request is going but the destination doesn't support zipkin.
Note that the span must have 'cs'/'cr' annotations.
:param port: The port number of the destination
:type port: int
:param service_name: The name of the destination service
:type service_name: str
:param host: Host address of the destination
:type host: str
"""
if self.kind != Kind.CLIENT:
# TODO: trying to set a sa binary annotation for a non-client span
# should result in a logged error
return
remote_endpoint = create_endpoint(
port=port,
service_name=service_name,
host=host,
)
if not self.logging_context:
if self.remote_endpoint is not None:
raise ValueError('SA annotation already set.')
self.remote_endpoint = remote_endpoint
else:
if self.logging_context.remote_endpoint is not None:
raise ValueError('SA annotation already set.')
self.logging_context.remote_endpoint = remote_endpoint
|
Overrides the current span name.
|
def override_span_name(self, name):
"""Overrides the current span name.
This is useful if you don't know the span name yet when you create the
zipkin_span object. i.e. pyramid_zipkin doesn't know which route the
request matched until the function wrapped by the context manager
completes.
:param name: New span name
:type name: str
"""
self.span_name = name
if self.logging_context:
self.logging_context.span_name = name
|
Creates a new Endpoint object.
|
def create_endpoint(port=None, service_name=None, host=None, use_defaults=True):
"""Creates a new Endpoint object.
:param port: TCP/UDP port. Defaults to 0.
:type port: int
:param service_name: service name as a str. Defaults to 'unknown'.
:type service_name: str
:param host: ipv4 or ipv6 address of the host. Defaults to the
current host ip.
:type host: str
:param use_defaults: whether to use defaults.
:type use_defaults: bool
:returns: zipkin Endpoint object
"""
if use_defaults:
if port is None:
port = 0
if service_name is None:
service_name = 'unknown'
if host is None:
try:
host = socket.gethostbyname(socket.gethostname())
except socket.gaierror:
host = '127.0.0.1'
ipv4 = None
ipv6 = None
if host:
# Check ipv4 or ipv6.
try:
socket.inet_pton(socket.AF_INET, host)
ipv4 = host
except socket.error:
# If it's not an ipv4 address, maybe it's ipv6.
try:
socket.inet_pton(socket.AF_INET6, host)
ipv6 = host
except socket.error:
# If it's neither ipv4 or ipv6, leave both ip addresses unset.
pass
return Endpoint(
ipv4=ipv4,
ipv6=ipv6,
port=port,
service_name=service_name,
)
|
Creates a copy of a given endpoint with a new service name.
|
def copy_endpoint_with_new_service_name(endpoint, new_service_name):
"""Creates a copy of a given endpoint with a new service name.
:param endpoint: existing Endpoint object
:type endpoint: Endpoint
:param new_service_name: new service name
:type new_service_name: str
:returns: zipkin new Endpoint object
"""
return Endpoint(
service_name=new_service_name,
ipv4=endpoint.ipv4,
ipv6=endpoint.ipv6,
port=endpoint.port,
)
|
Builds and returns a V1 Span.
|
def build_v1_span(self):
"""Builds and returns a V1 Span.
:return: newly generated _V1Span
:rtype: _V1Span
"""
# We are simulating a full two-part span locally, so set cs=sr and ss=cr
full_annotations = OrderedDict([
('cs', self.timestamp),
('sr', self.timestamp),
('ss', self.timestamp + self.duration),
('cr', self.timestamp + self.duration),
])
if self.kind != Kind.LOCAL:
# If kind is not LOCAL, then we only want client or
# server side annotations.
for ann in _DROP_ANNOTATIONS_BY_KIND[self.kind]:
del full_annotations[ann]
# Add user-defined annotations. We write them in full_annotations
# instead of the opposite so that user annotations will override
# any automatically generated annotation.
full_annotations.update(self.annotations)
return _V1Span(
trace_id=self.trace_id,
name=self.name,
parent_id=self.parent_id,
id=self.span_id,
timestamp=self.timestamp if self.shared is False else None,
duration=self.duration if self.shared is False else None,
endpoint=self.local_endpoint,
annotations=full_annotations,
binary_annotations=self.tags,
remote_endpoint=self.remote_endpoint,
)
|
Encode list of protobuf Spans to binary.
|
def encode_pb_list(pb_spans):
"""Encode list of protobuf Spans to binary.
:param pb_spans: list of protobuf Spans.
:type pb_spans: list of zipkin_pb2.Span
:return: encoded list.
:rtype: bytes
"""
pb_list = zipkin_pb2.ListOfSpans()
pb_list.spans.extend(pb_spans)
return pb_list.SerializeToString()
|
Converts a py_zipkin Span in a protobuf Span.
|
def create_protobuf_span(span):
"""Converts a py_zipkin Span in a protobuf Span.
:param span: py_zipkin Span to convert.
:type span: py_zipkin.encoding.Span
:return: protobuf's Span
:rtype: zipkin_pb2.Span
"""
# Protobuf's composite types (i.e. Span's local_endpoint) are immutable.
# So we can't create a zipkin_pb2.Span here and then set the appropriate
# fields since `pb_span.local_endpoint = zipkin_pb2.Endpoint` fails.
# Instead we just create the kwargs and pass them in to the Span constructor.
pb_kwargs = {}
pb_kwargs['trace_id'] = _hex_to_bytes(span.trace_id)
if span.parent_id:
pb_kwargs['parent_id'] = _hex_to_bytes(span.parent_id)
pb_kwargs['id'] = _hex_to_bytes(span.span_id)
pb_kind = _get_protobuf_kind(span.kind)
if pb_kind:
pb_kwargs['kind'] = pb_kind
if span.name:
pb_kwargs['name'] = span.name
if span.timestamp:
pb_kwargs['timestamp'] = int(span.timestamp * 1000 * 1000)
if span.duration:
pb_kwargs['duration'] = int(span.duration * 1000 * 1000)
if span.local_endpoint:
pb_kwargs['local_endpoint'] = _convert_endpoint(span.local_endpoint)
if span.remote_endpoint:
pb_kwargs['remote_endpoint'] = _convert_endpoint(span.remote_endpoint)
if len(span.annotations) > 0:
pb_kwargs['annotations'] = _convert_annotations(span.annotations)
if len(span.tags) > 0:
pb_kwargs['tags'] = span.tags
if span.debug:
pb_kwargs['debug'] = span.debug
if span.shared:
pb_kwargs['shared'] = span.shared
return zipkin_pb2.Span(**pb_kwargs)
|
Encodes to hexadecimal ids to big - endian binary.
|
def _hex_to_bytes(hex_id):
"""Encodes to hexadecimal ids to big-endian binary.
:param hex_id: hexadecimal id to encode.
:type hex_id: str
:return: binary representation.
:type: bytes
"""
if len(hex_id) <= 16:
int_id = unsigned_hex_to_signed_int(hex_id)
return struct.pack('>q', int_id)
else:
# There's no 16-bytes encoding in Python's struct. So we convert the
# id as 2 64 bit ids and then concatenate the result.
# NOTE: we count 16 chars from the right (:-16) rather than the left so
# that ids with less than 32 chars will be correctly pre-padded with 0s.
high_id = unsigned_hex_to_signed_int(hex_id[:-16])
high_bin = struct.pack('>q', high_id)
low_id = unsigned_hex_to_signed_int(hex_id[-16:])
low_bin = struct.pack('>q', low_id)
return high_bin + low_bin
|
Converts py_zipkin s Kind to Protobuf s Kind.
|
def _get_protobuf_kind(kind):
"""Converts py_zipkin's Kind to Protobuf's Kind.
:param kind: py_zipkin's Kind.
:type kind: py_zipkin.Kind
:return: correcponding protobuf's kind value.
:rtype: zipkin_pb2.Span.Kind
"""
if kind == Kind.CLIENT:
return zipkin_pb2.Span.CLIENT
elif kind == Kind.SERVER:
return zipkin_pb2.Span.SERVER
elif kind == Kind.PRODUCER:
return zipkin_pb2.Span.PRODUCER
elif kind == Kind.CONSUMER:
return zipkin_pb2.Span.CONSUMER
return None
|
Converts py_zipkin s Endpoint to Protobuf s Endpoint.
|
def _convert_endpoint(endpoint):
"""Converts py_zipkin's Endpoint to Protobuf's Endpoint.
:param endpoint: py_zipkins' endpoint to convert.
:type endpoint: py_zipkin.encoding.Endpoint
:return: corresponding protobuf's endpoint.
:rtype: zipkin_pb2.Endpoint
"""
pb_endpoint = zipkin_pb2.Endpoint()
if endpoint.service_name:
pb_endpoint.service_name = endpoint.service_name
if endpoint.port and endpoint.port != 0:
pb_endpoint.port = endpoint.port
if endpoint.ipv4:
pb_endpoint.ipv4 = socket.inet_pton(socket.AF_INET, endpoint.ipv4)
if endpoint.ipv6:
pb_endpoint.ipv6 = socket.inet_pton(socket.AF_INET6, endpoint.ipv6)
return pb_endpoint
|
Converts py_zipkin s annotations dict to protobuf.
|
def _convert_annotations(annotations):
"""Converts py_zipkin's annotations dict to protobuf.
:param annotations: annotations dict.
:type annotations: dict
:return: corresponding protobuf's list of annotations.
:rtype: list
"""
pb_annotations = []
for value, ts in annotations.items():
pb_annotations.append(zipkin_pb2.Annotation(
timestamp=int(ts * 1000 * 1000),
value=value,
))
return pb_annotations
|
Create a zipkin annotation object
|
def create_annotation(timestamp, value, host):
"""
Create a zipkin annotation object
:param timestamp: timestamp of when the annotation occured in microseconds
:param value: name of the annotation, such as 'sr'
:param host: zipkin endpoint object
:returns: zipkin annotation object
"""
return zipkin_core.Annotation(timestamp=timestamp, value=value, host=host)
|
Create a zipkin binary annotation object
|
def create_binary_annotation(key, value, annotation_type, host):
"""
Create a zipkin binary annotation object
:param key: name of the annotation, such as 'http.uri'
:param value: value of the annotation, such as a URI
:param annotation_type: type of annotation, such as AnnotationType.I32
:param host: zipkin endpoint object
:returns: zipkin binary annotation object
"""
return zipkin_core.BinaryAnnotation(
key=key,
value=value,
annotation_type=annotation_type,
host=host,
)
|
Create a zipkin Endpoint object.
|
def create_endpoint(port=0, service_name='unknown', ipv4=None, ipv6=None):
"""Create a zipkin Endpoint object.
An Endpoint object holds information about the network context of a span.
:param port: int value of the port. Defaults to 0
:param service_name: service name as a str. Defaults to 'unknown'
:param ipv4: ipv4 host address
:param ipv6: ipv6 host address
:returns: thrift Endpoint object
"""
ipv4_int = 0
ipv6_binary = None
# Convert ip address to network byte order
if ipv4:
ipv4_int = struct.unpack('!i', socket.inet_pton(socket.AF_INET, ipv4))[0]
if ipv6:
ipv6_binary = socket.inet_pton(socket.AF_INET6, ipv6)
# Zipkin passes unsigned values in signed types because Thrift has no
# unsigned types, so we have to convert the value.
port = struct.unpack('h', struct.pack('H', port))[0]
return zipkin_core.Endpoint(
ipv4=ipv4_int,
ipv6=ipv6_binary,
port=port,
service_name=service_name,
)
|
Copies a copy of a given endpoint with a new service name. This should be very fast on the order of several microseconds.
|
def copy_endpoint_with_new_service_name(endpoint, service_name):
"""Copies a copy of a given endpoint with a new service name.
This should be very fast, on the order of several microseconds.
:param endpoint: existing zipkin_core.Endpoint object
:param service_name: str of new service name
:returns: zipkin Endpoint object
"""
return zipkin_core.Endpoint(
ipv4=endpoint.ipv4,
port=endpoint.port,
service_name=service_name,
)
|
Reformat annotations dict to return list of corresponding zipkin_core objects.
|
def annotation_list_builder(annotations, host):
"""
Reformat annotations dict to return list of corresponding zipkin_core objects.
:param annotations: dict containing key as annotation name,
value being timestamp in seconds(float).
:type host: :class:`zipkin_core.Endpoint`
:returns: a list of annotation zipkin_core objects
:rtype: list
"""
return [
create_annotation(int(timestamp * 1000000), key, host)
for key, timestamp in annotations.items()
]
|
Reformat binary annotations dict to return list of zipkin_core objects. The value of the binary annotations MUST be in string format.
|
def binary_annotation_list_builder(binary_annotations, host):
"""
Reformat binary annotations dict to return list of zipkin_core objects. The
value of the binary annotations MUST be in string format.
:param binary_annotations: dict with key, value being the name and value
of the binary annotation being logged.
:type host: :class:`zipkin_core.Endpoint`
:returns: a list of binary annotation zipkin_core objects
:rtype: list
"""
# TODO: Remove the type hard-coding of STRING to take it as a param option.
ann_type = zipkin_core.AnnotationType.STRING
return [
create_binary_annotation(key, str(value), ann_type, host)
for key, value in binary_annotations.items()
]
|
Takes a bunch of span attributes and returns a thriftpy2 representation of the span. Timestamps passed in are in seconds they re converted to microseconds before thrift encoding.
|
def create_span(
span_id,
parent_span_id,
trace_id,
span_name,
annotations,
binary_annotations,
timestamp_s,
duration_s,
):
"""Takes a bunch of span attributes and returns a thriftpy2 representation
of the span. Timestamps passed in are in seconds, they're converted to
microseconds before thrift encoding.
"""
# Check if trace_id is 128-bit. If so, record trace_id_high separately.
trace_id_length = len(trace_id)
trace_id_high = None
if trace_id_length > 16:
assert trace_id_length == 32
trace_id, trace_id_high = trace_id[16:], trace_id[:16]
if trace_id_high:
trace_id_high = unsigned_hex_to_signed_int(trace_id_high)
span_dict = {
'trace_id': unsigned_hex_to_signed_int(trace_id),
'name': span_name,
'id': unsigned_hex_to_signed_int(span_id),
'annotations': annotations,
'binary_annotations': binary_annotations,
'timestamp': int(timestamp_s * 1000000) if timestamp_s else None,
'duration': int(duration_s * 1000000) if duration_s else None,
'trace_id_high': trace_id_high,
}
if parent_span_id:
span_dict['parent_id'] = unsigned_hex_to_signed_int(parent_span_id)
return zipkin_core.Span(**span_dict)
|
Returns a TBinaryProtocol encoded Thrift span.
|
def span_to_bytes(thrift_span):
"""
Returns a TBinaryProtocol encoded Thrift span.
:param thrift_span: thrift object to encode.
:returns: thrift object in TBinaryProtocol format bytes.
"""
transport = TMemoryBuffer()
protocol = TBinaryProtocol(transport)
thrift_span.write(protocol)
return bytes(transport.getvalue())
|
Returns a TBinaryProtocol encoded list of Thrift objects.
|
def encode_bytes_list(binary_thrift_obj_list): # pragma: no cover
"""
Returns a TBinaryProtocol encoded list of Thrift objects.
:param binary_thrift_obj_list: list of TBinaryProtocol objects to encode.
:returns: bynary object representing the encoded list.
"""
transport = TMemoryBuffer()
write_list_begin(transport, TType.STRUCT, len(binary_thrift_obj_list))
for thrift_bin in binary_thrift_obj_list:
transport.write(thrift_bin)
return bytes(transport.getvalue())
|
Returns the span type and encoding for the message provided.
|
def detect_span_version_and_encoding(message):
"""Returns the span type and encoding for the message provided.
The logic in this function is a Python port of
https://github.com/openzipkin/zipkin/blob/master/zipkin/src/main/java/zipkin/internal/DetectingSpanDecoder.java
:param message: span to perform operations on.
:type message: byte array
:returns: span encoding.
:rtype: Encoding
"""
# In case message is sent in as non-bytearray format,
# safeguard convert to bytearray before handling
if isinstance(message, six.string_types):
# Even six.b is not enough to handle the py2/3 difference since
# it uses latin-1 as default encoding and not utf-8.
if six.PY2:
message = six.b(message) # pragma: no cover
else:
message = message.encode('utf-8') # pragma: no cover
if len(message) < 2:
raise ZipkinError("Invalid span format. Message too short.")
# Check for binary format
if six.byte2int(message) <= 16:
if six.byte2int(message) == 10 and six.byte2int(message[1:2]) != 0:
return Encoding.V2_PROTO3
return Encoding.V1_THRIFT
str_msg = message.decode('utf-8')
# JSON case for list of spans
if str_msg[0] == '[':
span_list = json.loads(str_msg)
if len(span_list) > 0:
# Assumption: All spans in a list are the same version
# Logic: Search for identifying fields in all spans, if any span can
# be strictly identified to a version, return that version.
# Otherwise, if no spans could be strictly identified, default to V2.
for span in span_list:
if any(word in span for word in _V2_ATTRIBUTES):
return Encoding.V2_JSON
elif (
'binaryAnnotations' in span or
(
'annotations' in span and
'endpoint' in span['annotations']
)
):
return Encoding.V1_JSON
return Encoding.V2_JSON
raise ZipkinError("Unknown or unsupported span encoding")
|
Converts encoded spans to a different encoding.
|
def convert_spans(spans, output_encoding, input_encoding=None):
"""Converts encoded spans to a different encoding.
param spans: encoded input spans.
type spans: byte array
param output_encoding: desired output encoding.
type output_encoding: Encoding
param input_encoding: optional input encoding. If this is not specified, it'll
try to understand the encoding automatically by inspecting the input spans.
type input_encoding: Encoding
:returns: encoded spans.
:rtype: byte array
"""
if not isinstance(input_encoding, Encoding):
input_encoding = detect_span_version_and_encoding(message=spans)
if input_encoding == output_encoding:
return spans
decoder = get_decoder(input_encoding)
encoder = get_encoder(output_encoding)
decoded_spans = decoder.decode_spans(spans)
output_spans = []
# Encode each indivicual span
for span in decoded_spans:
output_spans.append(encoder.encode_span(span))
# Outputs from encoder.encode_span() can be easily concatenated in a list
return encoder.encode_queue(output_spans)
|
Stores the zipkin attributes to thread local.
|
def push_zipkin_attrs(zipkin_attr):
"""Stores the zipkin attributes to thread local.
.. deprecated::
Use the Tracer interface which offers better multi-threading support.
push_zipkin_attrs will be removed in version 1.0.
:param zipkin_attr: tuple containing zipkin related attrs
:type zipkin_attr: :class:`zipkin.ZipkinAttrs`
"""
from py_zipkin.storage import ThreadLocalStack
log.warning('push_zipkin_attrs is deprecated. See DEPRECATIONS.rst for'
'details on how to migrate to using Tracer.')
return ThreadLocalStack().push(zipkin_attr)
|
Returns a 128 bit UTF - 8 encoded string. Follows the same conventions as generate_random_64bit_string ().
|
def generate_random_128bit_string():
"""Returns a 128 bit UTF-8 encoded string. Follows the same conventions
as generate_random_64bit_string().
The upper 32 bits are the current time in epoch seconds, and the
lower 96 bits are random. This allows for AWS X-Ray `interop
<https://github.com/openzipkin/zipkin/issues/1754>`_
:returns: 32-character hex string
"""
t = int(time.time())
lower_96 = random.getrandbits(96)
return '{:032x}'.format((t << 96) | lower_96)
|
Creates encoder object for the given encoding.
|
def get_encoder(encoding):
"""Creates encoder object for the given encoding.
:param encoding: desired output encoding protocol.
:type encoding: Encoding
:return: corresponding IEncoder object
:rtype: IEncoder
"""
if encoding == Encoding.V1_THRIFT:
return _V1ThriftEncoder()
if encoding == Encoding.V1_JSON:
return _V1JSONEncoder()
if encoding == Encoding.V2_JSON:
return _V2JSONEncoder()
if encoding == Encoding.V2_PROTO3:
return _V2ProtobufEncoder()
raise ZipkinError('Unknown encoding: {}'.format(encoding))
|
Checks if the new span fits in the max payload size.
|
def fits(self, current_count, current_size, max_size, new_span):
"""Checks if the new span fits in the max payload size.
Thrift lists have a fixed-size header and no delimiters between elements
so it's easy to compute the list size.
"""
return thrift.LIST_HEADER_SIZE + current_size + len(new_span) <= max_size
|
Encodes the current span to thrift.
|
def encode_span(self, v2_span):
"""Encodes the current span to thrift."""
span = v2_span.build_v1_span()
thrift_endpoint = thrift.create_endpoint(
span.endpoint.port,
span.endpoint.service_name,
span.endpoint.ipv4,
span.endpoint.ipv6,
)
thrift_annotations = thrift.annotation_list_builder(
span.annotations,
thrift_endpoint,
)
thrift_binary_annotations = thrift.binary_annotation_list_builder(
span.binary_annotations,
thrift_endpoint,
)
# Add sa/ca binary annotations
if v2_span.remote_endpoint:
self.encode_remote_endpoint(
v2_span.remote_endpoint,
v2_span.kind,
thrift_binary_annotations,
)
thrift_span = thrift.create_span(
span.id,
span.parent_id,
span.trace_id,
span.name,
thrift_annotations,
thrift_binary_annotations,
span.timestamp,
span.duration,
)
encoded_span = thrift.span_to_bytes(thrift_span)
return encoded_span
|
Converts an Endpoint to a JSON endpoint dict.
|
def _create_json_endpoint(self, endpoint, is_v1):
"""Converts an Endpoint to a JSON endpoint dict.
:param endpoint: endpoint object to convert.
:type endpoint: Endpoint
:param is_v1: whether we're serializing a v1 span. This is needed since
in v1 some fields default to an empty string rather than being
dropped if they're not set.
:type is_v1: bool
:return: dict representing a JSON endpoint.
:rtype: dict
"""
json_endpoint = {}
if endpoint.service_name:
json_endpoint['serviceName'] = endpoint.service_name
elif is_v1:
# serviceName is mandatory in v1
json_endpoint['serviceName'] = ""
if endpoint.port and endpoint.port != 0:
json_endpoint['port'] = endpoint.port
if endpoint.ipv4 is not None:
json_endpoint['ipv4'] = endpoint.ipv4
if endpoint.ipv6 is not None:
json_endpoint['ipv6'] = endpoint.ipv6
return json_endpoint
|
Encodes a single span to JSON.
|
def encode_span(self, v2_span):
"""Encodes a single span to JSON."""
span = v2_span.build_v1_span()
json_span = {
'traceId': span.trace_id,
'name': span.name,
'id': span.id,
'annotations': [],
'binaryAnnotations': [],
}
if span.parent_id:
json_span['parentId'] = span.parent_id
if span.timestamp:
json_span['timestamp'] = int(span.timestamp * 1000000)
if span.duration:
json_span['duration'] = int(span.duration * 1000000)
v1_endpoint = self._create_json_endpoint(span.endpoint, True)
for key, timestamp in span.annotations.items():
json_span['annotations'].append({
'endpoint': v1_endpoint,
'timestamp': int(timestamp * 1000000),
'value': key,
})
for key, value in span.binary_annotations.items():
json_span['binaryAnnotations'].append({
'key': key,
'value': value,
'endpoint': v1_endpoint,
})
# Add sa/ca binary annotations
if v2_span.remote_endpoint:
self.encode_remote_endpoint(
v2_span.remote_endpoint,
v2_span.kind,
json_span['binaryAnnotations'],
)
encoded_span = json.dumps(json_span)
return encoded_span
|
Encodes a single span to JSON.
|
def encode_span(self, span):
"""Encodes a single span to JSON."""
json_span = {
'traceId': span.trace_id,
'id': span.span_id,
}
if span.name:
json_span['name'] = span.name
if span.parent_id:
json_span['parentId'] = span.parent_id
if span.timestamp:
json_span['timestamp'] = int(span.timestamp * 1000000)
if span.duration:
json_span['duration'] = int(span.duration * 1000000)
if span.shared is True:
json_span['shared'] = True
if span.kind and span.kind.value is not None:
json_span['kind'] = span.kind.value
if span.local_endpoint:
json_span['localEndpoint'] = self._create_json_endpoint(
span.local_endpoint,
False,
)
if span.remote_endpoint:
json_span['remoteEndpoint'] = self._create_json_endpoint(
span.remote_endpoint,
False,
)
if span.tags and len(span.tags) > 0:
json_span['tags'] = span.tags
if span.annotations:
json_span['annotations'] = [
{
'timestamp': int(timestamp * 1000000),
'value': key,
}
for key, timestamp in span.annotations.items()
]
encoded_span = json.dumps(json_span)
return encoded_span
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.