*Redis cluster tutorial
This document is a gentle introduction to Redis Cluster, that does not use complex to understand distributed systems concepts. It provides instructions about how to setup a cluster, test, and operate it, without going into the details that are covered in the Redis Cluster specification but just describing how the system behaves from the point of view of the user.
However this tutorial tries to provide information about the availability and consistency characteristics of Redis Cluster from the point of view of the final user, stated in a simple to understand way.
Note this tutorial requires Redis version 3.0 or higher.
If you plan to run a serious Redis Cluster deployment, the more formal specification is a suggested reading, even if not strictly required. However it is a good idea to start from this document, play with Redis Cluster some time, and only later read the specification.
*Redis Cluster 101
Redis Cluster provides a way to run a Redis installation where data is automatically sharded across multiple Redis nodes.
Redis Cluster also provides some degree of availability during partitions, that is in practical terms the ability to continue the operations when some nodes fail or are not able to communicate. However the cluster stops to operate in the event of larger failures (for example when the majority of masters are unavailable).
So in practical terms, what you get with Redis Cluster?
- The ability to automatically split your dataset among multiple nodes.
- The ability to continue operations when a subset of the nodes are experiencing failures or are unable to communicate with the rest of the cluster.
*Redis Cluster TCP ports
Every Redis Cluster node requires two TCP connections open. The normal Redis TCP port used to serve clients, for example 6379, plus the port obtained by adding 10000 to the data port, so 16379 in the example.
This second high port is used for the Cluster bus, that is a node-to-node communication channel using a binary protocol. The Cluster bus is used by nodes for failure detection, configuration update, failover authorization and so forth. Clients should never try to communicate with the cluster bus port, but always with the normal Redis command port, however make sure you open both ports in your firewall, otherwise Redis cluster nodes will be not able to communicate.
The command port and cluster bus port offset is fixed and is always 10000.
Note that for a Redis Cluster to work properly you need, for each node:
- The normal client communication port (usually 6379) used to communicate with clients to be open to all the clients that need to reach the cluster, plus all the other cluster nodes (that use the client port for keys migrations).
- The cluster bus port (the client port + 10000) must be reachable from all the other cluster nodes.
If you don't open both TCP ports, your cluster will not work as expected.
The cluster bus uses a different, binary protocol, for node to node data exchange, which is more suited to exchange information between nodes using little bandwidth and processing time.
*Redis Cluster and Docker
Currently Redis Cluster does not support NATted environments and in general environments where IP addresses or TCP ports are remapped.
Docker uses a technique called port mapping: programs running inside Docker containers may be exposed with a different port compared to the one the program believes to be using. This is useful in order to run multiple containers using the same ports, at the same time, in the same server.
In order to make Docker compatible with Redis Cluster you need to use
the host networking mode of Docker. Please check the --net=host
option
in the Docker documentation for more information.
*Redis Cluster data sharding
Redis Cluster does not use consistent hashing, but a different form of sharding where every key is conceptually part of what we call an hash slot.
There are 16384 hash slots in Redis Cluster, and to compute what is the hash slot of a given key, we simply take the CRC16 of the key modulo 16384.
Every node in a Redis Cluster is responsible for a subset of the hash slots, so for example you may have a cluster with 3 nodes, where:
- Node A contains hash slots from 0 to 5500.
- Node B contains hash slots from 5501 to 11000.
- Node C contains hash slots from 11001 to 16384.
This allows to add and remove nodes in the cluster easily. For example if I want to add a new node D, I need to move some hash slot from nodes A, B, C to D. Similarly if I want to remove node A from the cluster I can just move the hash slots served by A to B and C. When the node A will be empty I can remove it from the cluster completely.
Because moving hash slots from a node to another does not require to stop operations, adding and removing nodes, or changing the percentage of hash slots hold by nodes, does not require any downtime.
Redis Cluster supports multiple key operations as long as all the keys involved into a single command execution (or whole transaction, or Lua script execution) all belong to the same hash slot. The user can force multiple keys to be part of the same hash slot by using a concept called hash tags.
Hash tags are documented in the Redis Cluster specification, but the gist is
that if there is a substring between {} brackets in a key, only what is
inside the string is hashed, so for example this{foo}key
and another{foo}key
are guaranteed to be in the same hash slot, and can be used together in a
command with multiple keys as arguments.
*Redis Cluster master-slave model
In order to remain available when a subset of master nodes are failing or are not able to communicate with the majority of nodes, Redis Cluster uses a master-slave model where every hash slot has from 1 (the master itself) to N replicas (N-1 additional slaves nodes).
In our example cluster with nodes A, B, C, if node B fails the cluster is not able to continue, since we no longer have a way to serve hash slots in the range 5501-11000.
However when the cluster is created (or at a latter time) we add a slave node to every master, so that the final cluster is composed of A, B, C that are masters nodes, and A1, B1, C1 that are slaves nodes, the system is able to continue if node B fails.
Node B1 replicates B, and B fails, the cluster will promote node B1 as the new master and will continue to operate correctly.
However note that if nodes B and B1 fail at the same time Redis Cluster is not able to continue to operate.
*Redis Cluster consistency guarantees
Redis Cluster is not able to guarantee strong consistency. In practical terms this means that under certain conditions it is possible that Redis Cluster will lose writes that were acknowledged by the system to the client.
The first reason why Redis Cluster can lose writes is because it uses asynchronous replication. This means that during writes the following happens:
- Your client writes to the master B.
- The master B replies OK to your client.
- The master B propagates the write to its slaves B1, B2 and B3.
As you can see B does not wait for an acknowledge from B1, B2, B3 before replying to the client, since this would be a prohibitive latency penalty for Redis, so if your client writes something, B acknowledges the write, but crashes before being able to send the write to its slaves, one of the slaves (that did not receive the write) can be promoted to master, losing the write forever.
This is very similar to what happens with most databases that are configured to flush data to disk every second, so it is a scenario you are already able to reason about because of past experiences with traditional database systems not involving distributed systems. Similarly you can improve consistency by forcing the database to flush data on disk before replying to the client, but this usually results into prohibitively low performance. That would be the equivalent of synchronous replication in the case of Redis Cluster.
Basically there is a trade-off to take between performance and consistency.
Redis Cluster has support for synchronous writes when absolutely needed, implemented via the WAIT command, this makes losing writes a lot less likely, however note that Redis Cluster does not implement strong consistency even when synchronous replication is used: it is always possible under more complex failure scenarios that a slave that was not able to receive the write is elected as master.
There is another notable scenario where Redis Cluster will lose writes, that happens during a network partition where a client is isolated with a minority of instances including at least a master.
Take as an example our 6 nodes cluster composed of A, B, C, A1, B1, C1, with 3 masters and 3 slaves. There is also a client, that we will call Z1.
After a partition occurs, it is possible that in one side of the partition we have A, C, A1, B1, C1, and in the other side we have B and Z1.
Z1 is still able to write to B, that will accept its writes. If the partition heals in a very short time, the cluster will continue normally. However if the partition lasts enough time for B1 to be promoted to master in the majority side of the partition, the writes that Z1 is sending to B will be lost.
Note that there is a maximum window to the amount of writes Z1 will be able to send to B: if enough time has elapsed for the majority side of the partition to elect a slave as master, every master node in the minority side stops accepting writes.
This amount of time is a very important configuration directive of Redis Cluster, and is called the node timeout.
After node timeout has elapsed, a master node is considered to be failing, and can be replaced by one of its replicas. Similarly after node timeout has elapsed without a master node to be able to sense the majority of the other master nodes, it enters an error state and stops accepting writes.
*Redis Cluster configuration parameters
We are about to create an example cluster deployment. Before to continue
let's introduce the configuration parameters that Redis Cluster introduces
in the redis.conf
file. Some will be obvious, others will be more clear
as you continue reading.
- cluster-enabled
<yes/no>
: If yes enables Redis Cluster support in a specific Redis instance. Otherwise the instance starts as a stand alone instance as usually. - cluster-config-file
<filename>
: Note that despite the name of this option, this is not an user editable configuration file, but the file where a Redis Cluster node automatically persists the cluster configuration (the state, basically) every time there is a change, in order to be able to re-read it at startup. The file lists things like the other nodes in the cluster, their state, persistent variables, and so forth. Often this file is rewritten and flushed on disk as a result of some message reception. - cluster-node-timeout
<milliseconds>
: The maximum amount of time a Redis Cluster node can be unavailable, without it being considered as failing. If a master node is not reachable for more than the specified amount of time, it will be failed over by its slaves. This parameter controls other important things in Redis Cluster. Notably, every node that can't reach the majority of master nodes for the specified amount of time, will stop accepting queries. - cluster-slave-validity-factor
<factor>
: If set to zero, a slave will always try to failover a master, regardless of the amount of time the link between the master and the slave remained disconnected. If the value is positive, a maximum disconnection time is calculated as the node timeout value multiplied by the factor provided with this option, and if the node is a slave, it will not try to start a failover if the master link was disconnected for more than the specified amount of time. For example if the node timeout is set to 5 seconds, and the validity factor is set to 10, a slave disconnected from the master for more than 50 seconds will not try to failover its master. Note that any value different than zero may result in Redis Cluster to be unavailable after a master failure if there is no slave able to failover it. In that case the cluster will return back available only when the original master rejoins the cluster. - cluster-migration-barrier
<count>
: Minimum number of slaves a master will remain connected with, for another slave to migrate to a master which is no longer covered by any slave. See the appropriate section about replica migration in this tutorial for more information. - cluster-require-full-coverage
<yes/no>
: If this is set to yes, as it is by default, the cluster stops accepting writes if some percentage of the key space is not covered by any node. If the option is set to no, the cluster will still serve queries even if only requests about a subset of keys can be processed.
*Creating and using a Redis Cluster
Note: to deploy a Redis Cluster manually is very important to learn certain operation aspects of it. However if you want to get a cluster up and running ASAP skip this section and the next one and go directly to Creating a Redis Cluster using the create-cluster script.
To create a cluster, the first thing we need is to have a few empty Redis instances running in cluster mode. This basically means that clusters are not created using normal Redis instances, but a special mode needs to be configured so that the Redis instance will enable the Cluster specific features and commands.
The following is a minimal Redis cluster configuration file:
port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
As you can see what enables the cluster mode is simply the cluster-enabled
directive. Every instance also contains the path of a file where the
configuration for this node is stored, that by default is nodes.conf
.
This file is never touched by humans, it is simply generated at startup
by the Redis Cluster instances, and updated every time it is needed.
Note that the minimal cluster that works as expected requires to contain at least three master nodes. For your first tests it is strongly suggested to start a six nodes cluster with three masters and three slaves.
To do so, enter a new directory, and create the following directories named after the port number of the instance we'll run inside any given directory.
Something like:
mkdir cluster-test
cd cluster-test
mkdir 7000 7001 7002 7003 7004 7005
Create a redis.conf
file inside each of the directories, from 7000 to 7005.
As a template for your configuration file just use the small example above,
but make sure to replace the port number 7000
with the right port number
according to the directory name.
Now copy your redis-server executable, compiled from the latest sources in the unstable branch at GitHub, into the cluster-test
directory, and finally open 6 terminal tabs in your favorite terminal application.
Start every instance like that, one every tab:
cd 7000
../redis-server ./redis.conf
As you can see from the logs of every instance, since no nodes.conf
file
existed, every node assigns itself a new ID.
[82462] 26 Nov 11:56:55.329 * No cluster configuration found, I'm 97a3a64667477371c4479320d683e4c8db5858b1
This ID will be used forever by this specific instance in order for the instance to have a unique name in the context of the cluster. Every node remembers every other node using this IDs, and not by IP or port. IP addresses and ports may change, but the unique node identifier will never change for all the life of the node. We call this identifier simply Node ID.
*Creating the cluster
Now that we have a number of instances running, we need to create our cluster by writing some meaningful configuration to the nodes.
This is very easy to accomplish as we are helped by the Redis Cluster
command line utility called redis-trib
, a Ruby program
executing special commands on instances in order to create new clusters,
check or reshard an existing cluster, and so forth.
The redis-trib
utility is in the src
directory of the Redis source code
distribution.
You need to install redis
gem to be able to run redis-trib
.
gem install redis
To create your cluster simply type:
./redis-trib.rb create --replicas 1 <IP_ADDRESS>:7000 <IP_ADDRESS>:7001 \
<IP_ADDRESS>:7002 <IP_ADDRESS>:7003 <IP_ADDRESS>:7004 <IP_ADDRESS>:7005
The command used here is create, since we want to create a new cluster.
The option --replicas 1
means that we want a slave for every master created.
The other arguments are the list of addresses of the instances I want to use
to create the new cluster.
Obviously the only setup with our requirements is to create a cluster with 3 masters and 3 slaves.
Redis-trib will propose you a configuration. Accept typing yes. The cluster will be configured and joined, that means, instances will be bootstrapped into talking with each other. Finally if everything went ok you'll see a message like that:
[OK] All 16384 slots covered
This means that there is at least a master instance serving each of the 16384 slots available.
*Creating a Redis Cluster using the create-cluster script
If you don't want to create a Redis Cluster by configuring and executing individual instances manually as explained above, there is a much simpler system (but you'll not learn the same amount of operational details).
Just check utils/create-cluster
directory in the Redis distribution.
There is a script called create-cluster
inside (same name as the directory
it is contained into), it's a simple bash script. In order to start
a 6 nodes cluster with 3 masters and 3 slaves just type the following
commands:
create-cluster start
create-cluster create
Reply to yes
in step 2 when the redis-trib
utility wants you to accept
the cluster layout.
You can now interact with the cluster, the first node will start at port 30001 by default. When you are done, stop the cluster with:
create-cluster stop
.
Please read the README
inside this directory for more information on how
to run the script.
*Playing with the cluster
At this stage one of the problems with Redis Cluster is the lack of client libraries implementations.
I'm aware of the following implementations:
- redis-rb-cluster is a Ruby implementation written by me (@antirez) as a reference for other languages. It is a simple wrapper around the original redis-rb, implementing the minimal semantics to talk with the cluster efficiently.
- redis-py-cluster A port of redis-rb-cluster to Python. Supports majority of redis-py functionality. Is in active development.
- The popular Predis has support for Redis Cluster, the support was recently updated and is in active development.
- The most used Java client, Jedis recently added support for Redis Cluster, see the Jedis Cluster section in the project README.
- StackExchange.Redis offers support for C# (and should work fine with most .NET languages; VB, F#, etc)
- thunk-redis offers support for Node.js and io.js, it is a thunk/promise-based redis client with pipelining and cluster.
- redis-go-cluster is an implementation of Redis Cluster for the Go language using the Redigo library client as the base client. Implements MGET/MSET via result aggregation.
- The
redis-cli
utility in the unstable branch of the Redis repository at GitHub implements a very basic cluster support when started with the-c
switch.
An easy way to test Redis Cluster is either to try any of the above clients
or simply the redis-cli
command line utility. The following is an example
of interaction using the latter:
$ redis-cli -c -p 7000
redis <IP_ADDRESS>:7000> set foo bar
-> Redirected to slot [12182] located at <IP_ADDRESS>:7002
OK
redis <IP_ADDRESS>:7002> set hello world
-> Redirected to slot [866] located at <IP_ADDRESS>:7000
OK
redis <IP_ADDRESS>:7000> get foo
-> Redirected to slot [12182] located at <IP_ADDRESS>:7002
"bar"
redis <IP_ADDRESS>:7000> get hello
-> Redirected to slot [866] located at <IP_ADDRESS>:7000
"world"
Note: if you created the cluster using the script your nodes may listen to different ports, starting from 30001 by default.
The redis-cli cluster support is very basic so it always uses the fact that Redis Cluster nodes are able to redirect a client to the right node. A serious client is able to do better than that, and cache the map between hash slots and nodes addresses, to directly use the right connection to the right node. The map is refreshed only when something changed in the cluster configuration, for example after a failover or after the system administrator changed the cluster layout by adding or removing nodes.
*Writing an example app with redis-rb-cluster
Before going forward showing how to operate the Redis Cluster, doing things like a failover, or a resharding, we need to create some example application or at least to be able to understand the semantics of a simple Redis Cluster client interaction.
In this way we can run an example and at the same time try to make nodes failing, or start a resharding, to see how Redis Cluster behaves under real world conditions. It is not very helpful to see what happens while nobody is writing to the cluster.
This section explains some basic usage of redis-rb-cluster showing two
examples. The first is the following, and is the example.rb
file inside
the redis-rb-cluster distribution:
1 require './cluster'
2
3 startup_nodes = [
4 {:host => "<IP_ADDRESS>", :port => 7000},
5 {:host => "<IP_ADDRESS>", :port => 7001}
6 ]
7 rc = RedisCluster.new(startup_nodes,32,:timeout => 0.1)
8
9 last = false
10
11 while not last
12 begin
13 last = rc.get("__last__")
14 last = 0 if !last
15 rescue => e
16 puts "error #{e.to_s}"
17 sleep 1
18 end
19 end
20
21 ((last.to_i+1)..1000000000).each{|x|
22 begin
23 rc.set("foo#{x}",x)
24 puts rc.get("foo#{x}")
25 rc.set("__last__",x)
26 rescue => e
27 puts "error #{e.to_s}"
28 end
29 sleep 0.1
30 }
The application does a very simple thing, it sets keys in the form foo<number>
to number
, one after the other. So if you run the program the result is the
following stream of commands:
- SET foo0 0
- SET foo1 1
- SET foo2 2
- And so forth...
The program looks more complex than it should usually as it is designed to
show errors on the screen instead of exiting with an exception, so every
operation performed with the cluster is wrapped by begin
rescue
blocks.
The line 7 is the first interesting line in the program. It creates the Redis Cluster object, using as argument a list of startup nodes, the maximum number of connections this object is allowed to take against different nodes, and finally the timeout after a given operation is considered to be failed.
The startup nodes don't need to be all the nodes of the cluster. The important thing is that at least one node is reachable. Also note that redis-rb-cluster updates this list of startup nodes as soon as it is able to connect with the first node. You should expect such a behavior with any other serious client.
Now that we have the Redis Cluster object instance stored in the rc variable we are ready to use the object like if it was a normal Redis object instance.
This is exactly what happens in line 11 to 19: when we restart the example
we don't want to start again with foo0
, so we store the counter inside
Redis itself. The code above is designed to read this counter, or if the
counter does not exist, to assign it the value of zero.
However note how it is a while loop, as we want to try again and again even if the cluster is down and is returning errors. Normal applications don't need to be so careful.
Lines between 21 and 30 start the main loop where the keys are set or an error is displayed.
Note the sleep
call at the end of the loop. In your tests you can remove
the sleep if you want to write to the cluster as fast as possible (relatively
to the fact that this is a busy loop without real parallelism of course, so
you'll get the usually 10k ops/second in the best of the conditions).
Normally writes are slowed down in order for the example application to be easier to follow by humans.
Starting the application produces the following output:
ruby ./example.rb
1
2
3
4
5
6
7
8
9
^C (I stopped the program here)
This is not a very interesting program and we'll use a better one in a moment but we can already see what happens during a resharding when the program is running.
*Resharding the cluster
Now we are ready to try a cluster resharding. To do this please
keep the example.rb program running, so that you can see if there is some
impact on the program running. Also you may want to comment the sleep
call in order to have some more serious write load during resharding.
Resharding basically means to move hash slots from a set of nodes to another set of nodes, and like cluster creation it is accomplished using the redis-trib utility.
To start a resharding just type:
./redis-trib.rb reshard <IP_ADDRESS>:7000
You only need to specify a single node, redis-trib will find the other nodes automatically.
Currently redis-trib is only able to reshard with the administrator support, you can't just say move 5% of slots from this node to the other one (but this is pretty trivial to implement). So it starts with questions. The first is how much a big resharding do you want to do:
How many slots do you want to move (from 1 to 16384)?
We can try to reshard 1000 hash slots, that should already contain a non trivial amount of keys if the example is still running without the sleep call.
Then redis-trib needs to know what is the target of the resharding, that is, the node that will receive the hash slots. I'll use the first master node, that is, <IP_ADDRESS>:7000, but I need to specify the Node ID of the instance. This was already printed in a list by redis-trib, but I can always find the ID of a node with the following command if I need:
$ redis-cli -p 7000 cluster nodes | grep myself
97a3a64667477371c4479320d683e4c8db5858b1 :0 myself,master - 0 0 0 connected 0-5460
Ok so my target node is 97a3a64667477371c4479320d683e4c8db5858b1.
Now you'll get asked from what nodes you want to take those keys.
I'll just type all
in order to take a bit of hash slots from all the
other master nodes.
After the final confirmation you'll see a message for every slot that redis-trib is going to move from a node to another, and a dot will be printed for every actual key moved from one side to the other.
While the resharding is in progress you should be able to see your example program running unaffected. You can stop and restart it multiple times during the resharding if you want.
At the end of the resharding, you can test the health of the cluster with the following command:
./redis-trib.rb check <IP_ADDRESS>:7000
All the slots will be covered as usually, but this time the master at <IP_ADDRESS>:7000 will have more hash slots, something around 6461.
*Scripting a resharding operation
Reshardings can be performed automatically without the need to manually enter the parameters in an interactive way. This is possible using a command line like the following:
./redis-trib.rb reshard --from <node-id> --to <node-id> --slots <number of slots> --yes <host>:<port>
This allows to build some automatism if you are likely to reshard often,
however currently there is no way for redis-trib
to automatically
rebalance the cluster checking the distribution of keys across the cluster
nodes and intelligently moving slots as needed. This feature will be added
in the future.
*A more interesting example application
The example application we wrote early is not very good. It writes to the cluster in a simple way without even checking if what was written is the right thing.
From our point of view the cluster receiving the writes could just always
write the key foo
to 42
to every operation, and we would not notice at
all.
So in the redis-rb-cluster
repository, there is a more interesting application
that is called consistency-test.rb
. It uses a set of counters, by default 1000, and sends INCR commands in order to increment the counters.
However instead of just writing, the application does two additional things:
- When a counter is updated using INCR, the application remembers the write.
- It also reads a random counter before every write, and check if the value is what we expected it to be, comparing it with the value it has in memory.
What this means is that this application is a simple consistency checker, and is able to tell you if the cluster lost some write, or if it accepted a write that we did not receive acknowledgment for. In the first case we'll see a counter having a value that is smaller than the one we remember, while in the second case the value will be greater.
Running the consistency-test application produces a line of output every second:
$ ruby consistency-test.rb
925 R (0 err) | 925 W (0 err) |
5030 R (0 err) | 5030 W (0 err) |
9261 R (0 err) | 9261 W (0 err) |
13517 R (0 err) | 13517 W (0 err) |
17780 R (0 err) | 17780 W (0 err) |
22025 R (0 err) | 22025 W (0 err) |
25818 R (0 err) | 25818 W (0 err) |
The line shows the number of Reads and Writes performed, and the number of errors (query not accepted because of errors since the system was not available).
If some inconsistency is found, new lines are added to the output. This is what happens, for example, if I reset a counter manually while the program is running:
$ redis <IP_ADDRESS>:7000> set key_217 0
OK
(in the other tab I see...)
94774 R (0 err) | 94774 W (0 err) |
98821 R (0 err) | 98821 W (0 err) |
102886 R (0 err) | 102886 W (0 err) | 114 lost |
107046 R (0 err) | 107046 W (0 err) | 114 lost |
When I set the counter to 0 the real value was 114, so the program reports 114 lost writes (INCR commands that are not remembered by the cluster).
This program is much more interesting as a test case, so we'll use it to test the Redis Cluster failover.
*Testing the failover
Note: during this test, you should take a tab open with the consistency test application running.
In order to trigger the failover, the simplest thing we can do (that is also the semantically simplest failure that can occur in a distributed system) is to crash a single process, in our case a single master.
We can identify a cluster and crash it with the following command:
$ redis-cli -p 7000 cluster nodes | grep master
3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 <IP_ADDRESS>:7001 master - 0<PHONE_NUMBER>082 0 connected 5960-10921
2938205e12de373867bf38f1ca29d31d0ddb3e46 <IP_ADDRESS>:7002 master - 0<PHONE_NUMBER>582 0 connected 11423-16383
97a3a64667477371c4479320d683e4c8db5858b1 :0 myself,master - 0 0 0 connected 0-5959 10922-11422
Ok, so 7000, 7001, and 7002 are masters. Let's crash node 7002 with the DEBUG SEGFAULT command:
$ redis-cli -p 7002 debug segfault
Error: Server closed the connection
Now we can look at the output of the consistency test to see what it reported.
18849 R (0 err) | 18849 W (0 err) |
23151 R (0 err) | 23151 W (0 err) |
27302 R (0 err) | 27302 W (0 err) |
... many error warnings here ...
29659 R (578 err) | 29660 W (577 err) |
33749 R (578 err) | 33750 W (577 err) |
37918 R (578 err) | 37919 W (577 err) |
42077 R (578 err) | 42078 W (577 err) |
As you can see during the failover the system was not able to accept 578 reads and 577 writes, however no inconsistency was created in the database. This may sound unexpected as in the first part of this tutorial we stated that Redis Cluster can lose writes during the failover because it uses asynchronous replication. What we did not say is that this is not very likely to happen because Redis sends the reply to the client, and the commands to replicate to the slaves, about at the same time, so there is a very small window to lose data. However the fact that it is hard to trigger does not mean that it is impossible, so this does not change the consistency guarantees provided by Redis cluster.
We can now check what is the cluster setup after the failover (note that in the meantime I restarted the crashed instance so that it rejoins the cluster as a slave):
$ redis-cli -p 7000 cluster nodes
3fc783611028b1707fd65345e763befb36454d73 <IP_ADDRESS>:7004 slave 3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 0<PHONE_NUMBER>521 0 connected
a211e242fc6b22a9427fed61285e85892fa04e08 <IP_ADDRESS>:7003 slave 97a3a64667477371c4479320d683e4c8db5858b1 0<PHONE_NUMBER>023 0 connected
97a3a64667477371c4479320d683e4c8db5858b1 :0 myself,master - 0 0 0 connected 0-5959 10922-11422
3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e <IP_ADDRESS>:7005 master - 0<PHONE_NUMBER>023 3 connected 11423-16383
3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 <IP_ADDRESS>:7001 master - 0<PHONE_NUMBER>005 0 connected 5960-10921
2938205e12de373867bf38f1ca29d31d0ddb3e46 <IP_ADDRESS>:7002 slave 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 0<PHONE_NUMBER>016 3 connected
Now the masters are running on ports 7000, 7001 and 7005. What was previously a master, that is the Redis instance running on port 7002, is now a slave of 7005.
The output of the CLUSTER NODES command may look intimidating, but it is actually pretty simple, and is composed of the following tokens:
- Node ID
- ip:port
- flags: master, slave, myself, fail, ...
- if it is a slave, the Node ID of the master
- Time of the last pending PING still waiting for a reply.
- Time of the last PONG received.
- Configuration epoch for this node (see the Cluster specification).
- Status of the link to this node.
- Slots served...
*Manual failover
Sometimes it is useful to force a failover without actually causing any problem on a master. For example in order to upgrade the Redis process of one of the master nodes it is a good idea to failover it in order to turn it into a slave with minimal impact on availability.
Manual failovers are supported by Redis Cluster using the CLUSTER FAILOVER command, that must be executed in one of the slaves of the master you want to failover.
Manual failovers are special and are safer compared to failovers resulting from actual master failures, since they occur in a way that avoid data loss in the process, by switching clients from the original master to the new master only when the system is sure that the new master processed all the replication stream from the old one.
This is what you see in the slave log when you perform a manual failover:
# Manual failover user request accepted.
# Received replication offset for paused master manual failover: 347540
# All master replication stream processed, manual failover can start.
# Start of election delayed for 0 milliseconds (rank #0, offset 347540).
# Starting a failover election for epoch 7545.
# Failover election won: I'm the new master.
Basically clients connected to the master we are failing over are stopped. At the same time the master sends its replication offset to the slave, that waits to reach the offset on its side. When the replication offset is reached, the failover starts, and the old master is informed about the configuration switch. When the clients are unblocked on the old master, they are redirected to the new master.
*Adding a new node
Adding a new node is basically the process of adding an empty node and then moving some data into it, in case it is a new master, or telling it to setup as a replica of a known node, in case it is a slave.
We'll show both, starting with the addition of a new master instance.
In both cases the first step to perform is adding an empty node.
This is as simple as to start a new node in port 7006 (we already used from 7000 to 7005 for our existing 6 nodes) with the same configuration used for the other nodes, except for the port number, so what you should do in order to conform with the setup we used for the previous nodes:
- Create a new tab in your terminal application.
- Enter the
cluster-test
directory. - Create a directory named
7006
. - Create a redis.conf file inside, similar to the one used for the other nodes but using 7006 as port number.
- Finally start the server with
../redis-server ./redis.conf
At this point the server should be running.
Now we can use redis-trib as usually in order to add the node to the existing cluster.
./redis-trib.rb add-node <IP_ADDRESS>:7006 <IP_ADDRESS>:7000
As you can see I used the add-node command specifying the address of the new node as first argument, and the address of a random existing node in the cluster as second argument.
In practical terms redis-trib here did very little to help us, it just sent a CLUSTER MEET message to the node, something that is also possible to accomplish manually. However redis-trib also checks the state of the cluster before to operate, so it is a good idea to perform cluster operations always via redis-trib even when you know how the internals work.
Now we can connect to the new node to see if it really joined the cluster:
redis <IP_ADDRESS>:7006> cluster nodes
3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 <IP_ADDRESS>:7001 master - 0<PHONE_NUMBER>575 0 connected 5960-10921
3fc783611028b1707fd65345e763befb36454d73 <IP_ADDRESS>:7004 slave 3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 0<PHONE_NUMBER>583 0 connected
f093c80dde814da99c5cf72a7dd01590792b783b :0 myself,master - 0 0 0 connected
2938205e12de373867bf38f1ca29d31d0ddb3e46 <IP_ADDRESS>:7002 slave 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 0<PHONE_NUMBER>072 3 connected
a211e242fc6b22a9427fed61285e85892fa04e08 <IP_ADDRESS>:7003 slave 97a3a64667477371c4479320d683e4c8db5858b1 0<PHONE_NUMBER>575 0 connected
97a3a64667477371c4479320d683e4c8db5858b1 <IP_ADDRESS>:7000 master - 0<PHONE_NUMBER>080 0 connected 0-5959 10922-11422
3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e <IP_ADDRESS>:7005 master - 0<PHONE_NUMBER>568 3 connected 11423-16383
Note that since this node is already connected to the cluster it is already able to redirect client queries correctly and is generally speaking part of the cluster. However it has two peculiarities compared to the other masters:
- It holds no data as it has no assigned hash slots.
- Because it is a master without assigned slots, it does not participate in the election process when a slave wants to become a master.
Now it is possible to assign hash slots to this node using the resharding
feature of redis-trib
. It is basically useless to show this as we already
did in a previous section, there is no difference, it is just a resharding
having as a target the empty node.
*Adding a new node as a replica
Adding a new Replica can be performed in two ways. The obvious one is to use redis-trib again, but with the --slave option, like this:
./redis-trib.rb add-node --slave <IP_ADDRESS>:7006 <IP_ADDRESS>:7000
Note that the command line here is exactly like the one we used to add a new master, so we are not specifying to which master we want to add the replica. In this case what happens is that redis-trib will add the new node as replica of a random master among the masters with less replicas.
However you can specify exactly what master you want to target with your new replica with the following command line:
./redis-trib.rb add-node --slave --master-id 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e <IP_ADDRESS>:7006 <IP_ADDRESS>:7000
This way we assign the new replica to a specific master.
A more manual way to add a replica to a specific master is to add the new node as an empty master, and then turn it into a replica using the CLUSTER REPLICATE command. This also works if the node was added as a slave but you want to move it as a replica of a different master.
For example in order to add a replica for the node <IP_ADDRESS>:7005 that is currently serving hash slots in the range 11423-16383, that has a Node ID 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e, all I need to do is to connect with the new node (already added as empty master) and send the command:
redis <IP_ADDRESS>:7006> cluster replicate 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e
That's it. Now we have a new replica for this set of hash slots, and all the other nodes in the cluster already know (after a few seconds needed to update their config). We can verify with the following command:
$ redis-cli -p 7000 cluster nodes | grep slave | grep 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e
f093c80dde814da99c5cf72a7dd01590792b783b <IP_ADDRESS>:7006 slave 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 0<PHONE_NUMBER>702 3 connected
2938205e12de373867bf38f1ca29d31d0ddb3e46 <IP_ADDRESS>:7002 slave 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 0<PHONE_NUMBER>198 3 connected
The node 3c3a0c... now has two slaves, running on ports 7002 (the existing one) and 7006 (the new one).
*Removing a node
To remove a slave node just use the del-node
command of redis-trib:
./redis-trib del-node <IP_ADDRESS>:7000 `<node-id>`
The first argument is just a random node in the cluster, the second argument is the ID of the node you want to remove.
You can remove a master node in the same way as well, however in order to remove a master node it must be empty. If the master is not empty you need to reshard data away from it to all the other master nodes before.
An alternative to remove a master node is to perform a manual failover of it over one of its slaves and remove the node after it turned into a slave of the new master. Obviously this does not help when you want to reduce the actual number of masters in your cluster, in that case, a resharding is needed.
*Replicas migration
In Redis Cluster it is possible to reconfigure a slave to replicate with a different master at any time just using the following command:
CLUSTER REPLICATE <master-node-id>
However there is a special scenario where you want replicas to move from one master to another one automatically, without the help of the system administrator. The automatic reconfiguration of replicas is called replicas migration and is able to improve the reliability of a Redis Cluster.
Note: you can read the details of replicas migration in the Redis Cluster Specification, here we'll only provide some information about the general idea and what you should do in order to benefit from it.
The reason why you may want to let your cluster replicas to move from one master to another under certain condition, is that usually the Redis Cluster is as resistant to failures as the number of replicas attached to a given master.
For example a cluster where every master has a single replica can't continue operations if the master and its replica fail at the same time, simply because there is no other instance to have a copy of the hash slots the master was serving. However while netsplits are likely to isolate a number of nodes at the same time, many other kind of failures, like hardware or software failures local to a single node, are a very notable class of failures that are unlikely to happen at the same time, so it is possible that in your cluster where every master has a slave, the slave is killed at 4am, and the master is killed at 6am. This still will result in a cluster that can no longer operate.
To improve reliability of the system we have the option to add additional replicas to every master, but this is expensive. Replica migration allows to add more slaves to just a few masters. So you have 10 masters with 1 slave each, for a total of 20 instances. However you add, for example, 3 instances more as slaves of some of your masters, so certain masters will have more than a single slave.
With replicas migration what happens is that if a master is left without slaves, a replica from a master that has multiple slaves will migrate to the orphaned master. So after your slave goes down at 4am as in the example we made above, another slave will take its place, and when the master will fail as well at 5am, there is still a slave that can be elected so that the cluster can continue to operate.
So what you should know about replicas migration in short?
- The cluster will try to migrate a replica from the master that has the greatest number of replicas in a given moment.
- To benefit from replica migration you have just to add a few more replicas to a single master in your cluster, it does not matter what master.
- There is a configuration parameter that controls the replica migration feature that is called
cluster-migration-barrier
: you can read more about it in the exampleredis.conf
file provided with Redis Cluster.
*Upgrading nodes in a Redis Cluster
Upgrading slave nodes is easy since you just need to stop the node and restart it with an updated version of Redis. If there are clients scaling reads using slave nodes, they should be able to reconnect to a different slave if a given one is not available.
Upgrading masters is a bit more complex, and the suggested procedure is:
- Use CLUSTER FAILOVER to trigger a manual failover of the master to one of its slaves (see the "Manual failover" section of this documentation).
- Wait for the master to turn into a slave.
- Finally upgrade the node as you do for slaves.
- If you want the master to be the node you just upgraded, trigger a new manual failover in order to turn back the upgraded node into a master.
Following this procedure you should upgrade one node after the other until all the nodes are upgraded.
*Migrating to Redis Cluster
Users willing to migrate to Redis Cluster may have just a single master, or may already using a preexisting sharding setup, where keys are split among N nodes, using some in-house algorithm or a sharding algorithm implemented by their client library or Redis proxy.
In both cases it is possible to migrate to Redis Cluster easily, however what is the most important detail is if multiple-keys operations are used by the application, and how. There are three different cases:
- Multiple keys operations, or transactions, or Lua scripts involving multiple keys, are not used. Keys are accessed independently (even if accessed via transactions or Lua scripts grouping multiple commands, about the same key, together).
- Multiple keys operations, transactions, or Lua scripts involving multiple keys are used but only with keys having the same hash tag, which means that the keys used together all have a
{...}
sub-string that happens to be identical. For example the following multiple keys operation is defined in the context of the same hash tag:SUNION {user:1000}.foo {user:1000}.bar
. - Multiple keys operations, transactions, or Lua scripts involving multiple keys are used with key names not having an explicit, or the same, hash tag.
The third case is not handled by Redis Cluster: the application requires to be modified in order to don't use multi keys operations or only use them in the context of the same hash tag.
Case 1 and 2 are covered, so we'll focus on those two cases, that are handled in the same way, so no distinction will be made in the documentation.
Assuming you have your preexisting data set split into N masters, where N=1 if you have no preexisting sharding, the following steps are needed in order to migrate your data set to Redis Cluster:
- Stop your clients. No automatic live-migration to Redis Cluster is currently possible. You may be able to do it orchestrating a live migration in the context of your application / environment.
- Generate an append only file for all of your N masters using the BGREWRITEAOF command, and waiting for the AOF file to be completely generated.
- Save your AOF files from aof-1 to aof-N somewhere. At this point you can stop your old instances if you wish (this is useful since in non-virtualized deployments you often need to reuse the same computers).
- Create a Redis Cluster composed of N masters and zero slaves. You'll add slaves later. Make sure all your nodes are using the append only file for persistence.
- Stop all the cluster nodes, substitute their append only file with your pre-existing append only files, aof-1 for the first node, aof-2 for the second node, up to aof-N.
- Restart your Redis Cluster nodes with the new AOF files. They'll complain that there are keys that should not be there according to their configuration.
- Use
redis-trib fix
command in order to fix the cluster so that keys will be migrated according to the hash slots each node is authoritative or not. - Use
redis-trib check
at the end to make sure your cluster is ok. - Restart your clients modified to use a Redis Cluster aware client library.
There is an alternative way to import data from external instances to a Redis
Cluster, which is to use the redis-trib import
command.
The command moves all the keys of a running instance (deleting the keys from the source instance) to the specified pre-existing Redis Cluster. However note that if you use a Redis 2.8 instance as source instance the operation may be slow since 2.8 does not implement migrate connection caching, so you may want to restart your source instance with a Redis 3.x version before to perform such operation.


 It temporarily takes ownwership of reference-counted objects that nobody else wants to take ownership of and releases them at a later, appropriate point in time.
Note: The correct way to add an object hold by an AutoPtr<> to an AutoReleasePool is by invoking the AutoPtr's duplicate() method. Example:
AutoReleasePool<C> arp; AutoPtr<C> ptr = new C; ... arp.add(ptr.duplicate());
Member Summary
Member Functions: add, release
Constructors
AutoReleasePool
Creates the AutoReleasePool.
Destructor
~AutoReleasePool
~AutoReleasePool();
Destroys the AutoReleasePool and releases all objects it currently holds.
Member Functions
add
void add(
C * pObject
);
Adds the given object to the AutoReleasePool. The object's reference count is not modified
release
void release();
Releases all objects the AutoReleasePool currently holds by calling each object's release() method.


How to embed a Power BI report into a web page by JavaScript
WorkspaceCollectionName:
AccessKey:
Get Workspaces
Workspaces:
Reports:
Embed


Name
Add Event Type
HomelessCR_stable_house
OR
AND
HomelessCR_stable_house
OR
AND
OR
HomelessCR_stable_worry
OR
AND
AND
HomelessCR_live_2mos
OR
AND
AND
Traumatic Brain Injury Consult Order
Add Consult
Positive Depression Screen
Add Dashboard Alert
POSITIVE - HAS WORRIES ABOUT HOUSING
Add Health Factor
Taking care of your household responsibilities?
Show Question
Event Type
Select Consult
Save
Events
Add And Condition
Add Or Condition
Expression
Error Message
Add New Block
Edit <Rule Name> Rule
Help
U.S. Department of Veterans Affairs | eScreening Health Assessment (Ver 1.0)
Welcome Last Name, First Name | Logout
* This wireframe provide the workflow, the structure, and the interaction between some specific pages and sections in the eScreening project and it's covered all the interaction between the application features and behaviours.
* Some of the interaction between pages may require using a specific rules and steps in order to demonstrate.
* This wireframe still in progress.
IMPORTANT NOTE - Click to Expand
For demo purpose please follow the below steps
Click Add New Block to insert Text or If block
Click Add Button to add Else condition after step 3 completed
Notes / Requirements
User will be able to drag and drop blocks with limitations in some cases such as else
Click for Screen Notes / Wireframe Notes:
Manage Block
dep_score_phq2
+
OR
AND
Block Type
Block Name
AND
OR
AND
Select Variable
Variable
Display Name
Type
Insert
demo_firstname
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
dep_score_phq9
Question
Select
dep1_interest
Question
Select
dep2_down
Question
Select
dep3_sleep
Question
Select
dep4_tired
Question
Select
dep5_appetite
Question
Select
dep6_feelbad
Question
Select
dep7_concentrate
Question
Select
dep8_moveslow
Question
Select
dep9_dead
Question
Select
dep10_difficult
Question
Select
dep_score_phq2
Question
Select
Variable List
1
1
Variable
Display Name
Type
Insert
appointments
appointments
Custom
Select
demo_DOB
Date of Birth
Free Text
Select
table_var
-
Table
Select
matrix_var
-
Select Multi Matrix
Select
2
2
+ Add Variable
+ Add Variable
OR
AND
Select Variable
Variable
Display Name
Type
Insert
demo_firstname
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
dep_score_phq9
Question
Select
dep1_interest
Question
Select
dep2_down
Question
Select
dep3_sleep
Question
Select
dep4_tired
Question
Select
dep5_appetite
Question
Select
dep6_feelbad
Question
Select
dep7_concentrate
Question
Select
dep8_moveslow
Question
Select
dep9_dead
Question
Select
dep10_difficult
Question
Select
dep_score_phq2
Question
Select
1
1
Variable
Display Name
Type
Insert
appointments
appointments
Custom
Select
demo_DOB
Date of Birth
Free Text
Select
table_var
-
Table
Select
matrix_var
-
Select Multi Matrix
Select
2
2
Variable List
Else
Variable
Display Name
Type
Insert
demo_firstname
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
dep_score_phq9
Question
Select
dep1_interest
Question
Select
dep2_down
Question
Select
dep3_sleep
Question
Select
dep4_tired
Question
Select
dep5_appetite
Question
Select
dep6_feelbad
Question
Select
dep7_concentrate
Question
Select
dep8_moveslow
Question
Select
dep9_dead
Question
Select
dep10_difficult
Question
Select
dep_score_phq2
Question
Select
Variable List
1
1
Variable
Display Name
Type
Insert
appointments
appointments
Custom
Select
demo_DOB
Date of Birth
Free Text
Select
table_var
-
Table
Select
matrix_var
-
Select Multi Matrix
Select
2
2
Manage Block
Block Name
AND
Select Variable
Variable
Display Name
Type
Insert
demo_firstname
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
dep_score_phq9
Question
Select
dep1_interest
Question
Select
dep2_down
Question
Select
dep3_sleep
Question
Select
dep4_tired
Question
Select
dep5_appetite
Question
Select
dep6_feelbad
Question
Select
dep7_concentrate
Question
Select
dep8_moveslow
Question
Select
dep9_dead
Question
Select
dep10_difficult
Question
Select
dep_score_phq2
Question
Select
1
1
Variable
Display Name
Type
Insert
appointments
appointments
Custom
Select
demo_DOB
Date of Birth
Free Text
Select
table_var
-
Table
Select
matrix_var
-
Select Multi Matrix
Select
2
2
Variable List
+ Add Variable
OR
AND
Event Type
Block Type
Select Variable
Variable
Display Name
Type
Insert
demo_firstname1
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
dep_score_phq9
Question
Select
dep1_interest
Question
Select
dep2_down
Question
Select
dep3_sleep
Question
Select
dep4_tired
Question
Select
dep5_appetite
Question
Select
dep6_feelbad
Question
Select
dep7_concentrate
Question
Select
dep8_moveslow
Question
Select
dep9_dead
Question
Select
dep10_difficult
Question
Select
dep_score_phq2
Question
Select
1
1
Variable List
Variable
Display Name
Type
Insert
appointments
appointments
Custom
Select
demo_DOB
Date of Birth
Free Text
Select
table_var
-
Table
Select
matrix_multi_var
-
Select Multi Matrix
Select
matrix_one_var
-
Select Multi One
Select
2
2
+ Add Variable
OR
AND
Select Variable
Variable
Display Name
Type
Insert
demo_firstname
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
dep_score_phq9
Question
Select
dep1_interest
Question
Select
dep2_down
Question
Select
dep3_sleep
Question
Select
dep4_tired
Question
Select
dep5_appetite
Question
Select
dep6_feelbad
Question
Select
dep7_concentrate
Question
Select
dep8_moveslow
Question
Select
dep9_dead
Question
Select
dep10_difficult
Question
Select
dep_score_phq2
Question
Select
1
1
Variable
Display Name
Type
Insert
appointments
appointments
Custom
Select
demo_DOB
Date of Birth
Free Text
Select
table_var
-
Table
Select
matrix_var
-
Select Multi Matrix
Select
2
2
+ Add Variable
OR
AND
Select Variable
Variable
Display Name
Type
Insert
demo_firstname
First Name
Question
Select
assigned_clinician
Assigned Clinician
Custom
Select
-
PTSD Formula
Formula
Select
demo_va_concerns
Presenting Concerns
Question
Select
dep_score_phq9
Question
Select
dep1_interest
Question
Select
dep2_down
Question
Select
dep3_sleep
Question
Select
dep4_tired
Question
Select
dep5_appetite
Question
Select
dep6_feelbad
Question
Select
dep7_concentrate
Question
Select
dep8_moveslow
Question
Select
dep9_dead
Question
Select
dep10_difficult
Question
Select
dep_score_phq2
Question
Select
Variable List
1
1
Variable
Display Name
Type
Insert
appointments
appointments
Custom
Select
demo_DOB
Date of Birth
Free Text
Select
table_var
-
Table
Select
matrix_var
-
Select Multi Matrix
Select
2
2
Delete Block
Are you sure you want to delete this Block? That's may delete any other sub blocks.


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| Action<T> | Action is a wrapper for a void returning
method. |
| Class Summary | |
|---|---|
| ActionPredicate<T> | ActionPredicate is a combination of an
Action and a Predicate . |
| BoolMCell | BoolMCell is a mutable cell with boolean content. |
| CachedFunction<TArg,TRes> | CachedFunction is a caching wrapper around a (presumably pure) function. |
| Debug | Debug contains some simple debugging methods. |
| EqualityPredicate<T> | EqualityPredicate is a simple predicate that checks
equality with a reference element. |
| Function<TArg,TRes> | Function is a wrapper around a function that takes a
TArg and returns a TRes . |
| IdentityWrapper<T> | IdentityWrapper is useful when you want to assign some
information to each object, not to each class of equal objects. |
| IdFunction<T> | IdFunction - identity function |
| IntMCell | IntMCell is a mutable cell with integer content. |
| LongMCell | LongMCell is a mutable cell with long content. |
| MCell<T> | MCell is a mutable cell with content of type
T . |
| Predicate<T> | Predicate wraps a boolean predicate. |
| SetMembership<T> | SetMembership is a predicate that checks whether an
element is member of a specific set. |
| UComp<T> | UComp is an universal comparator, which compares any two
objecs by simply comparing their string representation. |
Miscellaneous useful classes.
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Visual Persuasions Canada
Legal Name:
Visual Persuasions Canada
Operating Name:
Pam Ivey International
Mailing Address:
24 Kelley CresWASAGA BEACH, Ontario
L9Z 1J3
Location Address:
24 Kelley CresWASAGA BEACH, Ontario
L9Z 1J3
Tel.:<PHONE_NUMBER>
Fax:
Logo
Company Profile
We make Online Marketing (understanding, doing + managing), easier. And we’ve been doing it for nearly 15 years.
Do you have a case of the shoulds?
I should advertise on Facebook.
I should be tracking my website stats.
I should be creating more content.
I should be posting to social media more often, and so on, and so on.

Is there a course me or my team member could take that cuts through to the core of online marketing and serves up only the most important parts?
Sure is.
We offer a variety of online marketing training programs, Live workshops and VIP strategy sessions, limited personal coaching and speaking in such areas as marketing funnels, content marketing, social media, search engine optimization, mobile marketing, web analytics and conversion optimization.
If those phrases make your eyes glaze over, you’re not alone. But you’re in the right place.
Our training is delivered in a variety of formats in layperson’s terms, without insulting your intelligence.
Since 2001, Pam Ivey International has worked in the frantic race pits, faced the demons, dug deep during challenging times, and savoured the victories of the online marketing world to get to a place where putting you in the driver’s seat has become its over-arching creed.
Simply put, our legacy of experience has given us the inside track on what online marketing is, how it works and how it can drive your business forward.
Best of all, for you, we completely demystify the process.
And we don’t keep secrets.
You (or your team member or employee) can learn this process in a variety of ways, whether you’re new to online marketing or you need a refresher boost.
So go ahead. Take our REV™ Assessment, explore our learning opportunities and get in touch with any questions you have. We look forward to supporting you right from the green flag straight through to the checkered one!
Now here’s a few words about our stellar track team…
About Pam Ivey
I’ve been working online since 2001, and in that time, I’ve watched the way we do business be turned upside-down, sideways, and spun ’round and ’round.
Things in the online world seem to change in the blink of an eye. Some people embrace the changes but most just get totally freaked out. A new Google algorithm? WHAT is heck is an algorithm? Changing from HTML to WordPress… Whaaaa…? I just kinda figured out HTML… Mobile marketing? How the heck am I going to keep up with it all???
I can help. I am PASSIONATE about all things online marketing. I find it fascinating, stimulating, and even FUN!
After the death of my husband and the love of my life in 2012, and after I took a number of months away from my business to work through my grief, I decided that because Rob was such an incredible giver, I wanted to carry that on. Instead of changing the lives and businesses of a handful of clients each year, I wanted to create a veritable army of high-level service professionals, and that’s why my Online Marketing Manager Certification program was created.
Pam IveySoon after, a number of colleagues began to ask me when I was going to create a program for business owners to up-level their own online marketing. Hmm…. what a GREAT idea!
So now, I’m pleased to introduce the REV It Up + Convert! group coaching program: Use the REV Formula to accelerate your online marketing engine to power up sales, dominate loyalty, and fire up business growth in today’s noisy marketplace.
It’s a comprehensive program that covers the most critical areas a business owner needs to know in order to capitalize on the biggest business asset in modern history… the Internet.
How do you get into my community? Simply grab a copy of my Online Marketing Toolkit, and I’ll keep you in the know!
Professional Community Involvement
- Evolutionary Business Council
- IMPACT for Coaches
- Women Speakers Association
About the Pam Ivey International Team
Kate (Kathy A.) Smith, Online Business Manager, Copywriter, Editor, Online Marketing Success Magazine
Kate Smith is a born organizer, master virtual assistant with over a decade of experience, and an exceptional project manager.
A seasoned interviewer and prolific writer, she has authored more than 150 newspaper and magazine articles for both mainstream publications, including Reader’s Digest, as well as maritime industry trade journals. Kate also writes B2B and B2C marketing copy for a wide variety of clients.
Kelly Brown, Customer Service, Copywriter, Support
Kelly Brown comes to Pam Ivey International with 25 years of business experience in the fields of real estate, health care, aerospace and education. A former business owner herself, Kelly understands what it takes to launch a successful business and the dedication and work required to keep you and your business in the fast lane. Kelly’s passion is in organization, process writing, content editing and business systems.
Stephanie Watson, Copywriter
Stephanie Watson has more than 20 years experience working from home in a variety of roles such as HTML Website Designer, Internet Marketer, Template Bender, and Virtual Assistant.
Today she is an author and content strategist who organizes, plans, writes and impements content strategies for business owners through her business Barry Publishing.
Mary Greenlees, Art Director, Online Marketing Success Magazine & Graphic Designer Extraordinaire
Mary Greenlees is a design visionary who brings almost 30 years of experience in graphic design and printing to the countless creative projects she’s produced for a global clientele.
She has a innate knack for listening first, then providing valuable input and direction, which results in designs that are exactly what her customers are looking for.
Full profile
Full profile
Contact information
Company description
541510 - Computer Systems Design and Related Services
541619 - Other Management Consulting Services
541899 - All Other Services Related to Advertising
611710 - Educational Support Services
Product / Service / Licensing
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
541510 - Computer Systems Design and Related Services
541619 - Other Management Consulting Services
541899 - All Other Services Related to Advertising
611710 - Educational Support Services


Get Docker Swarm
Estimated reading time: 4 minutesYou are viewing docs for legacy standalone Swarm. These topics describe standalone Docker Swarm. In Docker 1.12 and higher, Swarm mode is integrated with Docker Engine. Most users should use integrated Swarm mode — a good place to start is Getting started with swarm mode, Swarm mode CLI commands, and the Get started with Docker walkthrough). Standalone Docker Swarm is not integrated into the Docker Engine API and CLI commands.
You can create a Docker Swarm cluster using the swarm
executable image from a
container or using an executable swarm
binary you install on your system. This
page introduces the two methods and discusses their pros and cons.
Create a cluster with an interactive container
You can use the Docker Swarm official image to create a cluster. The image is
built by Docker and updated regularly through an automated build. To use the
image, you run it a container via the Engine docker run
command. The image has
multiple options and subcommands you can use to create and manage a Swarm cluster.
The first time you use any image, Docker Engine checks to see if you already have the image in your environment. By default Docker runs the swarm:latest
version but you can also specify a tag other than latest
. If you have an image locally but a newer one exists on Docker Hub, Engine downloads it.
Run the Swarm image from a container
-
Open a terminal on a host running Engine.
If you are using Mac or Windows, then you must make sure you have started a Docker Engine host running and pointed your terminal environment to it with the Docker Machine commands. If you aren’t sure, you can verify:
$ docker-machine ls NAME ACTIVE URL STATE URL SWARM DOCKER ERRORS default * virtualbox Running tcp://<IP_ADDRESS>:2376 v1.9.1
This shows an environment running an Engine host on the
default
instance. -
Use the
swarm
image to execute a command.The easiest command is to get the help for the image.  A Docker-native clustering system Version: 1.0.1 (744e3a3) Options: --debug debug mode [$DEBUG] --log-level, -l "info" Log level (options: debug, info, warn, error, fatal, panic) --help, -h show help --version, -v print the version Commands: create, c Create a cluster list, l List nodes in a cluster manage, m Manage a docker cluster join, j join a docker cluster help, h Shows a list of commands or help for one command Run 'swarm COMMAND --help' for more information on a command.
In this example, the
swarm
image did not exist on the Engine host, so the Engine downloaded it. After it downloaded, the image executed thehelp
subcommand to display the help text. After displaying the help, theswarm
image exits and returns you to your terminal command line. -
List the running containers on your Engine host.
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
Swarm is no longer running. The
swarm
image exits after you issue it a command.
Why use the image?
Using a Swarm container has three key benefits over other methods:
- You don’t need to install a binary on the system to use the image.
- The single command
docker run
gets and runs the most recent version of the image every time. - The container isolates Swarm from your host environment. You don’t need to perform or maintain shell paths and environments.
Running the Swarm image is the recommended way to create and manage your Swarm cluster. All of Docker’s documentation and tutorials use this method.
Run a Swarm binary
Before you run a Swarm binary directly on a host operating system (OS), you compile the binary from the source code or get a trusted copy from another location. Then you run the Swarm binary.
To compile Swarm from source code, refer to the instructions in CONTRIBUTING.md.
Why use the binary?
Using a Swarm binary this way has one key benefit over other methods: If you are a developer who contributes to the Swarm project, you can test your code changes without “containerizing” the binary before you run it.
Running a Swarm binary on the host OS has disadvantages:
- Compilation from source is a burden.
- The binary doesn’t have the benefits that Docker containers provide, such as isolation.
- Most Docker documentation and tutorials don’t show this method of running swarm.
Lastly, because the Swarm nodes don’t use Engine, you can’t use Docker-based software tools, such as Docker Engine CLI at the node level.
Related information
- Docker Swarm official image repository on Docker Hub
- Provision a Swarm with Docker Machine


