Routing
Messages can be sent via a router to efficiently route them to destination actors, known as its routees. A Router can be used inside or outside of an actor, and you can manage the routees yourselves or use a self contained router actor with configuration capabilities.
Different routing strategies can be used, according to your application's needs. Akka comes with several useful routing strategies right out of the box. But, as you will see in this chapter, it is also possible to create your own.
A Simple Router
The following example illustrates how to use a Router and manage the routees from within an actor.
import akka.routing.{ ActorRefRoutee, RoundRobinRoutingLogic, Router }
class Master extends Actor {
var router = {
val routees = Vector.fill(5) {
val r = context.actorOf(Props[Worker])
context watch r
ActorRefRoutee(r)
}
Router(RoundRobinRoutingLogic(), routees)
}
def receive = {
case w: Work =>
router.route(w, sender())
case Terminated(a) =>
router = router.removeRoutee(a)
val r = context.actorOf(Props[Worker])
context watch r
router = router.addRoutee(r)
}
}
We create a Router and specify that it should use RoundRobinRoutingLogic when routing the messages to the routees.
The routing logic shipped with Akka are:
- akka.routing.RoundRobinRoutingLogic
- akka.routing.RandomRoutingLogic
- akka.routing.SmallestMailboxRoutingLogic
- akka.routing.BroadcastRoutingLogic
- akka.routing.ScatterGatherFirstCompletedRoutingLogic
- akka.routing.TailChoppingRoutingLogic
- akka.routing.ConsistentHashingRoutingLogic
We create the routees as ordinary child actors wrapped in ActorRefRoutee. We watch the routees to be able to replace them if they are terminated.
Sending messages via the router is done with the route method, as is done for the Work messages in the example above.
The Router is immutable and the RoutingLogic is thread safe; meaning that they can also be used outside of actors.
Note
In general, any message sent to a router will be sent onwards to its routees, but there is one exception. The special Broadcast Messages will send to all of a router's routees. However, do not use Broadcast Messages when you use BalancingPool for routees as described in Specially Handled Messages.
A Router Actor
A router can also be created as a self contained actor that manages the routees itself and loads routing logic and other settings from configuration.
This type of router actor comes in two distinct flavors:
- Pool - The router creates routees as child actors and removes them from the router if they terminate.
- Group - The routee actors are created externally to the router and the router sends messages to the specified path using actor selection, without watching for termination.
The settings for a router actor can be defined in configuration or programmatically. In order to make an actor to make use of an externally configurable router the FromConfig props wrapper must be used to denote that the actor accepts routing settings from configuration. This is in contrast with Remote Deployment where such marker props is not necessary. If the props of an actor is NOT wrapped in FromConfig it will ignore the router section of the deployment configuration.
You send messages to the routees via the router actor in the same way as for ordinary actors, i.e. via its ActorRef. The router actor forwards messages onto its routees without changing the original sender. When a routee replies to a routed message, the reply will be sent to the original sender, not to the router actor.
Note
In general, any message sent to a router will be sent onwards to its routees, but there are a few exceptions. These are documented in the Specially Handled Messages section below.
Pool
The following code and configuration snippets show how to create a round-robin router that forwards messages to five Worker routees. The routees will be created as the router's children.
akka.actor.deployment {
/parent/router1 {
router = round-robin-pool
nr-of-instances = 5
}
}
val router1: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router1")
Here is the same example, but with the router configuration provided programmatically instead of from configuration.
val router2: ActorRef =
context.actorOf(RoundRobinPool(5).props(Props[Worker]), "router2")
Remote Deployed Routees
In addition to being able to create local actors as routees, you can instruct the router to deploy its created children on a set of remote hosts. Routees will be deployed in round-robin fashion. In order to deploy routees remotely, wrap the router configuration in a RemoteRouterConfig, attaching the remote addresses of the nodes to deploy to. Remote deployment requires the akka-remote module to be included in the classpath.
import akka.actor.{ Address, AddressFromURIString }
import akka.remote.routing.RemoteRouterConfig
val addresses = Seq(
Address("akka.tcp", "remotesys", "otherhost", 1234),
AddressFromURIString("akka.tcp://othersys@anotherhost:1234"))
val routerRemote = system.actorOf(
RemoteRouterConfig(RoundRobinPool(5), addresses).props(Props[Echo]))
Senders
By default, when a routee sends a message, it will implicitly set itself as the sender.
sender() ! x // replies will go to this actor
However, it is often useful for routees to set the router as a sender. For example, you might want to set the router as the sender if you want to hide the details of the routees behind the router. The following code snippet shows how to set the parent router as sender.
sender().tell("reply", context.parent) // replies will go back to parent
sender().!("reply")(context.parent) // alternative syntax (beware of the parens!)
Supervision
Routees that are created by a pool router will be created as the router's children. The router is therefore also the children's supervisor.
The supervision strategy of the router actor can be configured with the supervisorStrategy property of the Pool. If no configuration is provided, routers default to a strategy of “always escalate”. This means that errors are passed up to the router's supervisor for handling. The router's supervisor will decide what to do about any errors.
Note the router's supervisor will treat the error as an error with the router itself. Therefore a directive to stop or restart will cause the router itself to stop or restart. The router, in turn, will cause its children to stop and restart.
It should be mentioned that the router's restart behavior has been overridden so that a restart, while still re-creating the children, will still preserve the same number of actors in the pool.
This means that if you have not specified supervisorStrategy of the router or its parent a failure in a routee will escalate to the parent of the router, which will by default restart the router, which will restart all routees (it uses Escalate and does not stop routees during restart). The reason is to make the default behave such that adding withRouter to a child’s definition does not change the supervision strategy applied to the child. This might be an inefficiency that you can avoid by specifying the strategy when defining the router.
Setting the strategy is easily done:
val escalator = OneForOneStrategy() {
case e ⇒ testActor ! e; SupervisorStrategy.Escalate
}
val router = system.actorOf(RoundRobinPool(1, supervisorStrategy = escalator).props(
routeeProps = Props[TestActor]))
Note
If the child of a pool router terminates, the pool router will not automatically spawn a new child. In the event that all children of a pool router have terminated the router will terminate itself unless it is a dynamic router, e.g. using a resizer.
Group
Sometimes, rather than having the router actor create its routees, it is desirable to create routees separately and provide them to the router for its use. You can do this by passing an paths of the routees to the router's configuration. Messages will be sent with ActorSelection to these paths.
The example below shows how to create a router by providing it with the path strings of three routee actors.
akka.actor.deployment {
/parent/router3 {
router = round-robin-group
routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
}
}
val router3: ActorRef =
context.actorOf(FromConfig.props(), "router3")
Here is the same example, but with the router configuration provided programmatically instead of from configuration.
val router4: ActorRef =
context.actorOf(RoundRobinGroup(paths).props(), "router4")
The routee actors are created externally from the router:
system.actorOf(Props[Workers], "workers")
class Workers extends Actor {
context.actorOf(Props[Worker], name = "w1")
context.actorOf(Props[Worker], name = "w2")
context.actorOf(Props[Worker], name = "w3")
// ...
The paths may contain protocol and address information for actors running on remote hosts. Remoting requires the akka-remote module to be included in the classpath.
akka.actor.deployment {
/parent/remoteGroup {
router = round-robin-group
routees.paths = [
"akka.tcp://app@<IP_ADDRESS>:2552/user/workers/w1",
"akka.tcp://app@<IP_ADDRESS>:2552/user/workers/w1",
"akka.tcp://app@<IP_ADDRESS>:2552/user/workers/w1"]
}
}
Router usage
In this section we will describe how to create the different types of router actors.
The router actors in this section are created from within a top level actor named parent. Note that deployment paths in the configuration starts with /parent/ followed by the name of the router actor.
system.actorOf(Props[Parent], "parent")
RoundRobinPool and RoundRobinGroup
Routes in a round-robin fashion to its routees.
RoundRobinPool defined in configuration:
akka.actor.deployment {
/parent/router1 {
router = round-robin-pool
nr-of-instances = 5
}
}
val router1: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router1")
RoundRobinPool defined in code:
val router2: ActorRef =
context.actorOf(RoundRobinPool(5).props(Props[Worker]), "router2")
RoundRobinGroup defined in configuration:
akka.actor.deployment {
/parent/router3 {
router = round-robin-group
routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
}
}
val router3: ActorRef =
context.actorOf(FromConfig.props(), "router3")
RoundRobinGroup defined in code:
val paths = List("/user/workers/w1", "/user/workers/w2", "/user/workers/w3")
val router4: ActorRef =
context.actorOf(RoundRobinGroup(paths).props(), "router4")
RandomPool and RandomGroup
This router type selects one of its routees randomly for each message.
RandomPool defined in configuration:
akka.actor.deployment {
/parent/router5 {
router = random-pool
nr-of-instances = 5
}
}
val router5: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router5")
RandomPool defined in code:
val router6: ActorRef =
context.actorOf(RandomPool(5).props(Props[Worker]), "router6")
RandomGroup defined in configuration:
akka.actor.deployment {
/parent/router7 {
router = random-group
routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
}
}
val router7: ActorRef =
context.actorOf(FromConfig.props(), "router7")
RandomGroup defined in code:
val paths = List("/user/workers/w1", "/user/workers/w2", "/user/workers/w3")
val router8: ActorRef =
context.actorOf(RandomGroup(paths).props(), "router8")
BalancingPool
A Router that will try to redistribute work from busy routees to idle routees. All routees share the same mailbox.
Note
The BalancingPool has the property that its routees do not have truly distinct identity: they have different names, but talking to them will not end up at the right actor in most cases. Therefore you cannot use it for workflows that require state to be kept within the routee, you would in this case have to include the whole state in the messages.
With a SmallestMailboxPool you can have a vertically scaling service that can interact in a stateful fashion with other services in the back-end before replying to the original client. The other advantage is that it does not place a restriction on the message queue implementation as BalancingPool does.
Note
Do not use Broadcast Messages when you use BalancingPool for routers. as described in Specially Handled Messages,
BalancingPool defined in configuration:
akka.actor.deployment {
/parent/router9 {
router = balancing-pool
nr-of-instances = 5
}
}
val router9: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router9")
BalancingPool defined in code:
val router10: ActorRef =
context.actorOf(BalancingPool(5).props(Props[Worker]), "router10")
Addition configuration for the balancing dispatcher, which is used by the pool, can be configured in the pool-dispatcher section of the router deployment configuration.
akka.actor.deployment {
/parent/router9b {
router = balancing-pool
nr-of-instances = 5
pool-dispatcher {
attempt-teamwork = off
}
}
}
The BalancingPool automatically uses a special BalancingDispatcher for its routees - disregarding any dispatcher that is set on the routee Props object. This is needed in order to implement the balancing semantics via sharing the same mailbox by all the routees.
While it is not possible to change the dispatcher used by the routees, it is possible to fine tune the used executor. By default the fork-join-dispatcher is used and can be configured as explained in Dispatchers. In situations where the routees are expected to perform blocking operations it may be useful to replace it with a thread-pool-executor hinting the number of allocated threads explicitly:
akka.actor.deployment {
/parent/router10b {
router = balancing-pool
nr-of-instances = 5
pool-dispatcher {
executor = "thread-pool-executor"
# allocate exactly 5 threads for this pool
thread-pool-executor {
core-pool-size-min = 5
core-pool-size-max = 5
}
}
}
}
It is also possible to change the mailbox used by the balancing dispatcher for scenarios where the default unbounded mailbox is not well suited. An example of such a scenario could arise whether there exists the need to manage priority for each message. You can then implement a priority mailbox and configure your dispatcher:
akka.actor.deployment {
/parent/router10c {
router = balancing-pool
nr-of-instances = 5
pool-dispatcher {
mailbox = myapp.myprioritymailbox
}
}
}
Note
Bear in mind that BalancingDispatcher requires a message queue that must be thread-safe for multiple concurrent consumers. So it is mandatory for the message queue backing a custom mailbox for this kind of dispatcher to implement akka.dispatch.MultipleConsumerSemantics. See details on how to implement your custom mailbox in Mailboxes.
There is no Group variant of the BalancingPool.
SmallestMailboxPool
A Router that tries to send to the non-suspended child routee with fewest messages in mailbox. The selection is done in this order:
- pick any idle routee (not processing message) with empty mailbox
- pick any routee with empty mailbox
- pick routee with fewest pending messages in mailbox
- pick any remote routee, remote actors are consider lowest priority, since their mailbox size is unknown
SmallestMailboxPool defined in configuration:
akka.actor.deployment {
/parent/router11 {
router = smallest-mailbox-pool
nr-of-instances = 5
}
}
val router11: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router11")
SmallestMailboxPool defined in code:
val router12: ActorRef =
context.actorOf(SmallestMailboxPool(5).props(Props[Worker]), "router12")
There is no Group variant of the SmallestMailboxPool because the size of the mailbox and the internal dispatching state of the actor is not practically available from the paths of the routees.
BroadcastPool and BroadcastGroup
A broadcast router forwards the message it receives to all its routees.
BroadcastPool defined in configuration:
akka.actor.deployment {
/parent/router13 {
router = broadcast-pool
nr-of-instances = 5
}
}
val router13: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router13")
BroadcastPool defined in code:
val router14: ActorRef =
context.actorOf(BroadcastPool(5).props(Props[Worker]), "router14")
BroadcastGroup defined in configuration:
akka.actor.deployment {
/parent/router15 {
router = broadcast-group
routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
}
}
val router15: ActorRef =
context.actorOf(FromConfig.props(), "router15")
BroadcastGroup defined in code:
val paths = List("/user/workers/w1", "/user/workers/w2", "/user/workers/w3")
val router16: ActorRef =
context.actorOf(BroadcastGroup(paths).props(), "router16")
Note
Broadcast routers always broadcast every message to their routees. If you do not want to broadcast every message, then you can use a non-broadcasting router and use Broadcast Messages as needed.
ScatterGatherFirstCompletedPool and ScatterGatherFirstCompletedGroup
The ScatterGatherFirstCompletedRouter will send the message on to all its routees. It then waits for first reply it gets back. This result will be sent back to original sender. Other replies are discarded.
It is expecting at least one reply within a configured duration, otherwise it will reply with akka.pattern.AskTimeoutException in a akka.actor.Status.Failure.
ScatterGatherFirstCompletedPool defined in configuration:
akka.actor.deployment {
/parent/router17 {
router = scatter-gather-pool
nr-of-instances = 5
within = 10 seconds
}
}
val router17: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router17")
ScatterGatherFirstCompletedPool defined in code:
val router18: ActorRef =
context.actorOf(ScatterGatherFirstCompletedPool(5, within = 10.seconds).
props(Props[Worker]), "router18")
ScatterGatherFirstCompletedGroup defined in configuration:
akka.actor.deployment {
/parent/router19 {
router = scatter-gather-group
routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
within = 10 seconds
}
}
val router19: ActorRef =
context.actorOf(FromConfig.props(), "router19")
ScatterGatherFirstCompletedGroup defined in code:
val paths = List("/user/workers/w1", "/user/workers/w2", "/user/workers/w3")
val router20: ActorRef =
context.actorOf(ScatterGatherFirstCompletedGroup(
paths,
within = 10.seconds).props(), "router20")
TailChoppingPool and TailChoppingGroup
The TailChoppingRouter will first send the message to one, randomly picked, routee and then after a small delay to a second routee (picked randomly from the remaining routees) and so on. It waits for first reply it gets back and forwards it back to original sender. Other replies are discarded.
The goal of this router is to decrease latency by performing redundant queries to multiple routees, assuming that one of the other actors may still be faster to respond than the initial one.
This optimisation was described nicely in a blog post by Peter Bailis: Doing redundant work to speed up distributed queries.
TailChoppingPool defined in configuration:
akka.actor.deployment {
/parent/router21 {
router = tail-chopping-pool
nr-of-instances = 5
within = 10 seconds
tail-chopping-router.interval = 20 milliseconds
}
}
val router21: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router21")
TailChoppingPool defined in code:
val router22: ActorRef =
context.actorOf(TailChoppingPool(5, within = 10.seconds, interval = 20.millis).
props(Props[Worker]), "router22")
TailChoppingGroup defined in configuration:
akka.actor.deployment {
/parent/router23 {
router = tail-chopping-group
routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
within = 10 seconds
tail-chopping-router.interval = 20 milliseconds
}
}
val router23: ActorRef =
context.actorOf(FromConfig.props(), "router23")
TailChoppingGroup defined in code:
val paths = List("/user/workers/w1", "/user/workers/w2", "/user/workers/w3")
val router24: ActorRef =
context.actorOf(TailChoppingGroup(
paths,
within = 10.seconds, interval = 20.millis).props(), "router24")
ConsistentHashingPool and ConsistentHashingGroup
The ConsistentHashingPool uses consistent hashing to select a routee based on the sent message. This article gives good insight into how consistent hashing is implemented.
There is 3 ways to define what data to use for the consistent hash key.
- You can define hashMapping of the router to map incoming messages to their consistent hash key. This makes the decision transparent for the sender.
- The messages may implement akka.routing.ConsistentHashingRouter.ConsistentHashable. The key is part of the message and it's convenient to define it together with the message definition.
- The messages can be wrapped in a akka.routing.ConsistentHashingRouter.ConsistentHashableEnvelope to define what data to use for the consistent hash key. The sender knows the key to use.
These ways to define the consistent hash key can be use together and at the same time for one router. The hashMapping is tried first.
Code example:
import akka.actor.Actor
import akka.routing.ConsistentHashingRouter.ConsistentHashable
class Cache extends Actor {
var cache = Map.empty[String, String]
def receive = {
case Entry(key, value) => cache += (key -> value)
case Get(key) => sender() ! cache.get(key)
case Evict(key) => cache -= key
}
}
final case class Evict(key: String)
final case class Get(key: String) extends ConsistentHashable {
override def consistentHashKey: Any = key
}
final case class Entry(key: String, value: String)
import akka.actor.Props
import akka.routing.ConsistentHashingPool
import akka.routing.ConsistentHashingRouter.ConsistentHashMapping
import akka.routing.ConsistentHashingRouter.ConsistentHashableEnvelope
def hashMapping: ConsistentHashMapping = {
case Evict(key) => key
}
val cache: ActorRef =
context.actorOf(ConsistentHashingPool(10, hashMapping = hashMapping).
props(Props[Cache]), name = "cache")
cache ! ConsistentHashableEnvelope(
message = Entry("hello", "HELLO"), hashKey = "hello")
cache ! ConsistentHashableEnvelope(
message = Entry("hi", "HI"), hashKey = "hi")
cache ! Get("hello")
expectMsg(Some("HELLO"))
cache ! Get("hi")
expectMsg(Some("HI"))
cache ! Evict("hi")
cache ! Get("hi")
expectMsg(None)
In the above example you see that the Get message implements ConsistentHashable itself, while the Entry message is wrapped in a ConsistentHashableEnvelope. The Evict message is handled by the hashMapping partial function.
ConsistentHashingPool defined in configuration:
akka.actor.deployment {
/parent/router25 {
router = consistent-hashing-pool
nr-of-instances = 5
virtual-nodes-factor = 10
}
}
val router25: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router25")
ConsistentHashingPool defined in code:
val router26: ActorRef =
context.actorOf(
ConsistentHashingPool(5).props(Props[Worker]),
"router26")
ConsistentHashingGroup defined in configuration:
akka.actor.deployment {
/parent/router27 {
router = consistent-hashing-group
routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
virtual-nodes-factor = 10
}
}
val router27: ActorRef =
context.actorOf(FromConfig.props(), "router27")
ConsistentHashingGroup defined in code:
val paths = List("/user/workers/w1", "/user/workers/w2", "/user/workers/w3")
val router28: ActorRef =
context.actorOf(ConsistentHashingGroup(paths).props(), "router28")
virtual-nodes-factor is the number of virtual nodes per routee that is used in the consistent hash node ring to make the distribution more uniform.
Specially Handled Messages
Most messages sent to router actors will be forwarded according to the routers' routing logic. However there are a few types of messages that have special behavior.
Note that these special messages, except for the Broadcast message, are only handled by self contained router actors and not by the akka.routing.Router component described in A Simple Router.
Broadcast Messages
A Broadcast message can be used to send a message to all of a router's routees. When a router receives a Broadcast message, it will broadcast that message's payload to all routees, no matter how that router would normally route its messages.
The example below shows how you would use a Broadcast message to send a very important message to every routee of a router.
import akka.routing.Broadcast
router ! Broadcast("Watch out for Davy Jones' locker")
In this example the router receives the Broadcast message, extracts its payload ("Watch out for Davy Jones' locker"), and then sends the payload on to all of the router's routees. It is up to each routee actor to handle the received payload message.
Note
Do not use Broadcast Messages when you use BalancingPool for routers. Routees on BalancingPool shares the same mailbox instance, thus some routees can possibly get the broadcast message multiple times, while other routees get no broadcast message.
PoisonPill Messages
A PoisonPill message has special handling for all actors, including for routers. When any actor receives a PoisonPill message, that actor will be stopped. See the PoisonPill documentation for details.
import akka.actor.PoisonPill
router ! PoisonPill
For a router, which normally passes on messages to routees, it is important to realise that PoisonPill messages are processed by the router only. PoisonPill messages sent to a router will not be sent on to routees.
However, a PoisonPill message sent to a router may still affect its routees, because it will stop the router and when the router stops it also stops its children. Stopping children is normal actor behavior. The router will stop routees that it has created as children. Each child will process its current message and then stop. This may lead to some messages being unprocessed. See the documentation on Stopping actors for more information.
If you wish to stop a router and its routees, but you would like the routees to first process all the messages currently in their mailboxes, then you should not send a PoisonPill message to the router. Instead you should wrap a PoisonPill message inside a Broadcast message so that each routee will receive the PoisonPill message. Note that this will stop all routees, even if the routees aren't children of the router, i.e. even routees programmatically provided to the router.
import akka.actor.PoisonPill
import akka.routing.Broadcast
router ! Broadcast(PoisonPill)
With the code shown above, each routee will receive a PoisonPill message. Each routee will continue to process its messages as normal, eventually processing the PoisonPill. This will cause the routee to stop. After all routees have stopped the router will itself be stopped automatically unless it is a dynamic router, e.g. using a resizer.
Note
Brendan W McAdams' excellent blog post Distributing Akka Workloads - And Shutting Down Afterwards discusses in more detail how PoisonPill messages can be used to shut down routers and routees.
Kill Messages
Kill messages are another type of message that has special handling. See Killing an Actor for general information about how actors handle Kill messages.
When a Kill message is sent to a router the router processes the message internally, and does not send it on to its routees. The router will throw an ActorKilledException and fail. It will then be either resumed, restarted or terminated, depending how it is supervised.
Routees that are children of the router will also be suspended, and will be affected by the supervision directive that is applied to the router. Routees that are not the routers children, i.e. those that were created externally to the router, will not be affected.
import akka.actor.Kill
router ! Kill
As with the PoisonPill message, there is a distinction between killing a router, which indirectly kills its children (who happen to be routees), and killing routees directly (some of whom may not be children.)  Broadcast(Kill)
Management Messages
- Sending akka.routing.GetRoutees to a router actor will make it send back its currently used routees in a akka.routing.Routees message.
- Sending akka.routing.AddRoutee to a router actor will add that routee to its collection of routees.
- Sending akka.routing.RemoveRoutee to a router actor will remove that routee to its collection of routees.
- Sending akka.routing.AdjustPoolSize to a pool router actor will add or remove that number of routees to its collection of routees.
These management messages may be handled after other messages, so if you send AddRoutee immediately followed by an ordinary message you are not guaranteed that the routees have been changed when the ordinary message is routed. If you need to know when the change has been applied you can send AddRoutee followed by GetRoutees and when you receive the Routees reply you know that the preceding change has been applied.
Dynamically Resizable Pool
Most pools can be used with a fixed number of routees or with a resize strategy to adjust the number of routees dynamically.
There are two types of resizers: the default Resizer and the OptimalSizeExploringResizer.
Default Resizer
The default resizer ramps up and down pool size based on pressure, measured by the percentage of busy routees in the pool. It ramps up pool size if the pressure is higher than a certain threshold and backs off if the pressure is lower than certain threshold. Both thresholds are configurable.
Pool with default resizer defined in configuration:
akka.actor.deployment {
/parent/router29 {
router = round-robin-pool
resizer {
lower-bound = 2
upper-bound = 15
messages-per-resize = 100
}
}
}
val router29: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router29")
Several more configuration options are available and described in akka.actor.deployment.default.resizer section of the reference Configuration.
Pool with resizer defined in code:
val resizer = DefaultResizer(lowerBound = 2, upperBound = 15)
val router30: ActorRef =
context.actorOf(
RoundRobinPool(5, Some(resizer)).props(Props[Worker]),
"router30")
It is also worth pointing out that if you define the ``router`` in the configuration file then this value will be used instead of any programmatically sent parameters.
Optimal Size Exploring Resizer
The OptimalSizeExploringResizer resizes the pool to an optimal size that provides the most message throughput.
This resizer works best when you expect the pool size to performance function to be a convex function. For example, when you have a CPU bound tasks, the optimal size is bound to the number of CPU cores. When your task is IO bound, the optimal size is bound to optimal number of concurrent connections to that IO service - e.g. a 4 node elastic search cluster may handle 4-8 concurrent requests at optimal speed.
It achieves this by keeping track of message throughput at each pool size and performing the following three resizing operations (one at a time) periodically:
- Downsize if it hasn't seen all routees ever fully utilized for a period of time.
- Explore to a random nearby pool size to try and collect throughput metrics.
- Optimize to a nearby pool size with a better (than any other nearby sizes) throughput metrics.
When the pool is fully-utilized (i.e. all routees are busy), it randomly choose between exploring and optimizing. When the pool has not been fully-utilized for a period of time, it will downsize the pool to the last seen max utilization multiplied by a configurable ratio.
By constantly exploring and optimizing, the resizer will eventually walk to the optimal size and remain nearby. When the optimal size changes it will start walking towards the new one.
It keeps a performance log so it's stateful as well as having a larger memory footprint than the default Resizer. The memory usage is O(n) where n is the number of sizes you allow, i.e. upperBound - lowerBound.
Pool with OptimalSizeExploringResizer defined in configuration:
akka.actor.deployment {
/parent/router31 {
router = round-robin-pool
optimal-size-exploring-resizer {
enabled = on
action-interval = 5s
downsize-after-underutilized-for = 72h
}
}
}
val router31: ActorRef =
context.actorOf(FromConfig.props(Props[Worker]), "router31")
Several more configuration options are available and described in akka.actor.deployment.default.optimal-size-exploring-resizer section of the reference Configuration.
Note
Resizing is triggered by sending messages to the actor pool, but it is not completed synchronously; instead a message is sent to the “head” RouterActor to perform the size change. Thus you cannot rely on resizing to instantaneously create new workers when all others are busy, because the message just sent will be queued to the mailbox of a busy actor. To remedy this, configure the pool to use a balancing dispatcher, see Configuring Dispatchers for more information.
How Routing is Designed within Akka
On the surface routers look like normal actors, but they are actually implemented differently. Routers are designed to be extremely efficient at receiving messages and passing them quickly on to routees.
A normal actor can be used for routing messages, but an actor's single-threaded processing can become a bottleneck. Routers can achieve much higher throughput with an optimization to the usual message-processing pipeline that allows concurrent routing. This is achieved by embedding routers' routing logic directly in their ActorRef rather than in the router actor. Messages sent to a router's ActorRef can be immediately routed to the routee, bypassing the single-threaded router actor entirely.
The cost to this is, of course, that the internals of routing code are more complicated than if routers were implemented with normal actors. Fortunately all of this complexity is invisible to consumers of the routing API. However, it is something to be aware of when implementing your own routers.
Custom Router
You can create your own router should you not find any of the ones provided by Akka sufficient for your needs. In order to roll your own router you have to fulfill certain criteria which are explained in this section.
Before creating your own router you should consider whether a normal actor with router-like behavior might do the job just as well as a full-blown router. As explained above, the primary benefit of routers over normal actors is their higher performance. But they are somewhat more complicated to write than normal actors. Therefore if lower maximum throughput is acceptable in your application you may wish to stick with traditional actors. This section, however, assumes that you wish to get maximum performance and so demonstrates how you can create your own router.
The router created in this example is replicating each message to a few destinations.
Start with the routing logic:
import scala.collection.immutable
import java.util.concurrent.ThreadLocalRandom
import akka.routing.RoundRobinRoutingLogic
import akka.routing.RoutingLogic
import akka.routing.Routee
import akka.routing.SeveralRoutees
class RedundancyRoutingLogic(nbrCopies: Int) extends RoutingLogic {
val roundRobin = RoundRobinRoutingLogic()
def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee = {
val targets = (1 to nbrCopies).map(_ => roundRobin.select(message, routees))
SeveralRoutees(targets)
}
}
select will be called for each message and in this example pick a few destinations by round-robin, by reusing the existing RoundRobinRoutingLogic and wrap the result in a SeveralRoutees instance. SeveralRoutees will send the message to all of the supplied routes.
The implementation of the routing logic must be thread safe, since it might be used outside of actors.
A unit test of the routing logic:
final case class TestRoutee(n: Int) extends Routee {
override def send(message: Any, sender: ActorRef): Unit = ()
}
val logic = new RedundancyRoutingLogic(nbrCopies = 3)
val routees = for (n <- 1 to 7) yield TestRoutee(n)
val r1 = logic.select("msg", routees)
r1.asInstanceOf[SeveralRoutees].routees should be(
Vector(TestRoutee(1), TestRoutee(2), TestRoutee(3)))
val r2 = logic.select("msg", routees)
r2.asInstanceOf[SeveralRoutees].routees should be(
Vector(TestRoutee(4), TestRoutee(5), TestRoutee(6)))
val r3 = logic.select("msg", routees)
r3.asInstanceOf[SeveralRoutees].routees should be(
Vector(TestRoutee(7), TestRoutee(1), TestRoutee(2)))
You could stop here and use the RedundancyRoutingLogic with a akka.routing.Router as described in A Simple Router.
Let us continue and make this into a self contained, configurable, router actor.
Create a class that extends Pool, Group or CustomRouterConfig. That class is a factory for the routing logic and holds the configuration for the router. Here we make it a Group.
import akka.dispatch.Dispatchers
import akka.routing.Group
import akka.routing.Router
import akka.japi.Util.immutableSeq
import com.typesafe.config.Config
final case class RedundancyGroup(routeePaths: immutable.Iterable[String], nbrCopies: Int) extends Group {
def this(config: Config) = this(
routeePaths = immutableSeq(config.getStringList("routees.paths")),
nbrCopies = config.getInt("nbr-copies"))
override def paths(system: ActorSystem): immutable.Iterable[String] = routeePaths
override def createRouter(system: ActorSystem): Router =
new Router(new RedundancyRoutingLogic(nbrCopies))
override val routerDispatcher: String = Dispatchers.DefaultDispatcherId
}
This can be used exactly as the router actors provided by Akka.
for (n <- 1 to 10) system.actorOf(Props[Storage], "s" + n)
val paths = for (n <- 1 to 10) yield ("/user/s" + n)
val redundancy1: ActorRef =
system.actorOf(
RedundancyGroup(paths, nbrCopies = 3).props(),
name = "redundancy1")
redundancy1 ! "important"
Note that we added a constructor in RedundancyGroup that takes a Config parameter. That makes it possible to define it in configuration.
akka.actor.deployment {
/redundancy2 {
router = "docs.routing.RedundancyGroup"
routees.paths = ["/user/s1", "/user/s2", "/user/s3"]
nbr-copies = 5
}
}
Note the fully qualified class name in the router property. The router class must extend akka.routing.RouterConfig (Pool, Group or CustomRouterConfig) and have constructor with one com.typesafe.config.Config parameter. The deployment section of the configuration is passed to the constructor.
val redundancy2: ActorRef = system.actorOf(
FromConfig.props(),
name = "redundancy2")
redundancy2 ! "very important"
Configuring Dispatchers
The dispatcher for created children of the pool will be taken from Props as described in Dispatchers.
To make it easy to define the dispatcher of the routees of the pool you can define the dispatcher inline in the deployment section of the config.
akka.actor.deployment {
/poolWithDispatcher {
router = random-pool
nr-of-instances = 5
pool-dispatcher {
fork-join-executor.parallelism-min = 5
fork-join-executor.parallelism-max = 5
}
}
}
That is the only thing you need to do enable a dedicated dispatcher for a pool.
Note
If you use a group of actors and route to their paths, then they will still use the same dispatcher that was configured for them in their Props, it is not possible to change an actors dispatcher after it has been created.
The “head” router cannot always run on the same dispatcher, because it does not process the same type of messages, hence this special actor does not use the dispatcher configured in Props, but takes the routerDispatcher from the RouterConfig instead, which defaults to the actor system’s default dispatcher. All standard routers allow setting this property in their constructor or factory method, custom routers have to implement the method in a suitable way.
val router: ActorRef = system.actorOf(
// “head” router actor will run on "router-dispatcher" dispatcher
// Worker routees will run on "pool-dispatcher" dispatcher
RandomPool(5, routerDispatcher = "router-dispatcher").props(Props[Worker]),
name = "poolWithDispatcher")
Note
It is not allowed to configure the routerDispatcher to be a akka.dispatch.BalancingDispatcherConfigurator since the messages meant for the special router actor cannot be processed by any other actor.
Contents


Amzi! Prolog consists of five primary tools, two libraries and six file types. The tools are:
Throughout this manual both the full name and generic names of the tools are used. For command-line environments, the generic names are also the names of the commands themselves (e.g. acmp.exe is the name of the compiler). For GUI-window environments, the tools are accessed from menus and tool bars.
This section briefly introduces the Amzi! tools and file types.
Normally Prolog code is developed using a Prolog interpreter, also called a "listener." The listener directly executes source code, which is stored in a plain text file (.pro file), or typed in directly at the ?- prompt. So developing an interpreted Amzi! Prolog module consists of these steps (the corresponding IDE commands are given in parentheses):
The Amzi! debugger is used to find and identify errors. It works on interpreted source code. The debugger can only be invoked from, and used within, the listener. In order to step through code, you need to consult the source code form of the module.
The Amzi! listener differs from other Prolog listeners because you can consult both source code files and compiled object code files. In fact, you can intermix compiled and interpreted code in the same application and listener session. This allows you to keep code under development in source form, and debugged code in compiled form.
The Listener is the heart of the Amzi! development tools. It is where you develop, test and debug your Prolog code.
Interpreted code is normally used only for dynamic data, debugging and experimentation. Once a module is completed, it is usually compiled into an object module (.plm file). No source code changes are required before compiling.
The development cycle is extended with the following steps to compile working modules, while keeping modules under development interpreted (in source form):
Compiling has a number of advantages. Compiled code runs at least 10 times faster than interpreted code. Compiled programs that have recursive calls will run longer before exhausting stack and heap resources. Finally, predicates in compiled modules can be hidden, making it easier to build large, multi-file applications.
The object file contains instructions for a Warren Abstract (Prolog) Machine (WAM). The WAM is the core of Amzi! Prolog, it is also called the Amzi! runtime, and is provided in both executable and library forms. The same Prolog object file (or source file) can be run on any version of the Amzi! runtime.
Once an application has been debugged, the object files (.plm) are linked into a single executable load module (.xpl file) that can be embedded in a C/C++, Java, Visual Basic, Delphi, Web Server or other program, or run as a standalone program.
The linker automatically links in a copy of the standard Amzi! library alib.plm into each .xpl file. You may also want to link in a library such as the list utilities library LIST.PLM.
An example of an executable load module is the file alis.xpl in your distribution files. It is the listener, which is itself an Amzi! Prolog application.
The tools just described are all available from the operating system command line using the specified program names. The tools are also gathered together under a single Integrated Development Environment (IDE) for Windows.
The IDE allows you to run the listener with its debugger, the compiler, the linker and the runtime (see below). It also includes an editor and the ability to define projects (PPJ files). Projects provide a convenient means to organize multi-module applications. There are two IDEs: winIDE_W supports the full Unicode character set, and winIDE_A the ASCII character set.
The Amzi! runtime executes a Prolog load module (.xpl file) created by the linker. A distributable Amzi! application minimally consists of a runtime and a load module.
The final steps, then, in building a Prolog application are:
Separate runtimes are provided for each supported environment. arun is the .exe form of the runtime and allows for standalone Prolog application development. The dynamic library forms of the runtime allow for embedding the Amzi! runtime in other languages.
An Amzi! application must have one .xpl file, and only one .xpl file. However, that .xpl file can consult as many other source files (.pro) and compiled object files (.plm) as needed.
An Amzi! application might also include an initialization file (.cfg file) which specifies the sizes of the heaps and stacks, and gives you control over other operational parameters of the Amzi! runtime. The initialization (.cfg) file bears the same name as the load (.xpl) file. One file, amzi.cfg, can be used to set system-wide defaults. If there are no .cfg files then default values are used.
The Amzi! runtime is a full Unicode implementation. This means that, internally, all strings are stored as wide (Unicode) character strings. Further, Prolog source text can be stored in Unicode format, enabling the inclusion of Unicode characters directly in Prolog programs.
The Amzi! runtime is also embodied in dynamic/shared libraries which can be linked into and called from a variety of languages and tools. Like arun, these libraries execute an Amzi! load module (.xpl file).
The programming interface to the Amzi! runtime is called the LSAPI. It provides over 50 functions that, in large part, mimic the functionality of the Prolog listener. You can load source and object code, issue queries, map the results of those queries to variables, assert new facts, build/decompose lists and structures and more.
The Logic Server API is provided as a C interface, a C++ class library, a Java Class, a Delphi Component, a Visual Basic definitions module and a general purpose interface (for other non-pointer-based languages).
Further, the Logic Server API lets you add your own predicates (functions) to Amzi! Prolog, thereby extending the Amzi! language implementation with your own C/C++ code. An example of this might be functions to access your database.
The Amzi! Logic Server also supports multiple, simultaneous invocations. Multiple engines are implemented simply by allocating a new Logic Server object. This can be done through either the native LSAPI interface, the new C++ Logic Server class, or any of the environment specific lsapis, Delphi, VB, or Java.
Next, we recommend you run through "A Quick Tutorial" which follows next. If you plan to embed Prolog code in other applications, you can follow the tutorial for the appropriate 'hello' samples which are described in the Logic Server API section.
There is also a detailed introduction and reference section for each of the tools described above.
Copyright ©1987-2011 Amzi! inc. All Rights Reserved. Amzi! is a registered trademark and Logic Server is a trademark of Amzi! inc.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/cache.20olean.20no.20longer.20working.html ---
Anybody else having this problem?
HEAD is now at d7283d7f feat(string): `split_on` a `char` (#1145) Trying to fetch cached olean .git/hooks/post-checkout: line 14: /Users/chrishughes/.mathlib/bin/cache-olean: Permission denied
Are you sure all the scripts in .mathlib/bin
have execution permission? Try chmod +x ~/.mathlib/bin/cache-olean
Fixed thanks.
:+1:
The setup should really take care of the for you though
I had the same problem recently, actually. I wonder what happened.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


∙ A helping hand around the house
∙ Military uses
∙ Medical uses
∙ Basically anything you can imagine (:
The Black Box can be assigned resources and assignments. You can customize
it to do anything you want, you just have to give it instructions verbally.


karma.conf.js |
|
|
Karma configuration Generated on Fri Dec 16 2016 13:09:51 GMT+0000 (UTC) |
module.exports = function(config) {
config.set({
|
|
base path that will be used to resolve all patterns (eg. files, exclude) |
basePath: '',
|
|
frameworks to use available frameworks: https://npmjs.org/browse/keyword/karma-adapter |
frameworks: ['mocha', 'chai', 'sinon'],
|
|
list of files / patterns to load in the browser |
files: [
'dist/debug.js',
'test/*spec.js'
],
|
|
list of files to exclude |
exclude: [
'src/node.js'
],
|
|
preprocess matching files before serving them to the browser available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor |
preprocessors: {
},
|
|
test results reporter to use possible values: 'dots', 'progress' available reporters: https://npmjs.org/browse/keyword/karma-reporter |
reporters: ['progress'],
|
|
web server port |
port: 9876,
|
|
enable / disable colors in the output (reporters and logs) |
colors: true,
|
|
level of logging possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG |
logLevel: config.LOG_INFO,
|
|
enable / disable watching file and executing tests whenever any file changes |
autoWatch: true,
|
|
start these browsers available browser launchers: https://npmjs.org/browse/keyword/karma-launcher |
browsers: ['PhantomJS'],
|
|
Continuous Integration mode if true, Karma captures browsers, runs the tests and exits |
singleRun: false,
|
|
Concurrency level how many browser should be started simultaneous |
concurrency: Infinity
})
}
|


{% extends "app_base.html" %}
{% load static %}
{% block head_title %}Attendance Report for {{ student }} in {{ grade_level }} in {{ school_year }}{% endblock %}
{% block main %}
Attendance Report for {{ student }} in {{ grade_level }} in {{ school_year }}
{% if school_dates %}
{% for school_date in school_dates %}
{{ school_date.date|date:"Y-m-d" }}
{% if school_date.is_break %}
No school scheduled
{% elif school_date.is_school_day %}
{% if school_date.attended %}
Attended
{% else %}
Absent
{% endif %}
{% else %}
Not a school day
{% endif %}


Stylish Portfolio is a one page Bootstrap portfolio theme with off canvas navigation and smooth scrolling through content sections.
Elevate is a responsive landing page website template designed to promote and generate leads for your products or service.
Responsive static website with multiple pages to promote and generate leads for your company or product.
One page Bootstrap theme created fo apps or application for your business using Html css and Jquery.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Responsive personal portofilo created using HTML CSS JQuery can be used for Business or multipurpose profile.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam viverra euismod odio, gravida pellentesque urna varius vitae.


{% extends "base.html" %} {% import "bootstrap/wtf.html" as wtf %} {% import "bootstrap/fixes.html" as fixes %} {% import "bootstrap/utils.html" as util %} {% block title %}Compare Networks{% endblock %} {% block content %}


--- layout: post status: publish published: true title: New Asshat of the Week author: display_name: Andy login: Andy email<EMAIL_ADDRESS>url: '' author_login: Andy author_email<EMAIL_ADDRESS>excerpt: "Since I can't seem to embed this crap, here is a link: Asshat of the Week.\n\nI think that every sports team has its share of embarassing fans. We find ourselves wishing that these people would show some maturity, respect, and moderation. Cards fans everywhere should be wishing that this guy " wordpress_id: 86 wordpress_url: http://ivyenvy.wordpress.com/?p=86 date: '2008-05-26 15:16:08 +0000' date_gmt: '2008-05-26 15:16:08 +0000' categories: - General Baseball tags: - Asshat - Ernie Banks - Fans - Jim Edmonds - Mark Derosa - Ryan Theriot comments: - id: 51 author: manstrength author_email<EMAIL_ADDRESS>author_url: '' date: '2008-05-26 17:58:45 +0000' date_gmt: '2008-05-26 17:58:45 +0000' content: Holy crap, that guy is an asshat fo' sho'. What do you think about his dubbing over the interview in the end? Wow. - id: 52 author: Hope Springs Eternal « Ivy Envy author_email: '' author_url: http://ivyenvy.wordpress.com/2008/07/05/hope-springs-eternal/ date: '2008-07-05 00:43:49 +0000' date_gmt: '2008-07-05 05:43:49 +0000' content: "[...] just getting the first win in this series with “the birds on the bat” (lolz) makes me feel like all is becoming right with the universe. We are out of Mordor [...]" ---
Since I can't seem to embed this crap, here is a link: Asshat of the Week.
I think that every sports team has its share of embarassing fans. We find ourselves wishing that these people would show some maturity, respect, and moderation. Cards fans everywhere should be wishing that this guy would shut his hole. It is always tough to see a longstanding member of your team playing for the enemy.  Edmonds is probably happy to just being playing at this point and to be still making a living. This scenario is reminiscent of being a fan of a particular band and then hanging a scarlet "S" for "sellout" around their necks when one of their songs shows up in a commecial. Sure, there are those players like Ernie Banks who love the city they play for with great abandon, but I'm guessing a large majority of the players out there are just happy to be making money doing what they love regardless of locale.
On the topic of embarassing fans-- Many people seem to think that the Cubs have some of the worst fans in baseball, including our friends at FOH. I already stated my position on this issue above. I'd be interested to hear what some of our readers think.
Check out DeRosa's blog for an interview with Ryan Theriot.
Here is another interesting Cubs-related blog to check out.


How to optimize engine parameters to achieve best efficiency? How to find a recipe for a dish to maximize feedback by customers? What are the optimal hyperparameters of a machine learning algorithm? All of these and many more practical problems share the same structure: they involve optimizing a function which is noisy, has no analytical form and is costly to compute. I am one of maintainers of scikit-optimize open source python library, which allows to solve such problems efficienlty.


Hello, I am Somto Ejinkonye and I am a Junior studying Computer Engineering and NYU. I am passonate about
cybersecurity, prototyping and embedded systems.
Click here to get a random fact about computer science!
About Me:
I am an avid hardware enthusiast and problemsolver. Here are some of my projects and interests.
Projects
During my senior year of highschool my robotics team built a quadcopter and attempted to program it
autonomously navigate an obstical field.
Hobbies/Jobs
I am Data Structures and Algorithms Teaching assistant and a cybersecurity Intern.
I enjoys teaching others about data structures and problem solving and learning about ways
to keep myself secure. In my freetime I enjoy reading about adavancements in technology,
storytelling, reading comics and exploring the city.
I enjoy exploring different music genres and would love any suggestions/reccomendations.


Warning!
For full functionality of this site it is necessary to enable JavaScript. Here are the
instructions how to enable JavaScript in your web browser.


Come Fly With Us!
Learn More About Us
After Flying Domestic and International Skies for Decades, We Know We are the Best!
Considering most of our planes flew imited-distance destinations,this is some big news! Visit the Pacific isles with our help!
Reasons to Fly With Us!
99 planes
From Global & HFY to de Havillands...
200 Countries
From France to Peru to Ukraine to Hawaii...
Luxuriousness
All of our private planes are equipped and packed.
100 Pilots
All of them pass harsh proficiency tests monthly...

Pets & Kids
Bring your dog, cat or a child onboard!
7895
Cups of Coffee
58
Pilots
312
Countries
99
Planes
As a movie star, I very often fly from a set to award shows. Can you imagine me doing so on a regular flight?
Adam Smith - developer
Being a millionaire has its cons. It obliges me to stpend tons of money on private flights.
Jenna Alissie - developer
As soon as I won the lottery, I've immediately signed off regular flights and started flying.
Adam Liam - developer
Do you feel like trying either of out flights for the first time?Hopefully our 20% off will help you make the decision!


Workout TeamUp can help you overcome your laziness and find fun in community activities!
Let's Go!Our goal is to supply you with an open platform where to start and participate teamup activities, find and meet up with your team and enjoy a healthy life.
What do we have?It's incredibly easy to find your groups of interest with our activity classification feature
We keep track your history of activities, and make them your glorious achievements
Chat with friends online and stay notified with email when you are offline
Our geo-location functions allows you to find about people nearby you. They can be your workout partners.


Use a highly extensible grid
Ladder grid was built from the ground up to allow extensibility. Every component in the ladder grid is extensible in multiple ways
The core ladder grid components can be extendended using simple prototype inheritance, the Ladder inheritance paradigm gives you more powerfull options:
- Extend your instance objects using knockout observables and computeds!
- Extend object instantiation code
- Extend templates at multiple levels, global templates, grid level templates and row/column level template extensions.
- Intercept core grid properties and modify them (for example use a custom function to deturmine which columns should be visible)
- Add your own classes and use them in the grid (for example add an 'aggregate-row' class). Newly added classes can inherit from existing classes which makes it easy to use them in the place of existing classes.


The data for this project was obtained from the United Nations High Commissioner for Refugees (UNHCR) and the UN Data Portal. As both sources exclusively provide country-to-country refugee flow statistics per year, additional data processing was conducted in both Excel and Trifacta Wrangler.
Below, data is condensed in Excel as the SUMIF() function is used to combine 'Values' from column E only if column C and D have matching 'Year' and 'Month' values, respectively. As such, the result in cell J6 will be equal to the number of refugees that fled the Syrian Arab Republic in May 2013. Instead of working with single digit refugee flows, the processed data allows us to better understand the refugee crisis and create more meaningful visualizations.
The refugee statistics organized above by month in column J were used in the heat map visualization. While the geospatial visualization of total hosted refugees by country in 2013 used similar data processing, nodes (country names) and links (refugee flow values) were extracted by hand and reorganized for the sankey particle flow visualization. Country IDs were assigned according to internationally recognized country codes.


Show simple alert
Alert with title and description
Alert with title, description and icon
Example with multiple options
Example with input
Advanced example with AJAX
Documentation
You can find examples and documentation about SweetAlert plugin here: SweetAlert documentation


CSS Exam Project
Index
Gallery
More
Gallery Flex
About
Some cool pictures from unsplash.com to fill gallery grid!


Full Name
Age
DOB
Gender
Contact

Add New Patient
Cancel
Enter Patient Details
First name
Please Enter a First Name
Last name
Please Enter a Last Name
Age
Please Enter a valid age
Please Choose a Gender
Male
Female
Date of Birth
Please Choose a Date of Birth
Contact
Please Enter a Contact Number
Message
Please Enter a Message
Add Patient


{% extends "basic.html" %} {% block content %}
Are you sure you want to delete "{{ category.titel }}"?


Click on the red area and drag to rotate the cube,Click and drag over the letters to answerLook for bonus words to score more


[1]
Video, Audio, Messaging, Security, Applications; Battery, Flash, Camera
[2]
-Great battery life, high quality, high tech!; -A little pricey


--- layout: post title: NTT DoCoMo buys music retail chain date: 2005-11-09 00:00:00 categories: business mobile ---
NTT DoCoMo buys music retail chain: "DoCoMo will initially provide Tower's 100 Japanese stores with pay-by-phone systems allowing consumers to purchase music and have it billed to their FeliCa mobile phone accounts.
Both firms also said they are considering a digital music download service partnership, and that's likely to be the real motivation behind the deal. DoCoMo gains a music brand and knowledge needed to provide such a service which could integrate perfectly with the telco's i-mode facility. Some reports claim music accounts for around half of all i-mode content sales."
Also worth considering: catalogue shopping via mobile is, I'm told, Big In Japan. CDs much surely be an in-demand item and suitable for such things.


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @(params: Map[String, Any]) @uk.gov.hmrc.hmrcemailrenderer.templates.helpers.html.template_main(params, "You applied for transfer of residence tax relief"){
Dear @params("customerName")
HMRC received an application for transfer of residence tax relief using this email address.
Your submission reference is: @params("submissionReference")
We will contact you by email or telephone within 15 working days to let you know if your application is approved, or to ask for more information.
You cannot use the submission reference in this email to make additions to your application.
Do not do anything now.
If we approve this application, we will email a Unique Reference Number (URN).
You can then use this URN to make additions, including adding an animal health certificate.
When you have your URN, select ‘start now’ from the GOV.UK page you used to start this application. You can then confirm your email, then select ‘Make additions to an already approved application’.
From Transfer of residence tax relief
}


This is a simple hero-unit layout to demonstrate the fragment inclusion system
Learn more about ThymeLeaf ...


Child function to call the convsh program to convert the PP format to a sensible NetCDF which we can more easily read. This requires the convsh and xconv functions available from: http://badc.nerc.ac.uk/help/software/xconv/index.html Follow the installation instructions for your platform (Linux, Windows, Mac etc.) prior to running this function. This requires the subset.tcl script in the utilities subdirectory of the MATLAB fvcom-toolbox. INPUT: file - cell array of PP file(s) to convert to NetCDF. Include sub-directory in path, can include full path name or path relative to working directory. convsh - the path to the convsh binary (NB this can't contain spaces). pp2nc_tcl - the path to the TCL script (in the utilities fvcom-toolbox file). xextents - [startx, endx, xinc] = start longitude coordinate, end coordinate and grid increment (> 0.1degrees). yextents - [starty, endy, yinc] = start longitude coordinate, end coordinate and grid increment (> 0.1degrees). OUTPUT: NetCDF files in the same directory as the input PP files but with a .nc file extension. USAGE (PWC): Convert the PP files to NetCDF. files = {'/path/to/file1.pp', '/path/to/file2.pp', '/path/to/file3.pp'}; convsh = '/users/modellers/pica/bin/convsh'; tcl = '/users/modellers/pica/MATLAB/fvcom-toolbox/utilities/pp2nc.tcl'; pp2nc(files, convsh, tcl); Author(s): Pierre Cazenave (Plymouth Marine Laboratory) Karen Amoudry (National Oceanography Centre, Liverpool) Judith Wolf (National Oceanography Centre, Liverpool) PWC Revision history: 2013-06-24 Extracted version from the get_MetUM_forcing.m script and set as standalone version. 2013-09-06 Modified pp2nc.m to use the subset.tcl script (which has more options). Also returns a list of the converted netCDF files. KJA Revision history: 2013-06-25 Added support for paths with spaces in. Also added support for creation of NetCDF files in Windows (convsh will only take a .nc filename, not a whole path). JW Revision history: 2013-08-13 Problem for paths with spaces in, especially using Windows Add backslash after pwd to define directory Make sure convsh is pointing to right path (cannot use paths with spaces in command, use relative paths from starting directory, put output file in same working directory
0001 function met_files = pp2nc_subset(file, convsh, pp2nc_tcl, xextents, yextents) 0002 % Child function to call the convsh program to convert the PP format to a 0003 % sensible NetCDF which we can more easily read. 0004 % 0005 % This requires the convsh and xconv functions available from: 0006 % 0007 % http://badc.nerc.ac.uk/help/software/xconv/index.html 0008 % 0009 % Follow the installation instructions for your platform (Linux, Windows, 0010 % Mac etc.) prior to running this function. 0011 % 0012 % This requires the subset.tcl script in the utilities subdirectory of the 0013 % MATLAB fvcom-toolbox. 0014 % 0015 % INPUT: 0016 % file - cell array of PP file(s) to convert to NetCDF. Include 0017 % sub-directory in path, can include full path name or path relative 0018 % to working directory. 0019 % convsh - the path to the convsh binary (NB this can't contain spaces). 0020 % pp2nc_tcl - the path to the TCL script (in the utilities fvcom-toolbox 0021 % file). 0022 % xextents - [startx, endx, xinc] = start longitude coordinate, end 0023 % coordinate and grid increment (> 0.1degrees). 0024 % yextents - [starty, endy, yinc] = start longitude coordinate, end 0025 % coordinate and grid increment (> 0.1degrees). 0026 % 0027 % OUTPUT: 0028 % NetCDF files in the same directory as the input PP files but with a .nc 0029 % file extension. 0030 % 0031 % USAGE (PWC): Convert the PP files to NetCDF. 0032 % files = {'/path/to/file1.pp', '/path/to/file2.pp', '/path/to/file3.pp'}; 0033 % convsh = '/users/modellers/pica/bin/convsh'; 0034 % tcl = '/users/modellers/pica/MATLAB/fvcom-toolbox/utilities/pp2nc.tcl'; 0035 % pp2nc(files, convsh, tcl); 0036 % 0037 % Author(s): 0038 % Pierre Cazenave (Plymouth Marine Laboratory) 0039 % Karen Amoudry (National Oceanography Centre, Liverpool) 0040 % Judith Wolf (National Oceanography Centre, Liverpool) 0041 % 0042 % PWC Revision history: 0043 % 2013-06-24 Extracted version from the get_MetUM_forcing.m script and 0044 % set as standalone version. 0045 % 2013-09-06 Modified pp2nc.m to use the subset.tcl script (which has 0046 % more options). Also returns a list of the converted netCDF files. 0047 % 0048 % KJA Revision history: 0049 % 2013-06-25 Added support for paths with spaces in. Also added support 0050 % for creation of NetCDF files in Windows (convsh will only take a .nc 0051 % filename, not a whole path). 0052 % 0053 % JW Revision history: 0054 % 2013-08-13 Problem for paths with spaces in, especially using Windows 0055 % Add backslash after pwd to define directory 0056 % Make sure convsh is pointing to right path (cannot use paths with 0057 % spaces in command, use relative paths from starting directory, 0058 % put output file in same working directory 0059 0060 nf = length(file); 0061 0062 for ff = 1:nf 0063 if ~isnan(file{ff}) 0064 if exist(file{ff}, 'file') ~= 2 0065 error('File %s not found', file) 0066 end 0067 0068 [pathname, filename, ~] = fileparts(file{ff}); 0069 met_files{ff} = [filename, '.nc']; 0070 cd(pathname) 0071 % Warn if it failed for some reason 0072 [res, msg] = system([... 0073 convsh, ' "', pp2nc_tcl, '" -i "', file{ff}, '" -o "', met_files{ff}, ... 0074 '" -xs ', num2str(xextents(1)), ... 0075 ' -xe ', num2str(xextents(2)), ... 0076 ' -xi ', num2str(xextents(3)), ... 0077 ' -ys ', num2str(yextents(1)), ... 0078 ' -ye ', num2str(yextents(2)), ... 0079 ' -yi ',num2str( yextents(3))... 0080 ]); 0081 % [res, msg] = system([convsh, ' "', pp2nc_tcl, '" -i "', infile, '" -o "', out, '"']); 0082 cd(goback) 0083 if res ~= 0 0084 warning('Conversion of %s to NetCDF failed. Conversion output:\n%s', file{ff}, msg) 0085 end 0086 end 0087 end


Announcement: Make sure to enable Arc so I can make money! (Click that purple
circle at the bottom left)
Public plays
| Player | Song | Combo | Score | Acc | Mods | Time |
Random Beatmaps
Randomize Beatmaps
Scripts
Skin
Hitsounds


{% extends "radio/site_base.html" %} {% load radio_extras %} {% load socialaccount %} {% block main-nav %} {% include "radio/site_live_nav.html" %} {% endblock %} {% block main-body %} {% get_setting 'PINAX_STRIPE_PUBLIC_KEY' as stripe_pub_key %}
Thank you for your subscription. We hope you enjoy the additional listening history
If at any time you would like to cancel, just email us at<EMAIL_ADDRESS>Use the menu at the top to select the scan list or talkgroup you want to listen to..
Note: It can take up to 5 minues for your plan access to change.


@main("Action"){
Reprise your role as a supernatural assassin in Dishonored 2 – the follow up to Arkane Studio's
first-person action blockbuster and winner of more than 100 'Game of the Year' awards,
Dishonored. Play your way in a world where mysticism and industry collide.
Was €69.99 now:
Play as Agent 47 to take out powerful high-profile targets in an intense spy-thriller story across a world of assassination. Released in a day one edition SteelBook®, HITMAN: The Complete First Season will deliver the ultimate physical version of the game, with over 100 hours of gameplay. Featuring all of the Season One locations and episodes from the Prologue, France and Italy to Morocco, Thailand, USA and Japan.
€44.99In a city where information is heavily monitored, agile couriers called Runners transport sensitive data away from prying eyes. In this seemingly utopian paradise, a crime has been committed, your sister has been framed and now you are being hunted.  Mirror’s Edge™ delivers you straight into the shoes of this unique heroine as she traverses the vertigo-inducing cityscape, engaging in intense combat and fast paced chases. With a never before seen sense of movement and perspective, you will be drawn into Faith’s world. A world that is visceral, immediate, and very dangerous. Live or die? Soar or plummet? One thing is certain, in this city you will learn how to run. From the makers of the groundbreaking Battlefield franchise, Mirror’s Edge is an action-adventure experience unlike any other.
€39.99A return to the fray Brothers in harm's way Set three years after the events of Uncharted 3: Drake’s Deception, Nathan Drake has presumably left the world of fortune hunting behind. However, it doesn’t take long for fate to come calling when Drake’s brother, Sam, resurfaces seeking his help to save his own life and offering an adventure Drake can’t resist. On the hunt for Captain Henry Avery’s long-lost treasure, Sam and Drake set off to find Libertalia, the pirate utopia deep in the forests of Madagascar. Uncharted 4: A Thief’s End takes players on a journey around the globe, through jungle isles, far-flung cities and snow-capped peaks on the search for Avery’s fortune.
€59.99Tom Clancy’s Rainbow Six® Siege is the newest installment of the acclaimed first-person shooter franchise, developed by the renowned Ubisoft Montreal studio for the new generation of home console and PC. It is an exciting, new approach to the first-person shooter experience that puts tactical combat and masterful destruction at the center of the action. In Rainbow Six Siege, Counter-Terrorist Unit Operators lead teams through tense and thrilling combat scenarios, where success is achieved through smart preparation and strategic improvisation
€49.99


NoteBook Basic 15
Notebook Basic 15 with 2,80 GHz quad core, 15" LCD, 4 GB DDR3 RAM, 500 GB Hard Disc, Windows 8 Pro


Save more than $33,000 using ngx-admin.
According to our research ngx-admin optimizes 480 hours of development time. Taking the average hourly rate of a front-end engineer in the US – $70
2
Create a custom experience by working with one of 3 themes or edit just a few custom variables. Need help? Check out our article, where we describe how you can create a different look in just 2 minutes
3
It’s completely FREE and MIT licensed.
You don’t have to worry about the legal stuff, ngx-admin is free for personal and commercial purposes, so you can use it to build any product
4
Do you need more? We can customize!
Visit our homepage or simply leave us a note at<EMAIL_ADDRESS>We’re available for hire and can create custom solutions just for you


--- layout: post title: Millions to miss out on date: 2004-12-09 00:00:00 category: mobile ---
Millions to miss out on the net. Is it pithy of me to point out that it depends what you mean by "online"?
If you mean "connected to a network", then I think mobile phone penetration stands at just shy of 80% in the UK. Yes: that's not web access, or broadband, or any of the lovely things which the digital media industry spurts over. But even low-bandwidth connectivity broken into 160-character chunks can be used to accomplish a lot.
...which is not to suggest that there isn't a digital divide, or that getting broadband into the homes of the nation isn't a worthy idea. Just that this stuff gets really interesting not when it can shove 16 million pixels in your face, but rather when it's so weaved into the fabric of our everyday lives that we don't notice it - and mobile is at this point.


We sell methodologies!
- embrace value-added systems
- embrace cutting-edge deliverables
- reinvent B2B infrastructures
- reintermediate bleeding-edge content
- expedite enterprise deliverables
- e-enable seamless initiatives
- e-enable customized vortals
- syndicate vertical web-readiness
- evolve holistic deliverables
- expedite distributed deliverables


Appetizer & Snack Recipes
This has a been a hit every time I have served it. Is a great appetizer for the holidays or when figs are in season.
Go somewhereThis yummy, warm baked Brie has a garlicky center with a touch of sweet red pepper jelly topping. Serve with fresh baguette or crackers. Your guests will be begging for the recipe!
Go somewhereThese make a simple, delicious, and elegant appetizer. They impress every time!
Go somewhere


--- layout: post title: "Mr. Arachnoid" category: poetry author: Jeremy Mifsud date: 2019-02-27 ---
I only knew life inside a zoo’s unkempt cell.
An unexpected man was bold enough to risk his life; he unlocked my gate. I followed him home like a loyal puppy.
I got lured me into his web of lies, I could not untangle myself.
He devoured my hope and spit it back in my face. As my body was drained dry, he kicked me out in the street: an emaciated body crawling to the gates of hell.
This poem was originally published in “Welcome to the Sombre Days” (2018)
Jeremy Mifsud is a queer and autistic poet from Malta. Social ineptitude becomes a catalyst for his art as he weaves unsaid words into poems and stories. He is the author of the poetry collection Welcome to the Sombre Days (2018). More of his works appear or are forthcoming in Please Hear What I'm Not Saying (2018), Terse, Little Lion Literary, Constellate Magazine, and others. You can read more of his work at www.poetrybyjeremy.wordpress.com and Twitter, @poetrybyjeremy.


|
CMSIS-Pack
Version 1.5.0
Delivery Mechanism for Software Packs
|
The element /package/examples/example describes fully defined examples contained in the PACK. An example lists the files that belong to an example. The example itself and each individual file may refer to a condition that must resolve to true; if it is false the example or file will be ignored. The board element is used to reference to one or more board descriptions using the board vendor and name an example is targeted for. Each example can specify attributes listing related components using Class (Cclass=), Group (Cgroup=), Subgroup (Csub) and a Version (Cversion=)
Example
Grouping element for examples. No more than one such group can exist in a PACK.
| Parent | Chain | ||
|---|---|---|---|
| package | /package | ||
| Child Elements | Description | Type | Occurrence |
| example | Description of fully specified project | ExampleType | 1..* |
An example section is used to provide the required information for accessing an example project contained in a PACK. All examples contained in the installed packs can be listed including a brief description. A selected example will get copied into a user selected destination folder. Based on the user selected environment the respective project file will be loaded. The ID of an example is the combination of the PACK vendor, the board information and the example name and version. Examples with the same ID are treated as a single example.
| Parent | Chain | ||
|---|---|---|---|
| examples | /package/examples | ||
| Attributes | Description | Type | Use |
| name | Name of the example | xs:string | required |
| folder | Relative path to the example base folder within the package. If selected, then the directory including all sub-folders and files will be copied, unless the archive attribute gets set. | xs:string | required |
| archive | Filename and extension of the archive file containing all files and sub-folders of the example. The archive is located in the path specified by the attribute folder. If selected, then the whole archive will be extracted. | xs:string | optional |
| doc | Document that describes the example. | xs:string | required |
| version | Example version number. The version format is described in Version Type. | VersionType | optional |
| Child Elements | Description | Type | Occurrence |
| description | Briefly documents the purpose and scope of the example. The test can be displayed in an example selector. | xs:string | 1 |
| board | Complex type providing a reference to a board description using board name and vendor.. | BoardReferenceType | 1 |
| project | Complex type describing the project files for different environments | ExampleProjectType | 1..* |
| attributes | Group element for project attributes, which list required components, define example categories, and set keywords to filter and search for examples. | ExampleAttributesType | 1 |
This element specifies the board that can be used with the example project.
Example:
| Parent | Chain | ||
|---|---|---|---|
| example | /package/examples/example | ||
| Attributes | Description | Type | Use |
| vendor | Vendor name of the board. | xs:string | required |
| name | Commercial name of the board. | xs:string | required |
| Dvendor | Vendor name of the device used on the board. Use predefined values as listed in the table Device Vendor. | DeviceVendorEnum | optional |
| Dfamily | Name of the target device family used on the board. This attribute is optional if either DsubFamily or Dname is already specified. Deprecated since version 1.1 | xs:string | optional |
| DsubFamily | Name of the target device sub-family used on the board. This attribute is optional if either Dfamily or Dname is already specified. Deprecated since version 1.1 | xs:string | optional |
| Dname | Name of the target device used on the board. This attribute is optional if either Dfamily or DsubFamily is already specified. Deprecated since version 1.1. | xs:string | optional |
A project element is a sequence of environment elements that describe the name of the environment and the project file to be loaded.
Example:
| Parent | Chain | ||
|---|---|---|---|
| example | /package/examples/example | ||
| Element | Description | Type | Occurrence |
| environment | Specifies the environment and project file with extension. | xs:complexType | 1..* |
The environment element describes the name of the environment and the project file to be loaded.
Example:
| Parent | Chain | ||
|---|---|---|---|
| project | /package/examples/project | ||
| Attributes | Description | Type | Use |
| name | Name of the required tool-chain (for example: uv, iar, etc.) | xs:string | required |
| load | Specifies the project file with extension. A path relative to folder attribute of the element /package/examples/example can be appended. | xs:string | required |
Example:
| Parent | Chain | ||
|---|---|---|---|
| example | /package/examples/example | ||
| Child Elements | Description | Type | Occurrence |
| category | Free form string defining an example category. A category can be used to filter examples in an example browser. | xs:string | 0..* |
| component | Group for defining the components used in the example. | ComponentCategoryType | 0..* |
| keyword | Free form string defining a keyword that relates to the example. A keyword can be used to search for examples. | xs:string | 0..* |
The component element specifies the Cclass to which the example belongs. This can be used to list all related components within an example.
Example:
| Parent | Chain | ||
|---|---|---|---|
| attribute | /package/examples/example/attributes | ||
| Attribute | Description | Type | Use |
| Cclass | Free form string defining an example class. Predefined values can be used as listed in the table Component Classes. | CclassType | required |
| Cgroup | Free form string defining an example group. Predefined values can be used as listed in the table Component Groups. | CgroupType | optional |
| Csub | Free form string defining an example subgroup. The type is described in Component Subgroups. | CsubType | optional |
| Cversion | Free form string defining an example version. The version format is described in Version Type. | VersionType | optional |
| Cvendor | Free form string defining the vendor of the example. | xs:string | optional |


The main function of this randomizer is shuffling all the item locations.
That means it’s completely possible to collect a spirit light container but get the double jump skill instead.
Likewise, Skill Trees don’t always give you a skill so you might find a Gorlek Ore when activating the Bash Skill Tree.
The item placement however is not completely random: there is an algorithm or logic to the chaos.
This ensures that every playthrough is beatable by placing each progression item at a location you will be able to reach.
For more information, you can read the logic guide.
This mod also adds other functionality to the game. Click on the links below to learn more about them.


[
next
] [
prev
] [
prev-tail
] [
tail
] [
up
]
B
Fourier series
→
Fourier transformation
B.1
From discrete spectrum to continuous spectrum
B.2
Fourier transformation
B.3
Numerical computation of Fourier transformation
B.4
Sampling theorem
[
next
] [
prev
] [
prev-tail
] [
front
] [
up
]


Inspector Sinai:
The chaotic power of the Sprites in the Forgotten Temple is growing. It must be stopped soon or else...
Quest


The Edit Objects dialog box has much the same layout as the Edit Graphs dialog box. It is divided into 3 regions...
At the top of the dialog box are two list boxes. The box on the left lists all known display objects (curves and images). The box on the right lists all known data objects. The number following the data objects' names indicates the number of values contained within each object. (The NULL data object is used to specify no data for certain elements of Curve objects.) The name of the display object being editted is indicated by the entry box below the left box. New objects are editted by simply entering a unique name. (Note that curves and images are treated separately, so one can have both a curve and image with the same name.) The Edit Data button on the right currently does nothing. In a future release, one will be able to edit old and create new data objects.
The middle portion of the dialog box lists the parameters defining the selected object. Using the pair of radio buttons at the top of this region one can alternate (or convert) between editting the object as a Curve or Image...
A POW Curve is formed by specifying up to 4 data objects: X, Y, X-error, and Y-error. To assign data to the curve, highlight one of the data objects in the top right box and then click on the appropriate button in the curve parameter list. Either X or Y must be specified, but the others are all optional. If an X or Y data object is given as "NULL", POW will generate a simple integer count instead.
A curve can contain WCS information which allows it to be plotted in celestial coordinates instead of pixels. Enter (or edit) the values at the bottom of the parameter list and select the WCS Info check box.
A POW Image is created from a single data object; highlight the desired data object and click on the Data button. The NULL data object cannot be used for an image. The Units entry box lists the units of the array values (not the X/Y coordinates). A data object is one-dimensional, so the image needs to know how to convert the data into a 2-D array. This is done by entering the X and Y Dimensions of the image in the first pair of entry boxes. Below them are the 3 image scale parameters. Origin specifies the coordinates of the center of the bottom left pixel of the image. By convention, FITS images have an origin of (1,1) when specified in pixels. The Pixel Size specifies the linear scale of the pixels (in units/pixel) and Units specify the physical units used for the Orign and Pixel Size.
An image can contain WCS information which allows it to be labeled in celestial coordinates instead of pixels. Enter (or edit) the values at the bottom of the parameter list and select the WCS Info check box. WCS information overrides the image scale parameters (origin, pixel size, and units).
At the bottom of the dialog box are 3 buttons. Create Object creates the indicated object. If the Object Name is unique, a new object will be created otherwise, it will replace the old version. (Note than a curve and image can have the same name and but will still be considered unique.) Creating/Editting an object does not immediately affect the graphs in which that object already exists, so it is necessary to update them manual from the Edit Graphs dialog box. Reload Info will reset the parameter list and update the object/data boxes with the current list of known objects. The Exit button closes the dialog box. Any changes will be lost if an object wasn't created before exitting.


The Love2Dev Custom Add to Homescreen Prompt Manager. You can control how visitors are prompted to add your Progressive Web App to their device, including iPhone and iPad.
There are some basic criteria a page must meet in order to qualify to trigger a prompt. There must at least be a reference to a web manifest file and a registered service worker. From there you can configure the library to follow your own ruleset.
There are several example test pages available to demonstrate how the library can be used. There are several custom properties and settings you can use to control how the native and non-native prompts are triggered.
Chrome and the Chromium based Edge support a native prompt for both Android and desktops. If available this is the default choice. The library catches the beforeinstall event to reference the event object and display the native prompt according to the custom ruleset.
Classic Edge does not have an Add to Desktop feature, so no prompt should display. This will be the general rule in any browser that does not have some sort of homescreen support, like desktop FireFox.
A set of properties and values passed to the library to demonstrate its flexibility.
Try it OutSets the customCriteria property to demonstrate how you can control if a prompt can be displayed using a custom function or simply passing true or false.
Try it OutUsing the debug property to mannually set the platform (browser) to iPhone. Note: Safari is the only iOS browser supported by Apple restrictions. So psuedo browsers like Chrome, Edge & FireFox are excluded.
Try it OutUsing the debug property to mannually set the platform (browser) to iPad. Note: Safari is the only iOS browser supported by Apple restrictions. So psuedo browsers like Chrome, Edge & FireFox are excluded.
Try it OutUsing the debug property to mannually set the platform (browser) to FireFox. Note: FireFox only supports Add to Homescreen on Android.
Try it OutUsing the debug property to mannually set the platform (browser) to FireFox. Note: Opera only supports Add to Homescreen on Android.
Try it OutUsing the debug property to mannually set the platform (browser) to FireFox. Note: Samsung only supports Add to Homescreen on Android.
Try it Out


This information will assist disaster response teams, researchers and communities by providing real-time crowd-sourced earthquake intensity data.
Share your experiences and read about others.


Integrating Apache Shiro into Guice based Application
Shiro Guice integration was added in Shiro 1.2. This page covers the ways to integrate Shiro into Guice-based applications using standard Guice conventions and mechanisms. Prior to reading this integration document, you should be a least somewhat familiar with Guice.
Overview
shiro-guice provides three Guice modules that can be included in your application.
- ShiroModule
- Provides basic integration for setting up the SecurityManager, any Realms, and any other Shiro configuration.
- This module is used by extending it and adding your own custom configuration.
- ShiroWebModule
- Extension of ShiroModule that sets up the web environment and also allows for filter chain configuration. This uses the Guice Servlet Module to configure the filters, and so requires that to be setup.
- Like the ShiroModule, this module is used by extending it and adding your own custom configuration.
- ShiroAopModule
- Uses Guice AOP to implement the Shiro AOP annotations. This module is primarily concerned with adapting Shiro AnnotationMethodInterceptors to the Guice method interceptor model.
- This module is typically used by simply installing it. However, if you have your own AnnotationMethodInterceptors written for Shiro, they can be easily incorporated by extending it.
Getting Started
The most simple configuration is to extend ShiroModule to install your own Realm.
class MyShiroModule extends ShiroModule { protected void configureShiro() { try { bindRealm().toConstructor(IniRealm.class.getConstructor(Ini.class)); } catch (NoSuchMethodException e) { addError(e); } } @Provides Ini loadShiroIni() { return Ini.fromResourcePath("classpath:shiro.ini"); } }
In this case, user and role configuration would go in the shiro.ini file.
| shiro.ini usage in Guice It is important to note that, in this above configuration, only the users and roles sections from the ini file are used. |
Then, the module is used to create a Guice injector, and the injector is used to obtain a SecurityManager. The following example serves the same purpose as the first three lines in the Quickstart example.
Injector injector = Guice.createInjector(new MyShiroModule()); SecurityManager securityManager = injector.getInstance(SecurityManager.class); SecurityUtils.setSecurityManager(securityManager);
AOP
Shiro includes several annotations and method interceptors useful for performing authorization via AOP. It also provides a simple API for writing Shiro-specific method interceptors. shiro-guice supports this with the ShiroAopModule.
To use it, simply instantiate and install the module alongside your application module and your ShiroModule.
Injector injector = Guice.createInjector(new MyShiroModule(), new ShiroAopModule(), new MyApplicationModule());
If you have written custom interceptors that conform to Shiro's api, you may find it useful to extend the ShiroAopModule.
class MyShiroAopModule extends ShiroAopModule { protected void configureInterceptors(AnnotationResolver resolver) { bindShiroInterceptor(new MyCustomAnnotationMethodInterceptor(resolver)); } }
Web
shiro-guice's web integration is designed to integrate Shiro and its filter paradigm with Guice's servlet module. If you are using Shiro in a web environment, and using Guice's servlet module, then you should extend ShiroWebModule rather than ShiroModule. Your web.xml should be setup exactly as Guice's servlet module recommends.
class MyShiroWebModule extends ShiroWebModule { MyShiroWebModule(ServletContext sc) { super(sc); } protected void configureShiroWeb() { try { bindRealm().toConstructor(IniRealm.class.getConstructor(Ini.class)); } catch (NoSuchMethodException e) { addError(e); } addFilterChain("/public/**", ANON); addFilterChain("/stuff/allowed/**", AUTHC_BASIC, config(PERMS, "yes")); addFilterChain("/stuff/forbidden/**", AUTHC_BASIC, config(PERMS, "no")); addFilterChain("/**", AUTHC_BASIC); } @Provides Ini loadShiroIni() { return Ini.fromResourcePath("classpath:shiro.ini"); } }
In the previous code, we have bound an IniRealm and setup four filter chains. These chains would be equivalent to the following ini configuration.
[urls] /public/** = anon /stuff/allowed/** = authcBasic, perms["yes"] /stuff/forbidden/** = authcBasic, perms["no"] /** = authcBasic
In shiro-guice, the filter names are Guice keys. All of the default Shiro filters are available as constants, but you are not limited to those. In order to use a custom filter in a filter chain, you would do
Key customFilter = Key.get(MyCustomFilter.class);
addFilterChain("/custom/**", customFilter);
We still have to tell guice-servlets about our Shiro filter. Since the ShiroWebModule is private, and guice-servlets does not give us a way to expose a filter mapping, we have to bind it manually.
ShiroWebModule.guiceFilterModule()
Or, from within an application module,
ShiroWebModule.bindGuiceFilter(binder())
Properties
A number of Shiro classes expose configuration parameters via setter methods. shiro-guice will inject these if it finds a binding for @Named("shiro.{propName}"). For instance, to set the session timeout, you could do the following.
bindConstant().annotatedWith(Names.named("shiro.globalSessionTimeout")).to(30000L);
If this paradigm doesn't work for you, you may also consider using a provider to instantiate the object and invoking the setters directly.
Injection of Shiro Objects
shiro-guice uses a Guice TypeListener to perform injection on native Shiro classes (any class in a subdirectory of org.apache.shiro but not org.apache.shiro.guice). However, Guice only considers explicitly bound types as candidates for TypeListeners, so if you have a Shiro object that you want injected, you have to declare it explicitly. For instance, to set the CredentialsMatcher for a realm, we would need to add the following bindings:
bind(CredentialsMatcher.class).to(HashedCredentialsMatcher.class);
bind(HashedCredentialsMatcher.class);
bindConstant().annotatedWith(Names.named("shiro.hashAlgorithmName")).to(Md5Hash.ALGORITHM_NAME);
Lend a hand with documentation
While we hope this documentation helps you with the work you're doing with Apache Shiro, the community is improving and expanding the documentation all the time. If you'd like to help the Shiro project, please consider corrected, expanding, or adding documentation where you see a need. Every little bit of help you provide expands the community and in turn improves Shiro.
The easiest way to contribute your documentation is to send it to the User Forum or the User Mailing List.


--- layout: default ---
This repository includes small projects I've done in the past, including a magic card game and a Who wants to be a millioniare game made using netbeans.


Short-term contract for new head coach
The Tall Blacks will not look too far for their new head coach - at least in the short term.
Basketball New Zealand announced yesterday it is ''well down the road'' to finding former head coach Paul Henare's replacement.
He will be signed to a short-term contract - until the end of next year's Olympics.
BBNZ also said the successful applicant would probably come from the existing team set-up, which has included Pero Cameron, Ross McMains and Mike Fitchett as assistant coaches.
High performance manager Leonard King said High Performance Sport New Zealand and the New Zealand Olympic Committee were consulted.
''From all of that it became clear that our best-case scenario was to make a short-term appointment, and that the successful applicant would need to have a thorough understanding of the team, the culture and the path they have been on throughout this Olympic window.
''As a result of that, we have not advertised extensively for the role, but have spoken directly to those we think fit the role we have identified.
''There is simply no time for a new coach to come in and implement a completely new system given the restrictions we have on getting the team together.
''While we did not get out of our group at the recent world championships, it was clear for all to see the progress the team made and the impact they had on the tournament, ending with a strong win over European heavyweights Turkey.
''We don't have that time to start from scratch again ahead of our 2020 programme.''


|
Behavioral Architecture
|
Public Member Functions | |
| def | __init__ (self) |
| def | target_pos_client (self, x, y) |
| def | getGesture (self, data) |
| def | execute (self, userdata) |
Public Attributes | |
| transition_value | |
| Define the value at wich it is performed the state transition. | |
| transition | |
| Transition value to decide whenever we have to change state. | |
| count | |
| Value to count how many times we perform the PLAY state before make a transition. | |
A class used to represent the PLAY behaviour of the robot Attributes -------- @param transition_value: define the value at wich it is performed the state transition @type transition_value: int @param transition: transition value to decide whenever we have to change state @type transition: int @param count: value to count how many times we perform the PLAY state before make a transition @type count: int Methods ----- target_pos_client(x, y): Makes a request to motion server using the target position (x,y) and wait for the response getGesture(data) Callback method that receives the pointed gesture and perform the PLAY behaviour execute() It publishes the person position and, after the robot reaches the position, it subsribes to "gesture" topic. At the end, it waits for the state transition
Definition at line 49 of file command_manager.py.
| def command_manager.play.__init__ | ( | self | ) |
Constrcutor. It inizializes the attribute
Definition at line 79 of file command_manager.py.
| def command_manager.play.execute | ( | self, | |
| userdata | |||
| ) |
It publishes the person position and, after the robot reaches the position, it subsribes to "gesture" topic. At the end, it waits for the state transition @param userdata: used to pass data between states @type userdata: list
Definition at line 131 of file command_manager.py.
| def command_manager.play.getGesture | ( | self, | |
| data | |||
| ) |
Callback method that receives the pointed gesture and perform the PLAY behaviour @param data: 2D pointed gesture @type data: Point
Definition at line 111 of file command_manager.py.
| def command_manager.play.target_pos_client | ( | self, | |
| x, | |||
| y | |||
| ) |
Makes a request to motion server using the target position (x,y) and wait for the response @param x: x coordinate of the target position @type x: int @param y: y coordinate of the target position @type y: int
Definition at line 90 of file command_manager.py.