docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add Related topics... buttons

This commit is contained in:
John Mulhausen 2017-02-21 18:45:07 -08:00
parent eda0c811a4
commit 81c71d67a1
No known key found for this signature in database
GPG Key ID: 0FC599ECCDBFDE02
3 changed files with 285 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

491
_data/glossary.yaml
View File

@ -1,294 +1,257 @@
glossary: aufs: |
- term: aufs aufs (advanced multi layered unification filesystem) is a Linux [filesystem](#filesystem) that
def: | Docker supports as a storage backend. It implements the
aufs (advanced multi layered unification filesystem) is a Linux [filesystem](#filesystem) that [union mount](http://en.wikipedia.org/wiki/Union_mount) for Linux file systems.
Docker supports as a storage backend. It implements the base image: |
[union mount](http://en.wikipedia.org/wiki/Union_mount) for Linux file systems. An image that has no parent is a **base image**.
- term: base image boot2docker: |
def: | [boot2docker](http://boot2docker.io/) is a lightweight Linux distribution made
An image that has no parent is a **base image**. specifically to run Docker containers. The boot2docker management tool for Mac and Windows was deprecated and replaced by [`docker-machine`](#machine) which you can install with the Docker Toolbox.
- term: boot2docker btrfs: |
def: | btrfs (B-tree file system) is a Linux [filesystem](#filesystem) that Docker
[boot2docker](http://boot2docker.io/) is a lightweight Linux distribution made supports as a storage backend. It is a [copy-on-write](http://en.wikipedia.org/wiki/Copy-on-write)
specifically to run Docker containers. The boot2docker management tool for Mac and Windows was deprecated and replaced by [`docker-machine`](#machine) which you can install with the Docker Toolbox. filesystem.
- term: btrfs build: |
def: | build is the process of building Docker images using a [Dockerfile](#dockerfile).
btrfs (B-tree file system) is a Linux [filesystem](#filesystem) that Docker The build uses a Dockerfile and a "context". The context is the set of files in the
supports as a storage backend. It is a [copy-on-write](http://en.wikipedia.org/wiki/Copy-on-write) directory in which the image is built.
filesystem. cgroups: |
- term: build cgroups is a Linux kernel feature that limits, accounts for, and isolates
def: | the resource usage (CPU, memory, disk I/O, network, etc.) of a collection
build is the process of building Docker images using a [Dockerfile](#dockerfile). of processes. Docker relies on cgroups to control and isolate resource limits.
The build uses a Dockerfile and a "context". The context is the set of files in the
directory in which the image is built.
- term: cgroups
def: |
cgroups is a Linux kernel feature that limits, accounts for, and isolates
the resource usage (CPU, memory, disk I/O, network, etc.) of a collection
of processes. Docker relies on cgroups to control and isolate resource limits.
*Also known as : control groups* *Also known as : control groups*
- term: Compose Compose: |
def: | [Compose](https://github.com/docker/compose) is a tool for defining and
[Compose](https://github.com/docker/compose) is a tool for defining and running complex applications with Docker. With compose, you define a
running complex applications with Docker. With compose, you define a multi-container application in a single file, then spin your
multi-container application in a single file, then spin your application up in a single command which does everything that needs to
application up in a single command which does everything that needs to be done to get it running.
be done to get it running.
*Also known as : docker-compose, fig* *Also known as : docker-compose, fig*
- term: copy-on-write copy-on-write: |
def: | Docker uses a
Docker uses a [copy-on-write](/engine/userguide/storagedriver/imagesandcontainers/#/the-copy-on-write-strategy)
[copy-on-write](/engine/userguide/storagedriver/imagesandcontainers/#/the-copy-on-write-strategy) technique and a [union file system](#union-file-system) for both images and
technique and a [union file system](#union-file-system) for both images and containers to optimize resources and speed performance. Multiple copies of an
containers to optimize resources and speed performance. Multiple copies of an entity share the same instance and each one makes only specific changes to its
entity share the same instance and each one makes only specific changes to its unique layer.
unique layer.
Multiple containers can share access to the same image, and make Multiple containers can share access to the same image, and make
container-specific changes on a writable layer which is deleted when container-specific changes on a writable layer which is deleted when
the container is removed. This speeds up container start times and performance. the container is removed. This speeds up container start times and performance.
Images are essentially layers of filesystems typically predicated on a base Images are essentially layers of filesystems typically predicated on a base
image under a writable layer, and built up with layers of differences from the image under a writable layer, and built up with layers of differences from the
base image. This minimizes the footprint of the image and enables shared base image. This minimizes the footprint of the image and enables shared
development. development.
For more about copy-on-write in the context of Docker, see [Understand images, For more about copy-on-write in the context of Docker, see [Understand images,
containers, and storage containers, and storage
drivers](/engine/userguide/storagedriver/imagesandcontainers/). drivers](/engine/userguide/storagedriver/imagesandcontainers/).
- term: container container: |
def: | A container is a runtime instance of a [docker image](#image).
A container is a runtime instance of a [docker image](#image).
A Docker container consists of A Docker container consists of
- A Docker image A Docker image
- Execution environment Execution environment
- A standard set of instructions A standard set of instructions
The concept is borrowed from Shipping Containers, which define a standard to ship The concept is borrowed from Shipping Containers, which define a standard to ship
goods globally. Docker defines a standard to ship software. goods globally. Docker defines a standard to ship software.
- term: data volume data volume: |
def: | A data volume is a specially-designated directory within one or more containers
A data volume is a specially-designated directory within one or more containers that bypasses the Union File System. Data volumes are designed to persist data,
that bypasses the Union File System. Data volumes are designed to persist data, independent of the container's life cycle. Docker therefore never automatically
independent of the container's life cycle. Docker therefore never automatically delete volumes when you remove a container, nor will it "garbage collect"
delete volumes when you remove a container, nor will it "garbage collect" volumes that are no longer referenced by a container.
volumes that are no longer referenced by a container. Docker: |
- term: Docker The term Docker can refer to
def: |
The term Docker can refer to
- The Docker project as a whole, which is a platform for developers and sysadmins to The Docker project as a whole, which is a platform for developers and sysadmins to
develop, ship, and run applications develop, ship, and run applications
- The docker daemon process running on the host which manages images and containers The docker daemon process running on the host which manages images and containers
- term: Docker for Mac Docker for Mac: |
def: | [Docker for Mac](/docker-for-mac/) is an easy-to-install,
[Docker for Mac](/docker-for-mac/) is an easy-to-install, lightweight Docker development environment designed specifically for the Mac. A
lightweight Docker development environment designed specifically for the Mac. A native Mac application, Docker for Mac uses the macOS Hypervisor framework,
native Mac application, Docker for Mac uses the macOS Hypervisor framework, networking, and filesystem. It's the best solution if you want to build, debug,
networking, and filesystem. It's the best solution if you want to build, debug, test, package, and ship Dockerized applications on a Mac. Docker for Mac
test, package, and ship Dockerized applications on a Mac. Docker for Mac supersedes [Docker Toolbox](#toolbox) as state-of-the-art Docker on macOS.
supersedes [Docker Toolbox](#toolbox) as state-of-the-art Docker on macOS. Docker for Windows: |
- term: Docker for Windows [Docker for Windows](/docker-for-windows/) is an
def: | easy-to-install, lightweight Docker development environment designed
[Docker for Windows](/docker-for-windows/) is an specifically for Windows 10 systems that support Microsoft Hyper-V
easy-to-install, lightweight Docker development environment designed (Professional, Enterprise and Education). Docker for Windows uses Hyper-V for
specifically for Windows 10 systems that support Microsoft Hyper-V virtualization, and runs as a native Windows app. It works with Windows Server
(Professional, Enterprise and Education). Docker for Windows uses Hyper-V for 2016, and gives you the ability to set up and run Windows containers as well as
virtualization, and runs as a native Windows app. It works with Windows Server the standard Linux containers, with an option to switch between the two. Docker
2016, and gives you the ability to set up and run Windows containers as well as for Windows is the best solution if you want to build, debug, test, package, and
the standard Linux containers, with an option to switch between the two. Docker ship Dockerized applications from Windows machines. Docker for Windows
for Windows is the best solution if you want to build, debug, test, package, and supersedes [Docker Toolbox](#toolbox) as state-of-the-art Docker on Windows.
ship Dockerized applications from Windows machines. Docker for Windows Docker Hub: |
supersedes [Docker Toolbox](#toolbox) as state-of-the-art Docker on Windows. The [Docker Hub](https://hub.docker.com/) is a centralized resource for working with
- term: Docker Hub Docker and its components. It provides the following services:
def: |
The [Docker Hub](https://hub.docker.com/) is a centralized resource for working with
Docker and its components. It provides the following services:
- Docker image hosting Docker image hosting
- User authentication User authentication
- Automated image builds and work-flow tools such as build triggers and web hooks Automated image builds and work-flow tools such as build triggers and web hooks
- Integration with GitHub and Bitbucket Integration with GitHub and Bitbucket
- term: Dockerfile Dockerfile: |
def: | A Dockerfile is a text document that contains all the commands you would
A Dockerfile is a text document that contains all the commands you would normally execute manually in order to build a Docker image. Docker can
normally execute manually in order to build a Docker image. Docker can build images automatically by reading the instructions from a Dockerfile.
build images automatically by reading the instructions from a Dockerfile. filesystem: |
- term: filesystem A file system is the method an operating system uses to name files
def: | and assign them locations for efficient storage and retrieval.
A file system is the method an operating system uses to name files
and assign them locations for efficient storage and retrieval.
Examples : Examples :
- Linux : ext4, aufs, btrfs, zfs Linux : ext4, aufs, btrfs, zfs
- Windows : NTFS Windows : NTFS
- macOS : HFS+ macOS : HFS+
- term: image image: |
def: | Docker images are the basis of [containers](#container). An Image is an
Docker images are the basis of [containers](#container). An Image is an ordered collection of root filesystem changes and the corresponding
ordered collection of root filesystem changes and the corresponding execution parameters for use within a container runtime. An image typically
execution parameters for use within a container runtime. An image typically contains a union of layered filesystems stacked on top of each other. An image
contains a union of layered filesystems stacked on top of each other. An image does not have state and it never changes.
does not have state and it never changes. libcontainer: |
- term: libcontainer libcontainer provides a native Go implementation for creating containers with
def: | namespaces, cgroups, capabilities, and filesystem access controls. It allows
libcontainer provides a native Go implementation for creating containers with you to manage the lifecycle of the container performing additional operations
namespaces, cgroups, capabilities, and filesystem access controls. It allows after the container is created.
you to manage the lifecycle of the container performing additional operations libnetwork: |
after the container is created. libnetwork provides a native Go implementation for creating and managing container
- term: libnetwork network namespaces and other network resources. It manage the networking lifecycle
def: | of the container performing additional operations after the container is created.
libnetwork provides a native Go implementation for creating and managing container link: |
network namespaces and other network resources. It manage the networking lifecycle links provide a legacy interface to connect Docker containers running on the
of the container performing additional operations after the container is created. same host to each other without exposing the hosts' network ports. Use the
- term: link Docker networks feature instead.
def: | Machine: |
links provide a legacy interface to connect Docker containers running on the [Machine](https://github.com/docker/machine) is a Docker tool which
same host to each other without exposing the hosts' network ports. Use the makes it really easy to create Docker hosts on your computer, on
Docker networks feature instead. cloud providers and inside your own data center. It creates servers,
- term: Machine installs Docker on them, then configures the Docker client to talk to them.
def: |
[Machine](https://github.com/docker/machine) is a Docker tool which
makes it really easy to create Docker hosts on your computer, on
cloud providers and inside your own data center. It creates servers,
installs Docker on them, then configures the Docker client to talk to them.
*Also known as : docker-machine* *Also known as : docker-machine*
- term: node node: |
def: | A [node](/engine/swarm/how-swarm-mode-works/nodes/) is a physical or virtual
A [node](/engine/swarm/how-swarm-mode-works/nodes/) is a physical or virtual machine running an instance of the Docker Engine in swarm mode.
machine running an instance of the Docker Engine in swarm mode.
**Manager nodes** perform swarm management and orchestration duties. By default **Manager nodes** perform swarm management and orchestration duties. By default
manager nodes are also worker nodes. manager nodes are also worker nodes.
**Worker nodes** execute tasks. **Worker nodes** execute tasks.
- term: overlay network driver overlay network driver: |
def: | Overlay network driver provides out of the box multi-host network connectivity
Overlay network driver provides out of the box multi-host network connectivity for docker containers in a cluster.
for docker containers in a cluster. overlay storage driver: |
- term: overlay storage driver OverlayFS is a [filesystem](#filesystem) service for Linux which implements a
def: | [union mount](http://en.wikipedia.org/wiki/Union_mount) for other file systems.
OverlayFS is a [filesystem](#filesystem) service for Linux which implements a It is supported by the Docker daemon as a storage driver.
[union mount](http://en.wikipedia.org/wiki/Union_mount) for other file systems. registry: |
It is supported by the Docker daemon as a storage driver. A Registry is a hosted service containing [repositories](#repository) of [images](#image)
- term: registry which responds to the Registry API.
def: |
A Registry is a hosted service containing [repositories](#repository) of [images](#image)
which responds to the Registry API.
The default registry can be accessed using a browser at [Docker Hub](#docker-hub) The default registry can be accessed using a browser at [Docker Hub](#docker-hub)
or using the `docker search` command. or using the `docker search` command.
- term: repository repository: |
def: | A repository is a set of Docker images. A repository can be shared by pushing it
A repository is a set of Docker images. A repository can be shared by pushing it to a [registry](#registry) server. The different images in the repository can be
to a [registry](#registry) server. The different images in the repository can be labeled using [tags](#tag).
labeled using [tags](#tag).
Here is an example of the shared [nginx repository](https://hub.docker.com/_/nginx/) Here is an example of the shared [nginx repository](https://hub.docker.com/_/nginx/)
and its [tags](https://hub.docker.com/r/library/nginx/tags/) and its [tags](https://hub.docker.com/r/library/nginx/tags/)
- term: service service: |
def: | A [service](/engine/swarm/how-swarm-mode-works/services/) is the definition of how
A [service](/engine/swarm/how-swarm-mode-works/services/) is the definition of how you want to run your application containers in a swarm. At the most basic level
you want to run your application containers in a swarm. At the most basic level a service defines which container image to run in the swarm and which commands
a service defines which container image to run in the swarm and which commands to run in the container. For orchestration purposes, the service defines the
to run in the container. For orchestration purposes, the service defines the "desired state", meaning how many containers to run as tasks and constraints for
"desired state", meaning how many containers to run as tasks and constraints for deploying the containers.
deploying the containers.
Frequently a service is a microservice within the context of some larger Frequently a service is a microservice within the context of some larger
application. Examples of services might include an HTTP server, a database, or application. Examples of services might include an HTTP server, a database, or
any other type of executable program that you wish to run in a distributed any other type of executable program that you wish to run in a distributed
environment. environment.
- term: service discovery service discovery: |
def: | Swarm mode [service discovery](/engine/swarm/networking/#use-swarm-mode-service-discovery) is a DNS component
Swarm mode [service discovery](/engine/swarm/networking/#use-swarm-mode-service-discovery) is a DNS component internal to the swarm that automatically assigns each service on an overlay
internal to the swarm that automatically assigns each service on an overlay network in the swarm a VIP and DNS entry. Containers on the network share DNS
network in the swarm a VIP and DNS entry. Containers on the network share DNS mappings for the service via gossip so any container on the network can access
mappings for the service via gossip so any container on the network can access the service via its service name.
the service via its service name.
You don’t need to expose service-specific ports to make the service available to You don’t need to expose service-specific ports to make the service available to
other services on the same overlay network. The swarm’s internal load balancer other services on the same overlay network. The swarm’s internal load balancer
automatically distributes requests to the service VIP among the active tasks. automatically distributes requests to the service VIP among the active tasks.
- term: swarm swarm: |
def: | A [swarm](/engine/swarm/) is a cluster of one or more Docker Engines running in [swarm mode](#swarm-mode).
A [swarm](/engine/swarm/) is a cluster of one or more Docker Engines running in [swarm mode](#swarm-mode). Docker Swarm: |
- term: Docker Swarm Do not confuse [Docker Swarm](https://github.com/docker/swarm) with the [swarm mode](#swarm-mode) features in Docker Engine.
def: |
Do not confuse [Docker Swarm](https://github.com/docker/swarm) with the [swarm mode](#swarm-mode) features in Docker Engine.
Docker Swarm is the name of a standalone native clustering tool for Docker. Docker Swarm is the name of a standalone native clustering tool for Docker.
Docker Swarm pools together several Docker hosts and exposes them as a single Docker Swarm pools together several Docker hosts and exposes them as a single
virtual Docker host. It serves the standard Docker API, so any tool that already virtual Docker host. It serves the standard Docker API, so any tool that already
works with Docker can now transparently scale up to multiple hosts. works with Docker can now transparently scale up to multiple hosts.
*Also known as : docker-swarm* *Also known as : docker-swarm*
- term: swarm mode swarm mode: |
def: | [Swarm mode](/engine/swarm/) refers to cluster management and orchestration
[Swarm mode](/engine/swarm/) refers to cluster management and orchestration features embedded in Docker Engine. When you initialize a new swarm (cluster) or
features embedded in Docker Engine. When you initialize a new swarm (cluster) or join nodes to a swarm, the Docker Engine runs in swarm mode.
join nodes to a swarm, the Docker Engine runs in swarm mode. tag: |
- term: tag A tag is a label applied to a Docker image in a [repository](#repository).
def: | tags are how various images in a repository are distinguished from each other.
A tag is a label applied to a Docker image in a [repository](#repository).
tags are how various images in a repository are distinguished from each other.
*Note : This label is not related to the key=value labels set for docker daemon* *Note : This label is not related to the key=value labels set for docker daemon*
- term: task task: |
def: | A [task](/engine/swarm/how-swarm-mode-works/services/#/tasks-and-scheduling) is the
A [task](/engine/swarm/how-swarm-mode-works/services/#/tasks-and-scheduling) is the atomic unit of scheduling within a swarm. A task carries a Docker container and
atomic unit of scheduling within a swarm. A task carries a Docker container and the commands to run inside the container. Manager nodes assign tasks to worker
the commands to run inside the container. Manager nodes assign tasks to worker nodes according to the number of replicas set in the service scale.
nodes according to the number of replicas set in the service scale.
The diagram below illustrates the relationship of services to tasks and The diagram below illustrates the relationship of services to tasks and
containers. containers.
![services diagram](/engine/swarm/images/services-diagram.png) ![services diagram](/engine/swarm/images/services-diagram.png)
- term: Toolbox Toolbox: |
def: | [Docker Toolbox](/toolbox/overview/) is a legacy
[Docker Toolbox](/toolbox/overview/) is a legacy installer for Mac and Windows users. It uses Oracle VirtualBox for
installer for Mac and Windows users. It uses Oracle VirtualBox for virtualization.
virtualization.
For Macs running OS X El Capitan 10.11 and newer macOS releases, [Docker for For Macs running OS X El Capitan 10.11 and newer macOS releases, [Docker for
Mac](/docker-for-mac/) is the better solution. Mac](/docker-for-mac/) is the better solution.
For Windows 10 systems that support Microsoft Hyper-V (Professional, Enterprise For Windows 10 systems that support Microsoft Hyper-V (Professional, Enterprise
and Education), [Docker for and Education), [Docker for
Windows](/docker-for-windows/) is the better solution. Windows](/docker-for-windows/) is the better solution.
- term: Union file system Union file system: |
def: | Union file systems implement a [union
Union file systems implement a [union mount](https://en.wikipedia.org/wiki/Union_mount) and operate by creating
mount](https://en.wikipedia.org/wiki/Union_mount) and operate by creating layers. Docker uses union file systems in conjunction with
layers. Docker uses union file systems in conjunction with [copy-on-write](#copy-on-write) techniques to provide the building blocks for
[copy-on-write](#copy-on-write) techniques to provide the building blocks for containers, making them very lightweight and fast.
containers, making them very lightweight and fast.
For more on Docker and union file systems, see [Docker and AUFS in For more on Docker and union file systems, see [Docker and AUFS in
practice](/engine/userguide/storagedriver/aufs-driver/), practice](/engine/userguide/storagedriver/aufs-driver/),
[Docker and Btrfs in [Docker and Btrfs in
practice](/engine/userguide/storagedriver/btrfs-driver/), practice](/engine/userguide/storagedriver/btrfs-driver/),
and [Docker and OverlayFS in and [Docker and OverlayFS in
practice](/engine/userguide/storagedriver/overlayfs-driver/) practice](/engine/userguide/storagedriver/overlayfs-driver/)
Example implementations of union file systems are Example implementations of union file systems are
[UnionFS](https://en.wikipedia.org/wiki/UnionFS), [UnionFS](https://en.wikipedia.org/wiki/UnionFS),
[AUFS](https://en.wikipedia.org/wiki/Aufs), and [AUFS](https://en.wikipedia.org/wiki/Aufs), and
[Btrfs](https://btrfs.wiki.kernel.org/index.php/Main_Page). [Btrfs](https://btrfs.wiki.kernel.org/index.php/Main_Page).
- term: virtual machine virtual machine: |
def: | A virtual machine is a program that emulates a complete computer and imitates dedicated hardware.
A virtual machine is a program that emulates a complete computer and imitates dedicated hardware. It shares physical hardware resources with other users but isolates the operating system. The
It shares physical hardware resources with other users but isolates the operating system. The end user has the same experience on a Virtual Machine as they would have on dedicated hardware.
end user has the same experience on a Virtual Machine as they would have on dedicated hardware.
Compared to containers, a virtual machine is heavier to run, provides more isolation, Compared to containers, a virtual machine is heavier to run, provides more isolation,
gets its own set of resources and does minimal sharing. gets its own set of resources and does minimal sharing.
*Also known as : VM* *Also known as : VM*

21
glossary.md
View File

@ -2,12 +2,23 @@
title: "Docker Glossary" title: "Docker Glossary"
description: "Glossary of terms used around Docker" description: "Glossary of terms used around Docker"
keywords: "glossary, docker, terms, definitions" keywords: "glossary, docker, terms, definitions"
skip-right-nav: true notoc: true
--- ---
{% for entry in site.data.glossary.glossary %} <!--
## {{ entry.term }} To edit/add/remove glossary entries, visit the YAML file at:
https://github.com/docker/docker.github.io/blob/master/_data/glossary.yaml
{{ entry.def }} To get a specific entry while writing a page in the docs, enter Liquid text
like so:
{{ site.data.glossary["aufs"] }}
-->
{% for entry in site.data.glossary %}{% assign newEntry="true" %}
## {{ entry[0] }}
{{ entry[1] }}
<span class="relatedGlossaryText" style="display:none">{{ entry[0] }}</span>
<span id="related-{{ forloop.index }}" style="display:none" class="relatedGlossary">{{ entry.term }}</span>
{% endfor %} {% endfor %}

44
js/menu.js
View File

@ -12,12 +12,52 @@ var scoreForURLMatch = 5;
var scoreForKeywordMatch = 3; var scoreForKeywordMatch = 3;
var scoreForDescriptionMatch = 1 var scoreForDescriptionMatch = 1
function makeSafeForCSS(name) {
return name.replace(/[^a-z0-9]/g, function(s) {
var c = s.charCodeAt(0);
if (c == 32) return '-';
if (c >= 65 && c <= 90) return '_' + s.toLowerCase();
return '__' + ('000' + c.toString(16)).slice(-4);
});
}
function showRelated(term)
{
$("#button-"+term).css("display","none");
$("#topics-"+term).css("display","block");
}
function drawRelated(liArray,term)
{
var output = new Array();
output.push('<a href="javascript:showRelated(\'' + makeSafeForCSS(term) + '\')" id="button-'+ makeSafeForCSS(term) +'" class="button darkblue-btn">Related topics...</a>');
output.push('<ul id="topics-' + makeSafeForCSS(term) + '" style="display:none">');
for(i=0;i<liArray.length;i++) output.push(liArray[i]);
output.push('</ul>')
return output.join('\n');
}
function glossaryCheck() { function glossaryCheck() {
if (window.location.href.indexOf("/glossary/") > -1) if (window.location.href.indexOf("/glossary/") > -1)
{ {
console.log(metadata);
// you're viewing the glossary; load related topics for each entry // you're viewing the glossary; load related topics for each entry
$(".relatedGlossary").each(function(){ $(".relatedGlossaryText").each(function(){
console.log(this); var output = new Array();
var thisTerm = this.innerText.toLowerCase();
for(i=0;i<metadata.pages.length;i++)
{
if(metadata.pages[i].keywords) {
if(metadata.pages[i].keywords.toLowerCase().indexOf(thisTerm) > -1)
{
output.push('<li><a href="' + metadata.pages[i].url + '">' + metadata.pages[i].title + '</a></li>');
}
}
}
if(output.length > 0)
{
$(this).after(drawRelated(output,this.innerText));
}
}); });
} }
} }