Fraction Analysis
Options
Protein Confidence MW (%):
the protein confidence, in percent, for inclusion in MW plots in the Fractions panel.
Go to top of page


sixandeight's products
DUMPS+ PIN PACK TR1+TR2 PACKAGE TUTORIAL...
Apple No Limit,Latest Working method.
YES, STRIPE CASHOUT METHOD TESTED WORKIN...
The best method to Card Apple App Store...
Bitcoin Stealer & Mass Generator
Quality Residential RDP( the best price ...
CONFIRMED $2,000+ DAILY WEBMONEY CASHOUT...
TWO BIGGEST AUTOSHOPS FOR ACCOUNTS READ...
MAKE $2K DAILY- GOOGLE PLAY CASHOUT.
HOW TO GET BITCOINS WITH AMAZON GIFT CAR...
THE FBI HACKING AND FORENSIC TOOLKIT HAC...
WORKING E-GIFT CARDS CARDING METHOD
BYPASS CELL PHONE SCREEN LOCK EASY
Adobe Photoshop CS6 x64 Portable Usb
The best for now, CC TO BTC Cashout 2.0....
ULTIMATE FULLZ CARDING SETUP 2.0 - PLUG ...
Current (2020) APPLE PAY CARDING MAKE T...
Confirmed Professional Carding Software ...
Coinbase Cashout guide.
CONFIRMED LAYERED CASH: EARN MINIMUM $45...
CARDING E-GIFT CARD TUTORIAL - CONFIRMED...
PayPal Cashout Video
Facebook & Instagram Pass Hacker !! Chec...
HOW TO PURCHASE BITCOIN EASILY USING HAC...
Download 10000 business email pass crack...
How To Create Online Bank Account
Email Sender Deluxe v. 2.35
MAKE BIG MONEY WITH BANK LOGINS.
BUSINESS NAME+ADDRESS+EIN+FULLZ
HawkEye Keylogger Cracked -Hacking Tool-...


/**
* Represents a single Neuron to be used in an artificial neural network.
* @param {number} numOfInputs - Is the number of inputs this neuron will have.
* @param {array} weights - An array to hold the weights of each input.
* @author Donnie Marges<EMAIL_ADDRESS>* @version 0.0.1
*/
function Neuron(numOfInputs, weights) {
/** Since params are required, if we don't get them we just return undefined. */
if(!numOfInputs || !weights) {
return;
}
/** Set instance variables. */
this.numberOfInputs = numOfInputs;
this.weights = weights;
}


Set in an alternate universe filled with ancient creatures of the Triassic, Jurassic and Cretaceous periods of the Mesozoic era, you play as a huntress named Artemis. The Earth is split into 3 large continents; Triassica, Jurassica and Cretaceia, each filled with the animals from each Mesozoic period. The player, or Artemis, begins their journey in the Triassic continent, Triassica, where their tribe has been wiped out by a strange and dangerous creature which had disappeared just as mysteriously as it had appeared. Artemis must complete quests and rebuild civilisation with an ambitious amount of side quests and main quests. Collect resources, craft tools, befriend tribes, tame creatures, build villages, discover landmarks, gather resources, escape angry tribes; Artemis’ adventures are endless.
Artemis began with the design of the protagonist, Artemis. From there, a world and story behind Artemis just came to life; I thought, ‘How cool would it be if people got to experience Artemis’ adventure themselves?’.
After working on the design of the character, the world, the enemies, and all the inner workings of the story and narrative, my team and I began working on the practical of the game. Where would the player begin? Would there be cut-scenes? What would the first quests be? What assets do we need to start work on?
Beginning the asset design and models were quite easy, it was putting them all together in a game format that was actually playable that was hard. We used Maya to model, and Unreal Engine 4 to build the environment of the game itself.
The style behind Artemis took great inspiration from the Legend of Zelda series games (more specifically, Breath of the Wild and Skyward Sword). The designs and models are realistic yet simplistic, a mixture of cartoonistic and lifelike appearances. This not only provided the game with a comfortable look and feel, it made the modelling and texturing process much easier.
The ideas and planning process lasted just under two months. It seems like a while, but I had the job of designing and planning the characters, environment, story and plot, style of the game, enemies the player would face, working out finances and timelines of work.
After this process, the REAL work for everything practical with the game took my team and I around a year and a half (this was for the planning and creation of assets and extra 3D models). The following year and a half after was spent putting our game world together and working on programming, with another few months after spent working on gathering music, sound effects, voice acting --pretty much all of the audio-- and putting that into the game. The games overall budget was $500,000.
Finally, after a long lasting amount of work and effort, Artemis is set to available for purchase on October 19, 2021 on Steam, Xbox and PlayStation.
Student
The recent digital media projects that I’ve created and polished off at Assumption College are a 3D modelled game asset (a pair of steampunk goggles) and a game environment (an awesome medieval themed bedroom), designing and coding a website completely from scratch, designing and drawing a game character in my own style, and finally doing some 2D animation and making my own game trailer.
I’ve worked on all my projects (personal and school-related) using Autodesk Maya, Unreal Engine 4, Adobe Photoshop, Adobe Illustrator, Adobe Dreamweaver, Adobe Animate, and Adobe After Effects
I’ve had an interest in drawing and creating things for about as long as I can remember, and I’ve only grown more interested as I’ve gotten older. And thanks to being in school where there are courses and classes that peak this interest, I’ve found myself drawn to digital media as a whole. Things that continously inspire me and keep me invested in digital media is probably indie games and also digital artists that I follow online.
My favourite game studio is Blizzard Entertainment. The games they’ve created over time that have gotten a lot of fan-love is admiring, and I’m a big fan their animations released on YouTube that explore more of the characters and game lores. My favourite individual game developer, however, is either Toby Fox or Scott Cawthorn; two guys who created their own games from scratch, quite inspiring if you ask me.
By far drawing and creating characters, writing my own stories and narratives, playing video games (of course), reading online novels and comics


nested-data-explorer
NBA Example
Nested data explorer for 2020 NBA statistics through Jan 1st (
data
). Code, details and documentation are available on
github
.


In this tutorial we are going to process several 5° wedges of thermolysin data, taken from multiple crystals, first using xia2 to process the images using the XDS pipeline, and then use BLEND on the resulting processed reflection files to analyse the datasets for non-isomorphism.
First we need to type several commands in order to make available all the software we need for the tutorial:
# make XDS available
module load XDS
# get the latest version of CCP4
module load ccp4
# get latest combined DIALS/xia2
module load dials/dev-228
# needed by BLEND
module load R
Next we have the xia2 command to run. Below we explain in detail the meaning of each parameter:
xia2 -3dii -failover \
mode=parallel njob=4 nproc=1 \
trust_beam_centre=True read_all_image_headers=False \
unit_cell="92.73 92.73 128.13 90.00 90.00 120.00" \
space_group=P6122 -atom X \
/dls/mx-scratch/mx_bag_training/thermolysin/
This command will run all the processing on a single computer. Assuming the computer has 4 processors available, we have set njob=4. If the computer we are using has more processors available, we may increase either njob or nproc, whilst ensuring that nproc x njob is less than or equal to the total number of processors available. Alternatively, we can take advantage of the cluster to process our data more quickly, by using the xia2 parameter type=qsub, which tells xia2 to submit individual jobs to the cluster using the qsub command. Since we are using the cluster, and not a single computer, we can increase the nproc parameter, e.g. to nproc=12 which will now use 12 processors per sweep. We can also increase njob=20 to process all 20 sweeps simultaneously. We also need to add an extra module load global/cluster command to make the cluster available:
module load global/cluster
module load XDS
module load ccp4
module load dials/dev-228
xia2 -3dii -failover \
mode=parallel njob=20 nproc=12 type=qsub\
trust_beam_centre=True read_all_image_headers=False \
unit_cell="92.73 92.73 128.13 90.00 90.00 120.00" \
space_group=P6122 -atom X \
/dls/mx-scratch/mx_bag_training/thermolysin/
| Parameter | Description |
|---|---|
| -3dii | Use the 3D (XDS) pipeline, using all images in indexing |
| -failover | If processing fails for any sweeps, ignore and just use those sweeps that processed successfully |
| mode=parallel | Process multiple sweeps in parallel, rather than serially |
| njob=4 | In conjunction with mode=parallel, process 4 sweeps simultaneously |
| nproc=1 | Use 1 processor per job (sweep) |
| type=qsub | Submit individual processing jobs to cluster using qsub |
| trust_beam_centre=True | Don’t run labelit beam centre search |
| read_all_image_headers=False | Skip reading all image headers - just read the first one for each sweep |
| unit_cell= | Provide a target unit cell to help indexing |
| space_group= | Provide a target space group to help indexing |
| -atom X | Anomalous flag: don’t merge Friedel pairs |
Once xia2 has finished processing all the data, the final merging statistics reported by xia2 are as follows:
For AUTOMATIC/DEFAULT/SAD
High resolution limit 1.29 5.63 1.29
Low resolution limit 68.02 68.02 1.33
Completeness 67.2 99.6 2.8
Multiplicity 6.5 9.2 1.1
I/sigma 16.1 27.6 4.3
Rmerge 0.124 0.136 0.000
Rmeas(I) 0.144 0.162 0.608
Rmeas(I+/-) 0.138 0.149 0.000
Rpim(I) 0.047 0.052 0.430
Rpim(I+/-) 0.058 0.060 0.000
CC half 0.988 0.956 0.823
Wilson B factor 18.807
Anomalous completeness 53.6 97.9 0.2
Anomalous multiplicity 2.8 4.9 1.0
Anomalous correlation 0.208 0.328 0.000
Anomalous slope 1.303 0.000 0.000
dF/F 0.076
dI/s(dI) 1.056
Total observations<PHONE_NUMBER>3 187
Total unique 55180 1161 176
Assuming spacegroup: P 61 2 2
Unit cell:
92.620 92.620 128.330
90.000 90.000 120.000
These merging statistics are for all the data from all 20 sweeps merged together. Depending upon the quality of the particular datasets, and what exactly we want to do with the processed data in the next step, this may well be good enough, however in some cases we may want to analyse the individual datasets for non-isomorphism using BLEND with the hope of finding a subset of the data that gives a better quality merged dataset than merging the all of the data together. We can run BLEND in analysis mode on the integrated reflection files output by XDS as follows:
find `pwd` -name "INTEGRATE.HKL" > data.txt
blend –a data.txt
Because we are not running with keywords, press enter while it’s running then check the resulting dendrogram:
display tree.png
If we wish we can now run BLEND in synthesis or combination mode to scale together and merge subsets of the data, for example to get the merged dataset for the second highest node in the dendrogram:
blend -s 10 5
pressing enter several times as before. This gives the resulting merging statistics as reported by BLEND:
********* Cluster 18, composed of datasets 1 2 3 5 6 7 8 9 11 13 14 15 16 18 19 20 *********
Collating multiple mtz into a single mtz ...
Running AIMLESS on the unscaled file ...
Statistics for this group:
Rmeas Rpim Completeness Multiplicity LowRes HighRes
Overall 0.133 0.074 86.4 2.6 50.15 2.48
InnerShell 0.175 0.096 85.2 2.7 50.15 8.93
OuterShell 0.171 0.096 87.9 2.6 2.58 2.48
For more information on using BLEND see the BLEND tutorials.


21-Jun-2017 | Milku
We've used eggs to condition our hair.
The quest for human beauty continues on Day 21 of 30 Days Wild as my humans have been trying to improve the condition of their hair. I reminded them that my fur is beautifully maintained and that I didn't require the application of any of their concoctions. Amazingly, they did take notice and one of the smaller humans volunteered for the treatment.
Her sister acquired a couple of eggs, cracked them into a bowl and made sure they were well beaten.
The willing victim volunteer, brushed her hair and allowed her Mum and sister to rub the beaten eggs into
her hair and scalp.
They they covered the hair with a towel and left the eggs to work their magic. A period of half an hour was recommended, but the little human had to finish watching a film before she'd rinse her hair so I think the treatment lasted over an hour.
You're probably wondering why they chose to use eggs. Due to their high levels of Omega-3 fatty acids, xanthophylls, immunoglobulins, vitamins and other micro-nutrients, eggs are supposed to be good for strengthening the hair and hair follicles. My humans also expected the hair to become less frizzy and grow faster. They are so optimistic!
I think it worked...a bit. All the hair straightening and the like that goes on has left quite a bit of damage so the process will have to be repeated many times.


- AJ Styles (Male Superstar)
- Lita (Female Superstar)
- Andre The Giant (Deceased Superstar)
- Paul Heyman (Non-Wrestler)
- D-Generation
- X (Tag-Team Or Faction)
- The Undertaker (Male Superstar)
- Trish Stratus (Female Superstar)
- Eddie Guerrero (Deceased Superstar)
- Vince McMahon (Non-Wrestler)
- New World Order (Tag-Team Or Faction)
-
AJ Styles - 510
-
Steve Austin - 400
-
Ric Flair - 177
-
Hulk Hogan - 154
-
Shawn Michaels - 118
-
The Rock - 83
-
Lita - 340
-
AJ Lee - 107
-
Charlotte - 94
-
Asuka 72 11%
-
Sable - 38
-
Sunny - 29
-
Andre The Giant - 987
-
Chris Benoit - 955
-
Randy Savage - 520
-
Owen Hart - 458
-
Roddy Piper - 204
-
Chyna - 109
-
Paul Heyman - 201
-
Bobby Heenan - 126
-
Jim Ross - 90
-
Eric Bischoff - 56
-
Jim Johnston - 40
-
Jim Cornette - 25
-
D-Generation X - 216
-
The Four Horsemen - 187
-
Evolution - 130
-
The Shield - 78
-
The Road Warriors - 62
-
Edge and Christian - 58
Thank you for voting! See you in 2018!


This chart illustrates the profit of a
Global Super Store by color for each State
within the United States.
The graph displays the sum profits for each
product category in California, where profit
is greatest in the United States.
The graph demonstrates the correlation between
Order Month and profit in California, where sales are
greatest, for the years 2013 and 2014. Be sure to
note that the years are distinguished by color.
This graph shows the forcasted profit for
Accessories, the most profitable product category
in California, through November 2015, based on
data provided from 2011 to 2014.


{% load markdown_deux_tags %} {% with address_contact.is_preferred as preferred %}
{{ address_contact.notes|markdown }}


Extends
- React.Component
Members
showEditPopup :boolean
The state that determines whether the EditProfilePopup is shown or not
Type:
- boolean
- Source:
userData :UserData
JSON object that contains all the user's info, retrieved from Firebase
Type:
- Source:
Methods
openEditPopup()
Called to open the EditProfilePopup and allow user to edit their details.
- Source:
openEditPopup()
Called to close the EditProfilePopup.
- Source:
setShowEditPopup(val)
A function callback that sets the showEditPopup boolean in the internal state of Profile.
Parameters:
| Name | Type | Description |
|---|---|---|
val |
boolean |
- Source:


{% extends 'helpcentre-detail.html' %} {% block pageTitle %} How to delete NHS login {% endblock %} {% block beforeContent %} {% endblock %} {% block content %}
You can delete your NHS login by visiting your NHS login settings.
Scroll down to the bottom and select ‘delete NHS login’. You will be asked to enter your password to confirm.
Once you delete your NHS login, you will not be able to use it to access any websites or apps. If you are trying to delete your account with just one website or app in particular, you should contact them directly. You may then still use your NHS login to access other websites and apps.
If you delete your NHS login, any websites or apps you have used with NHS login may keep some information about you in line with their terms and conditions and privacy notice. We may also keep some information about you in line with NHS login's privacy notice.


The Classroom Organizer - Students
Home
View Teachers
View Classes
View Students
View Grades
Search Results
{% if students %}
{% for s in students %}
{{s[1]}} {{s[2]}}
{% endfor %}
{% else %}
Sorry, there is no student by that name
{% endif %}


---
layout: page
tags: [Jekyll, HADDOCK, Bonvin, Docking, Simulation, Molecular Dynamics, Structural Biology, Computational Biology, Modelling, Protein Structure]
modified: 2014-08-08T20:53:07.573882-04:00
comments: false
image:
feature: pages/banner_software.jpg
---
HADDOCK2.2 manual
Introduction
HADDOCK (High Ambiguity Driven biomolecular DOCKing) is an information-driven flexible docking approach for the modelling of biomolecular complexes (Dominguez et al. 2003). Docking is defined as the modelling of the structure of a complex based on the known three-dimensional structures of its constituents. HADDOCK distinguishes itself from other docking methods by incorporating a wide variety of experimental and/or bioinformatics data to drive the modelling (Melquiond and Bonvin, 2010). This allows concentrating the search to relevant portions of the interaction space using a more sophisticated treatment of conformational flexibility.
Interface regions can be identified by mutagenesis, H/D exchange and chemical modifications (e.g. by cross-linkers or oxidative agents) detected by mass spectrometry, nuclear magnetic resonance, chemical shift perturbations and cross-saturation transfer. When experimental data are unavailable or scarce, this information can be supplemented by bioinformatics predictions (de Vries and Bonvin, 2008). These diverse information sources typically only identify or predict interfacial regions, but do not define the contacts across an interface. HADDOCK deals with this by implementing them as ambiguous interaction restraints (AIRs) that will force the interfaces to come together without imposing a particular orientation.
HADDOCK can also incorporate classical NMR restraints such as distances from nuclear Overhauser effects and paramagnetic relaxation enhancement measurements, pseudo-contact shift, dihedral angles, residual dipolar coupling and diffusion anisotropy restraints, the latter two providing valuable information about the relative orientation of the components in a complex. In addition, symmetry restraints can be defined in the case of symmetrical homomeric systems. Other valuable information can be obtained from low-to-medium resolution techniques such as small angle X-ray scattering, cryo-electron microscopy and ion mobility mass spectrometry that can provide valuable information about the shape of a complex.
The docking protocol in HADDOCK, which makes use of the Crystallography and NMR System (CNS) package as computational engine, consists of three successive steps:
- rigid-body energy minimization
- semi-flexible refinement in torsion angle space
- final refinement in explicit solvent refinement.
By allowing for explicit flexibility during the molecular dynamics refinement HADDOCK can account for small conformational changes occurring upon binding. Larger and more challenging conformational changes can be dealt with by starting the docking from ensembles of conformations and/or treating the molecules as a collection of domains. The latter approach makes use of the unique multi-body docking ability of HADDOCK, which can handle up to 6 separate domains or molecules at the same time. The selection of the final models is based on a weighted sum of electrostatics, desolvation and van der Waals energy terms, along with the energetic contribution of the restraints used to drive the docking.
HADDOCK has been extensively applied to a large variety of systems, including protein-protein, protein-nucleic acids and protein-small molecule docking and has shown a very strong performance in the blind critical assessment of the prediction of interactions (CAPRI). A considerable number of experimental structures of complexes calculated using HADDOCK have been deposited into the Protein Data Bank (PDB). HADDOCK is available as a web server (https://alcazar.sciencee.uu.nl/services/HADDOCK2.2) (de Vries et al. 2010) offering a user-friendly interface to the structural biology community.
A list of HADDOCK-related publications is availble here.
On our HADDOCK home page you will find:
- general information on HADDOCK
- tools to generate AIR restraint files and to setup projects
- instructions to obtain HADDOCK
- links to the various softwares required to run HADDOCK
- a manual describing the use of HADDOCK
- a frequently asked questions section
- various tutorials


Enter the code and escape the Matrix!
Choose a number between 1 and 100
Go!
—
—
—
—
—
Reset
Hint
-- message from Zion --


This End-User License Agreement ("EULA") is a legal agreement between you and OverTheHorizon-Hub
This EULA agreement governs your acquisition and use of our OverTheHorizon software ("Software") directly from OverTheHorizon-Hub or indirectly through a OverTheHorizon-Hub authorized reseller or distributor (a "Reseller").
Please read this EULA agreement carefully before completing the installation process and using the OverTheHorizon software. It provides a license to use the OverTheHorizon software and contains warranty information and liability disclaimers.
If you register for a free trial of the OverTheHorizon software, this EULA agreement will also govern that trial. By clicking "accept" or installing and/or using the OverTheHorizon software, you are confirming your acceptance of the Software and agreeing to become bound by the terms of this EULA agreement.
If you are entering into this EULA agreement on behalf of a company or other legal entity, you represent that you have the authority to bind such entity and its affiliates to these terms and conditions. If you do not have such authority or if you do not agree with the terms and conditions of this EULA agreement, do not install or use the Software, and you must not accept this EULA agreement.
This EULA agreement shall apply only to the Software supplied by OverTheHorizon-Hub herewith regardless of whether other software is referred to or described herein. The terms also apply to any OverTheHorizon-Hub updates, supplements, Internet-based services, and support services for the Software, unless other terms accompany those items on delivery. If so, those terms apply. This EULA was created by EULA Template for OverTheHorizon.
OverTheHorizon-Hub hereby grants you a personal, non-transferable, non-exclusive licence to use the OverTheHorizon software on your devices in accordance with the terms of this EULA agreement.
You are permitted to load the OverTheHorizon software (for example a PC, laptop, mobile or tablet) under your control. You are responsible for ensuring your device meets the minimum requirements of the OverTheHorizon software.
You are not permitted to:
OverTheHorizon-Hub shall at all times retain ownership of the Software as originally downloaded by you and all subsequent downloads of the Software by you. The Software (and the copyright, and other intellectual property rights of whatever nature in the Software, including any modifications made thereto) are and shall remain the property of OverTheHorizon-Hub.
OverTheHorizon-Hub reserves the right to grant licences to use the Software to third parties.
This EULA agreement is effective from the date you first use the Software and shall continue until terminated. You may terminate it at any time upon written notice to OverTheHorizon-Hub.
It will also terminate immediately if you fail to comply with any term of this EULA agreement. Upon such termination, the licenses granted by this EULA agreement will immediately terminate and you agree to stop all access and use of the Software. The provisions that by their nature continue and survive will survive any termination of this EULA agreement.
This EULA agreement, and any dispute arising out of or in connection with this EULA agreement, shall be governed by and construed in accordance with the laws of in.


Portland Public Schools: Adjust the Portland Public School Calendar to start after Labor Day... https://www.change.org/p/portland-public-schools-adjust-the-portland-public-school-calendar-to-start-after-labor-day-and-end-thursday-june-9-currently-scheduled-to-start-2-days-before-labor-day-weekend-and-end-on-tuesday-june-7?recruiter=308373569&utm_source=share_petition&utm_medium=twitter&utm_campaign=share_twitter_responsive via @Change
6/1/2015, 12:04:37 PM
Favs: 0
Retweets: 0
link


Past Presentations
Club Interest Presentation
Presentation given to those who found the club during the 2020-21 RHS Club Fair
Introduction to Python
Presentation that goes over the basics of the Python programming language
Introduction to Markdown, git and Github
Presentation that goes over the basics of Markdown along with how to use the git version control system and Github


Run Away Costs
As organisations scale more and more, usage inside the cloud and the resulting costs can begin to spiral out of control.
Pressure From The Finance Team
One result of the runaway costs can be demand from the finance team to create savings and measure usage.
Scripts Wreaking Havoc
Scripts can be laborious, onerous to maintain and inflexible. As AWS constantly changes its schemas, you have to stay on your toes to adapt.
Single Points of Human Failure
An employee who creates maintenance scripts isn’t scalable & often doesn’t stick around. Once they’re unavailable, organisations run into trouble.
Complexity In Cloud Management
Maintaining the foundational services of an AWS environment from within the console can be complicated and restrictive.
Inflexible Control & Permissions
Organisations that want to permit their engineers granular controls over their infrastructure find it hard to scale permissions and cede control.


Classes | |
| class | cPrecisionClock |
| cPrecisionClock provides a class to manage high-precision time measurements. All measurements are computed in seconds unless otherwise-specified. cPrecisionClock behaves just like a real chronograph: It can be started, stopped and restarted a later time. When the clock is running (ON), time is accumulated until the next stop event (OFF). The value of the clock can be read at any time by calling method getCurrentTimeSeconds(). When the clock is stopped (OFF), time is no longer accumulated. More... | |
| class | cThread |
| cThread provides a class to manage threads. More... |