Internal Error: Failed to create a new offer. Please try it again later.
Internal Error: Current user and offer landlord are not the same. Please try it again later.
Access Denied: Your are not a landlord.
Internal Error: Please try it again later.
Updating Error: Please try it again.


{% extends "base.html" %} {% import "bootstrap/wtf.html" as wtf %} {% block title %}Flasky{% endblock %} {% block page_content %}
Playlists Found: {{playlists_found}}


Testing Actor Systems
As with any piece of software, automated tests are a very important part of the development cycle. The actor model presents a different view on how units of code are delimited and how they interact, which has an influence on how to perform tests.
Akka comes with a dedicated module akka-testkit for supporting tests at different levels, which fall into two clearly distinct categories:
- Testing isolated pieces of code without involving the actor model, meaning without multiple threads; this implies completely deterministic behavior concerning the ordering of events and no concurrency concerns and will be called Unit Testing in the following.
- Testing (multiple) encapsulated actors including multi-threaded scheduling; this implies non-deterministic order of events but shielding from concurrency concerns by the actor model and will be called Integration Testing in the following.
There are of course variations on the granularity of tests in both categories, where unit testing reaches down to white-box tests and integration testing can encompass functional tests of complete actor networks. The important distinction lies in whether concurrency concerns are part of the test or not. The tools offered are described in detail in the following sections.
Note
Be sure to add the module akka-testkit to your dependencies.
Synchronous Unit Testing with TestActorRef
Testing the business logic inside Actor classes can be divided into two parts: first, each atomic operation must work in isolation, then sequences of incoming events must be processed correctly, even in the presence of some possible variability in the ordering of events. The former is the primary use case for single-threaded unit testing, while the latter can only be verified in integration tests.
Normally, the ActorRef shields the underlying Actor instance from the outside, the only communications channel is the actor's mailbox. This restriction is an impediment to unit testing, which led to the inception of the TestActorRef. This special type of reference is designed specifically for test purposes and allows access to the actor in two ways: either by obtaining a reference to the underlying actor instance, or by invoking or querying the actor's behaviour (receive). Each one warrants its own section below.
Note
It is highly recommended to stick to traditional behavioural testing (using messaging to ask the Actor to reply with the state you want to run assertions against), instead of using TestActorRef whenever possible.
Warning
Due to the synchronous nature of TestActorRef it will not work with some support traits that Akka provides as they require asynchronous behaviours to function properly. Examples of traits that do not mix well with test actor refs are PersistentActor and AtLeastOnceDelivery provided by Akka Persistence.
Obtaining a Reference to an Actor
Having access to the actual Actor object allows application of all traditional unit testing techniques on the contained methods. Obtaining a reference is done like this:
static class MyActor extends UntypedActor {
public void onReceive(Object o) throws Exception {
if (o.equals("say42")) {
getSender().tell(42, getSelf());
} else if (o instanceof Exception) {
throw (Exception) o;
}
}
public boolean testMe() { return true; }
}
@Test
public void demonstrateTestActorRef() {
final Props props = Props.create(MyActor.class);
final TestActorRef<MyActor> ref = TestActorRef.create(system, props, "testA");
final MyActor actor = ref.underlyingActor();
assertTrue(actor.testMe());
}
Since TestActorRef is generic in the actor type it returns the underlying actor with its proper static type. From this point on you may bring any unit testing tool to bear on your actor as usual.
Testing the Actor's Behavior
When the dispatcher invokes the processing behavior of an actor on a message, it actually calls apply on the current behavior registered for the actor. This starts out with the return value of the declared receive method, but it may also be changed using become and unbecome in response to external messages. All of this contributes to the overall actor behavior and it does not lend itself to easy testing on the Actor itself. Therefore the TestActorRef offers a different mode of operation to complement the Actor testing: it supports all operations also valid on normal ActorRef. Messages sent to the actor are processed synchronously on the current thread and answers may be sent back as usual. This trick is made possible by the CallingThreadDispatcher described below (see CallingThreadDispatcher); this dispatcher is set implicitly for any actor instantiated into a TestActorRef.
final Props props = Props.create(MyActor.class);
final TestActorRef<MyActor> ref = TestActorRef.create(system, props, "testB");
final Future<Object> future = akka.pattern.Patterns.ask(ref, "say42", 3000);
assertTrue(future.isCompleted());
assertEquals(42, Await.result(future, Duration.Zero()));
As the TestActorRef is a subclass of LocalActorRef with a few special extras, also aspects like supervision and restarting work properly, but beware that execution is only strictly synchronous as long as all actors involved use the CallingThreadDispatcher. As soon as you add elements which include more sophisticated scheduling you leave the realm of unit testing as you then need to think about asynchronicity again (in most cases the problem will be to wait until the desired effect had a chance to happen).
One more special aspect which is overridden for single-threaded tests is the receiveTimeout, as including that would entail asynchronous queuing of ReceiveTimeout messages, violating the synchronous contract.
Note
To summarize: TestActorRef overwrites two fields: it sets the dispatcher to CallingThreadDispatcher.global and it sets the receiveTimeout to None.
The Way In-Between: Expecting Exceptions
If you want to test the actor behavior, including hotswapping, but without involving a dispatcher and without having the TestActorRef swallow any thrown exceptions, then there is another mode available for you: just use the receive method on TestActorRef, which will be forwarded to the underlying actor:
final Props props = Props.create(MyActor.class);
final TestActorRef<MyActor> ref = TestActorRef.create(system, props, "myActor");
try {
ref.receive(new Exception("expected"));
fail("expected an exception to be thrown");
} catch (Exception e) {
assertEquals("expected", e.getMessage());
}
Use Cases
You may of course mix and match both modi operandi of TestActorRef as suits your test needs:
- one common use case is setting up the actor into a specific internal state before sending the test message
- another is to verify correct internal state transitions after having sent the test message
Feel free to experiment with the possibilities, and if you find useful patterns, don't hesitate to let the Akka forums know about them! Who knows, common operations might even be worked into nice DSLs.
Asynchronous Integration Testing with JavaTestKit
When you are reasonably sure that your actor's business logic is correct, the next step is verifying that it works correctly within its intended environment. The definition of the environment depends of course very much on the problem at hand and the level at which you intend to test, ranging for functional/integration tests to full system tests. The minimal setup consists of the test procedure, which provides the desired stimuli, the actor under test, and an actor receiving replies. Bigger systems replace the actor under test with a network of actors, apply stimuli at varying injection points and arrange results to be sent from different emission points, but the basic principle stays the same in that a single procedure drives the test.
The JavaTestKit class contains a collection of tools which makes this common task easy.
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.testkit.JavaTestKit;
import scala.concurrent.duration.Duration;
public class TestKitSampleTest {
public static class SomeActor extends UntypedActor {
ActorRef target = null;
public void onReceive(Object msg) {
if (msg.equals("hello")) {
getSender().tell("world", getSelf());
if (target != null) target.forward(msg, getContext());
} else if (msg instanceof ActorRef) {
target = (ActorRef) msg;
getSender().tell("done", getSelf());
}
}
}
static ActorSystem system;
@BeforeClass
public static void setup() {
system = ActorSystem.create();
}
@AfterClass
public static void teardown() {
JavaTestKit.shutdownActorSystem(system);
system = null;
}
@Test
public void testIt() {
/*
* Wrap the whole test procedure within a testkit constructor
* if you want to receive actor replies or use Within(), etc.
*/
new JavaTestKit(system) {{
final Props props = Props.create(SomeActor.class);
final ActorRef subject = system.actorOf(props);
// can also use JavaTestKit “from the outside”
final JavaTestKit probe = new JavaTestKit(system);
// “inject” the probe by passing it to the test subject
// like a real resource would be passed in production
subject.tell(probe.getRef(), getRef());
// await the correct response
expectMsgEquals(duration("1 second"), "done");
// the run() method needs to finish within 3 seconds
new Within(duration("3 seconds")) {
protected void run() {
subject.tell("hello", getRef());
// This is a demo: would normally use expectMsgEquals().
// Wait time is bounded by 3-second deadline above.
new AwaitCond() {
protected boolean cond() {
return probe.msgAvailable();
}
};
// response must have been enqueued to us before probe
expectMsgEquals(Duration.Zero(), "world");
// check that the probe we injected earlier got the msg
probe.expectMsgEquals(Duration.Zero(), "hello");
Assert.assertEquals(getRef(), probe.getLastSender());
// Will wait for the rest of the 3 seconds
expectNoMsg();
}
};
}};
}
}
The JavaTestKit contains an actor named testActor which is the entry point for messages to be examined with the various expectMsg... assertions detailed below. The test actor’s reference is obtained using the getRef method as demonstrated above. The testActor may also be passed to other actors as usual, usually subscribing it as notification listener. There is a whole set of examination methods, e.g. receiving all consecutive messages matching certain criteria, receiving a whole sequence of fixed messages or classes, receiving nothing for some time, etc.
The ActorSystem passed in to the constructor of JavaTestKit is accessible via the getSystem method.
Note
Remember to shut down the actor system after the test is finished (also in case of failure) so that all actors—including the test actor—are stopped.
Built-In Assertions
The above mentioned expectMsgEquals is not the only method for formulating assertions concerning received messages, the full set is this:
final String hello = expectMsgEquals("hello");
final Object any = expectMsgAnyOf("hello", "world");
final Object[] all = expectMsgAllOf("hello", "world");
final int i = expectMsgClass(Integer.class);
final Number j = expectMsgAnyClassOf(Integer.class, Long.class);
expectNoMsg();
final Object[] two = receiveN(2);
In these examples, the maximum durations you will find mentioned below are left out, in which case they use the default value from configuration item akka.test.single-expect-default which itself defaults to 3 seconds (or they obey the innermost enclosing Within as detailed below). The full signatures are:
public <T> T expectMsgEquals(Duration max, T msg)
The given message object must be received within the specified time; the object will be returned.
public Object expectMsgAnyOf(Duration max, Object... msg)
An object must be received within the given time, and it must be equal (compared with equals()) to at least one of the passed reference objects; the received object will be returned.
public Object[] expectMsgAllOf(Duration max, Object... msg)
A number of objects matching the size of the supplied object array must be received within the given time, and for each of the given objects there must exist at least one among the received ones which equals it (compared with equals()). The full sequence of received objects is returned in the order received.
public <T> T expectMsgClass(Duration max, Class<T> c)
An object which is an instance of the given Class must be received within the allotted time frame; the object will be returned. Note that this does a conformance check, if you need the class to be equal you need to verify that afterwards.
public <T> T expectMsgAnyClassOf(Duration max, Class<? extends T>... c)
An object must be received within the given time, and it must be an instance of at least one of the supplied Class objects; the received object will be returned. Note that this does a conformance check, if you need the class to be equal you need to verify that afterwards.
Note
Because of a limitation in Java’s type system it may be necessary to add @SuppressWarnings("unchecked") when using this method.
public void expectNoMsg(Duration max)
No message must be received within the given time. This also fails if a message has been received before calling this method which has not been removed from the queue using one of the other methods.
Object[] receiveN(int n, Duration max)
n messages must be received within the given time; the received messages are returned.
For cases which require more refined conditions there are constructs which take code blocks:
ExpectMsg<T>
new JavaTestKit(system) {{ getRef().tell(42, ActorRef.noSender()); final String out = new ExpectMsg<String>("match hint") { // do not put code outside this method, will run afterwards protected String match(Object in) { if (in instanceof Integer) { return "match"; } else { throw noMatch(); } } }.get(); // this extracts the received message assertEquals("match", out); }};The match(Object in) method will be evaluated once a message has been received within the allotted time (which may be given as constructor argument). If it throws noMatch() (where it is sufficient to call that method; the throw keyword is only needed in cases where the compiler would otherwise complain about wrong return types—Java is lacking Scala’s notion of a type which signifies “will not ever return normally”), then the expectation fails with an AssertionError, otherwise the matched and possibly transformed object is stored for retrieval using the get method.
ReceiveWhile<T>
new JavaTestKit(system) {{ getRef().tell(42, ActorRef.noSender()); getRef().tell(43, ActorRef.noSender()); getRef().tell("hello", ActorRef.noSender()); final String[] out = new ReceiveWhile<String>(String.class, duration("1 second")) { // do not put code outside this method, will run afterwards protected String match(Object in) { if (in instanceof Integer) { return in.toString(); } else { throw noMatch(); } } }.get(); // this extracts the received messages assertArrayEquals(new String[] {"42", "43"}, out); expectMsgEquals("hello"); }};This construct works like ExpectMsg, but it continually collects messages as long as they match the criteria, and it does not fail when a non-matching one is encountered. Collecting messages also ends when the time is up, when too much time passes between messages or when enough messages have been received.
new ReceiveWhile<String>( // type of array to be created must match ... String.class, // ... this class which is needed to that end duration("100 millis"), // maximum collect time duration("50 millis"), // maximum time between messages 12 // maximum number of messages to collect ) { // match elided ... };The need to specify the String result type twice results from the need to create a correctly typed array and Java’s inability to infer the class’s type argument.
AwaitCond
new JavaTestKit(system) {{ getRef().tell(42, ActorRef.noSender()); new AwaitCond( duration("1 second"), // maximum wait time duration("100 millis") // interval at which to check the condition ) { // do not put code outside this method, will run afterwards protected boolean cond() { // typically used to wait for something to start up return msgAvailable(); } }; }};This general construct is not connected with the test kit’s message reception, the embedded condition can compute the boolean result from anything in scope.
- AwaitAssert
new JavaTestKit(system) {{ getRef().tell(42, ActorRef.noSender()); new AwaitAssert( duration("1 second"), // maximum wait time duration("100 millis") // interval at which to check the condition ) { // do not put code outside this method, will run afterwards protected void check() { assertEquals(msgAvailable(), true); } }; }};This general construct is not connected with the test kit’s message reception, the embedded assert can check anything in scope.
There are also cases where not all messages sent to the test kit are actually relevant to the test, but removing them would mean altering the actors under test. For this purpose it is possible to ignore certain messages:
IgnoreMsg
new JavaTestKit(system) {{ // ignore all Strings new IgnoreMsg() { protected boolean ignore(Object msg) { return msg instanceof String; } }; getRef().tell("hello", ActorRef.noSender()); getRef().tell(42, ActorRef.noSender()); expectMsgEquals(42); // remove message filter ignoreNoMsg(); getRef().tell("hello", ActorRef.noSender()); expectMsgEquals("hello"); }};
Expecting Log Messages
Since an integration test does not allow to the internal processing of the participating actors, verifying expected exceptions cannot be done directly. Instead, use the logging system for this purpose: replacing the normal event handler with the TestEventListener and using an EventFilter allows assertions on log messages, including those which are generated by exceptions:
new JavaTestKit(system) {{
assertEquals("TestKitDocTest", system.name());
final ActorRef victim = system.actorOf(Props.empty(), "victim");
final int result = new EventFilter<Integer>(ActorKilledException.class) {
protected Integer run() {
victim.tell(Kill.getInstance(), ActorRef.noSender());
return 42;
}
}.from("akka://TestKitDocTest/user/victim").occurrences(1).exec();
assertEquals(42, result);
}};
If a number of occurrences is specific—as demonstrated above—then exec() will block until that number of matching messages have been received or the timeout configured in akka.test.filter-leeway is used up (time starts counting after the run() method returns). In case of a timeout the test fails.
Note
Be sure to exchange the default logger with the TestEventListener in your application.conf to enable this function:
akka.loggers = [akka.testkit.TestEventListener]
Timing Assertions
Another important part of functional testing concerns timing: certain events must not happen immediately (like a timer), others need to happen before a deadline. Therefore, all examination methods accept an upper time limit within the positive or negative result must be obtained. Lower time limits need to be checked external to the examination, which is facilitated by a new construct for managing time constraints:
new JavaTestKit(system) {{
getRef().tell(42, ActorRef.noSender());
new Within(Duration.Zero(), Duration.create(1, "second")) {
// do not put code outside this method, will run afterwards
public void run() {
assertEquals((Integer) 42, expectMsgClass(Integer.class));
}
};
}};
The block in Within.run must complete after a Duration which is between min and max, where the former defaults to zero. The deadline calculated by adding the max parameter to the block's start time is implicitly available within the block to all examination methods, if you do not specify it, it is inherited from the innermost enclosing within block.
It should be noted that if the last message-receiving assertion of the block is expectNoMsg or receiveWhile, the final check of the within is skipped in order to avoid false positives due to wake-up latencies. This means that while individual contained assertions still use the maximum time bound, the overall block may take arbitrarily longer in this case.
Note
All times are measured using System.nanoTime, meaning that they describe wall time, not CPU time or system time.
Accounting for Slow Test Systems
The tight timeouts you use during testing on your lightning-fast notebook will invariably lead to spurious test failures on the heavily loaded Jenkins server (or similar). To account for this situation, all maximum durations are internally scaled by a factor taken from the Configuration, akka.test.timefactor, which defaults to 1.
You can scale other durations with the same factor by using dilated method in JavaTestKit.
new JavaTestKit(system) {{
final Duration original = duration("1 second");
final Duration stretched = dilated(original);
assertTrue("dilated", stretched.gteq(original));
}};
Using Multiple Probe Actors
When the actors under test are supposed to send various messages to different destinations, it may be difficult distinguishing the message streams arriving at the testActor when using the JavaTestKit as shown until now. Another approach is to use it for creation of simple probe actors to be inserted in the message flows. The functionality is best explained using a small example:
new JavaTestKit(system) {{
// simple actor which just forwards messages
class Forwarder extends UntypedActor {
final ActorRef target;
@SuppressWarnings("unused")
public Forwarder(ActorRef target) {
this.target = target;
}
public void onReceive(Object msg) {
target.forward(msg, getContext());
}
}
// create a test probe
final JavaTestKit probe = new JavaTestKit(system);
// create a forwarder, injecting the probe’s testActor
final Props props = Props.create(Forwarder.class, this, probe.getRef());
final ActorRef forwarder = system.actorOf(props, "forwarder");
// verify correct forwarding
forwarder.tell(42, getRef());
probe.expectMsgEquals(42);
assertEquals(getRef(), probe.getLastSender());
}};
This simple test verifies an equally simple Forwarder actor by injecting a probe as the forwarder’s target. Another example would be two actors A and B which collaborate by A sending messages to B. In order to verify this message flow, a TestProbe could be inserted as target of A, using the forwarding capabilities or auto-pilot described below to include a real B in the test setup.
If you have many test probes, you can name them to get meaningful actor names in test logs and assertions:
new JavaTestKit(system) {{
final TestProbe worker = new TestProbe(system, "worker");
final TestProbe aggregator = new TestProbe(system, "aggregator");
assertTrue(worker.ref().path().name().startsWith("worker"));
assertTrue(aggregator.ref().path().name().startsWith("aggregator"));
}};
Probes may also be equipped with custom assertions to make your test code even more concise and clear:
new JavaTestKit(system) {{
class MyProbe extends JavaTestKit {
public MyProbe() {
super(system);
}
public void assertHello() {
expectMsgEquals("hello");
}
}
final MyProbe probe = new MyProbe();
probe.getRef().tell("hello", ActorRef.noSender());
probe.assertHello();
}};
You have complete flexibility here in mixing and matching the JavaTestKit facilities with your own checks and choosing an intuitive name for it. In real life your code will probably be a bit more complicated than the example given above; just use the power!
Warning
Any message send from a TestProbe to another actor which runs on the CallingThreadDispatcher runs the risk of dead-lock, if that other actor might also send to this probe. The implementation of TestProbe.watch and TestProbe.unwatch will also send a message to the watchee, which means that it is dangerous to try watching e.g. TestActorRef from a TestProbe.
Watching Other Actors from Probes
A JavaTestKit can register itself for DeathWatch of any other actor:
new JavaTestKit(system) {{
final JavaTestKit probe = new JavaTestKit(system);
probe.watch(target);
target.tell(PoisonPill.getInstance(), ActorRef.noSender());
final Terminated msg = probe.expectMsgClass(Terminated.class);
assertEquals(msg.getActor(), target);
}};
Replying to Messages Received by Probes
The probe stores the sender of the last dequeued message (i.e. after its expectMsg* reception), which may be retrieved using the getLastSender method. This information can also implicitly be used for having the probe reply to the last received message:
new JavaTestKit(system) {{
final JavaTestKit probe = new JavaTestKit(system);
probe.getRef().tell("hello", getRef());
probe.expectMsgEquals("hello");
probe.reply("world");
expectMsgEquals("world");
assertEquals(probe.getRef(), getLastSender());
}};
Forwarding Messages Received by Probes
The probe can also forward a received message (i.e. after its expectMsg* reception), retaining the original sender:
new JavaTestKit(system) {{
final JavaTestKit probe = new JavaTestKit(system);
probe.getRef().tell("hello", getRef());
probe.expectMsgEquals("hello");
probe.forward(getRef());
expectMsgEquals("hello");
assertEquals(getRef(), getLastSender());
}};
Auto-Pilot
Receiving messages in a queue for later inspection is nice, but in order to keep a test running and verify traces later you can also install an AutoPilot in the participating test probes (actually in any TestKit) which is invoked before enqueueing to the inspection queue. This code can be used to forward messages, e.g. in a chain A --> Probe --> B, as long as a certain protocol is obeyed.
new JavaTestKit(system) {{
final JavaTestKit probe = new JavaTestKit(system);
// install auto-pilot
probe.setAutoPilot(new TestActor.AutoPilot() {
public AutoPilot run(ActorRef sender, Object msg) {
sender.tell(msg, ActorRef.noSender());
return noAutoPilot();
}
});
// first one is replied to directly ...
probe.getRef().tell("hello", getRef());
expectMsgEquals("hello");
// ... but then the auto-pilot switched itself off
probe.getRef().tell("world", getRef());
expectNoMsg();
}};
The run method must return the auto-pilot for the next message, wrapped in an Option; setting it to None terminates the auto-pilot.
Caution about Timing Assertions
The behavior of within blocks when using test probes might be perceived as counter-intuitive: you need to remember that the nicely scoped deadline as described above is local to each probe. Hence, probes do not react to each other's deadlines or to the deadline set in an enclosing JavaTestKit instance:
new JavaTestKit(system) {{
final JavaTestKit probe = new JavaTestKit(system);
new Within(duration("1 second")) {
public void run() {
probe.expectMsgEquals("hello");
}
};
}};
Here, the expectMsgEquals call will use the default timeout.
Testing parent-child relationships
The parent of an actor is always the actor that created it. At times this leads to a coupling between the two that may not be straightforward to test. There are several approaches to improve testability of a child actor that needs to refer to its parent:
- when creating a child, pass an explicit reference to its parent
- create the child with a TestProbe as parent
- create a fabricated parent when testing
Conversely, a parent's binding to its child can be lessened as follows:
- when creating a parent, tell the parent how to create its child
For example, the structure of the code you want to test may follow this pattern:
static class Parent extends UntypedActor {
final ActorRef child = context().actorOf(Props.create(Child.class), "child");
boolean ponged = false;
@Override public void onReceive(Object message) throws Exception {
if ("pingit".equals(message)) {
child.tell("ping", self());
} else if ("pong".equals(message)) {
ponged = true;
} else {
unhandled(message);
}
}
}
static class Child extends UntypedActor {
@Override public void onReceive(Object message) throws Exception {
if ("ping".equals(message)) {
context().parent().tell("pong", self());
} else {
unhandled(message);
}
}
}
Introduce child to its parent
The first option is to avoid use of the context.parent function and create a child with a custom parent by passing an explicit reference to its parent instead.
class DependentChild extends UntypedActor {
private final ActorRef parent;
public DependentChild(ActorRef parent) {
this.parent = parent;
}
@Override public void onReceive(Object message) throws Exception {
if ("ping".equals(message)) {
parent.tell("pong", self());
} else {
unhandled(message);
}
}
}
Create the child using JavaTestKit
The JavaTestKit class can in fact create actors that will run with the test probe as parent. This will cause any messages the the child actor sends to context().getParent() to end up in the test probe.
JavaTestKit parent = new JavaTestKit(system);
ActorRef child = parent.childActorOf(Props.create(Child.class));
parent.send(child, "ping");
parent.expectMsgEquals("pong");
Using a fabricated parent
If you prefer to avoid modifying the child constructor you can create a fabricated parent in your test. This, however, does not enable you to test the parent actor in isolation.
class FabricatedParentCreator implements Creator<Actor> {
private final TestProbe proxy;
public FabricatedParentCreator(TestProbe proxy) {
this.proxy = proxy;
}
@Override public Actor create() throws Exception {
return new UntypedActor() {
final ActorRef child = context().actorOf(Props.create(Child.class), "child");
@Override public void onReceive(Object x) throws Exception {
if (sender().equals(child)) {
proxy.ref().forward(x, context());
} else {
child.forward(x, context());
}
}
};
}
}
TestProbe proxy = new TestProbe(system);
ActorRef parent = system.actorOf(Props.create(new FabricatedParentCreator(proxy)));
proxy.send(parent, "ping");
proxy.expectMsg("pong");
Externalize child making from the parent
Alternatively, you can tell the parent how to create its child. There are two ways to do this: by giving it a Props object or by giving it a function which takes care of creating the child actor:
class DependentParent extends UntypedActor {
final ActorRef child;
boolean ponged = false;
public DependentParent(Props childProps) {
child = context().actorOf(childProps, "child");
}
@Override public void onReceive(Object message) throws Exception {
if ("pingit".equals(message)) {
child.tell("ping", self());
} else if ("pong".equals(message)) {
ponged = true;
} else {
unhandled(message);
}
}
}
class GenericDependentParent extends UntypedActor {
final ActorRef child;
boolean ponged = false;
public GenericDependentParent(Function<ActorRefFactory, ActorRef> childMaker)
throws Exception {
child = childMaker.apply(context());
}
@Override public void onReceive(Object message) throws Exception {
if ("pingit".equals(message)) {
child.tell("ping", self());
} else if ("pong".equals(message)) {
ponged = true;
} else {
unhandled(message);
}
}
}
Creating the Actor is straightforward and the function may look like this in your test code:
Function<ActorRefFactory, ActorRef> maker = new Function<ActorRefFactory, ActorRef>() {
@Override public ActorRef apply(ActorRefFactory param) throws Exception {
return probe.ref();
}
};
ActorRef parent = system.actorOf(Props.create(GenericDependentParent.class, maker));
And like this in your application code:
Function<ActorRefFactory, ActorRef> maker = new Function<ActorRefFactory, ActorRef>() {
@Override public ActorRef apply(ActorRefFactory f) throws Exception {
return f.actorOf(Props.create(Child.class));
}
};
ActorRef parent = system.actorOf(Props.create(GenericDependentParent.class, maker));
Which of these methods is the best depends on what is most important to test. The most generic option is to create the parent actor by passing it a function that is responsible for the Actor creation, but using TestProbe or having a fabricated parent is often sufficient.
CallingThreadDispatcher
The CallingThreadDispatcher serves good purposes in unit testing, as described above, but originally it was conceived in order to allow contiguous stack traces to be generated in case of an error. As this special dispatcher runs everything which would normally be queued directly on the current thread, the full history of a message's processing chain is recorded on the call stack, so long as all intervening actors run on this dispatcher.
How to use it
Just set the dispatcher as you normally would:
system.actorOf(
Props.create(MyActor.class)
.withDispatcher(CallingThreadDispatcher.Id()));
How it works
When receiving an invocation, the CallingThreadDispatcher checks whether the receiving actor is already active on the current thread. The simplest example for this situation is an actor which sends a message to itself. In this case, processing cannot continue immediately as that would violate the actor model, so the invocation is queued and will be processed when the active invocation on that actor finishes its processing; thus, it will be processed on the calling thread, but simply after the actor finishes its previous work. In the other case, the invocation is simply processed immediately on the current thread. Futures scheduled via this dispatcher are also executed immediately.
This scheme makes the CallingThreadDispatcher work like a general purpose dispatcher for any actors which never block on external events.
In the presence of multiple threads it may happen that two invocations of an actor running on this dispatcher happen on two different threads at the same time. In this case, both will be processed directly on their respective threads, where both compete for the actor's lock and the loser has to wait. Thus, the actor model is left intact, but the price is loss of concurrency due to limited scheduling. In a sense this is equivalent to traditional mutex style concurrency.
The other remaining difficulty is correct handling of suspend and resume: when an actor is suspended, subsequent invocations will be queued in thread-local queues (the same ones used for queuing in the normal case). The call to resume, however, is done by one specific thread, and all other threads in the system will probably not be executing this specific actor, which leads to the problem that the thread-local queues cannot be emptied by their native threads. Hence, the thread calling resume will collect all currently queued invocations from all threads into its own queue and process them.
Limitations
Warning
In case the CallingThreadDispatcher is used for top-level actors, but without going through TestActorRef, then there is a time window during which the actor is awaiting construction by the user guardian actor. Sending messages to the actor during this time period will result in them being enqueued and then executed on the guardian’s thread instead of the caller’s thread. To avoid this, use TestActorRef.
If an actor's behavior blocks on a something which would normally be affected by the calling actor after having sent the message, this will obviously dead-lock when using this dispatcher. This is a common scenario in actor tests based on CountDownLatch for synchronization:
val latch = new CountDownLatch(1)
actor ! startWorkAfter(latch) // actor will call latch.await() before proceeding
doSomeSetupStuff()
latch.countDown()
The example would hang indefinitely within the message processing initiated on the second line and never reach the fourth line, which would unblock it on a normal dispatcher.
Thus, keep in mind that the CallingThreadDispatcher is not a general-purpose replacement for the normal dispatchers. On the other hand it may be quite useful to run your actor network on it for testing, because if it runs without dead-locking chances are very high that it will not dead-lock in production.
Warning
The above sentence is unfortunately not a strong guarantee, because your code might directly or indirectly change its behavior when running on a different dispatcher. If you are looking for a tool to help you debug dead-locks, the CallingThreadDispatcher may help with certain error scenarios, but keep in mind that it has may give false negatives as well as false positives.
Thread Interruptions
If the CallingThreadDispatcher sees that the current thread has its isInterrupted() flag set when message processing returns, it will throw an InterruptedException after finishing all its processing (i.e. all messages which need processing as described above are processed before this happens). As tell cannot throw exceptions due to its contract, this exception will then be caught and logged, and the thread’s interrupted status will be set again.
If during message processing an InterruptedException is thrown then it will be caught inside the CallingThreadDispatcher’s message handling loop, the thread’s interrupted flag will be set and processing continues normally.
Note
The summary of these two paragraphs is that if the current thread is interrupted while doing work under the CallingThreadDispatcher, then that will result in the isInterrupted flag to be true when the message send returns and no InterruptedException will be thrown.
Benefits
To summarize, these are the features with the CallingThreadDispatcher has to offer:
- Deterministic execution of single-threaded tests while retaining nearly full actor semantics
- Full message processing history leading up to the point of failure in exception stack traces
- Exclusion of certain classes of dead-lock scenarios
Tracing Actor Invocations
The testing facilities described up to this point were aiming at formulating assertions about a system’s behavior. If a test fails, it is usually your job to find the cause, fix it and verify the test again. This process is supported by debuggers as well as logging, where the Akka toolkit offers the following options:
Logging of exceptions thrown within Actor instances
This is always on; in contrast to the other logging mechanisms, this logs at ERROR level.
Logging of special messages
Actors handle certain special messages automatically, e.g. Kill, PoisonPill, etc. Tracing of these message invocations is enabled by the setting akka.actor.debug.autoreceive, which enables this on all actors.
Logging of the actor lifecycle
Actor creation, start, restart, monitor start, monitor stop and stop may be traced by enabling the setting akka.actor.debug.lifecycle; this, too, is enabled uniformly on all actors.
All these messages are logged at DEBUG level. To summarize, you can enable full logging of actor activities using this configuration fragment:
akka {
loglevel = "DEBUG"
actor {
debug {
autoreceive = on
lifecycle = on
}
}
}
Configuration
There are several configuration properties for the TestKit module, please refer to the reference configuration.
Contents


VIDEO: UBC scientists use drones to study southern resident killer whales
Main question is whether endangered southern residents are getting enough chinook salmon
by The Canadian PressScientists at UBC are using aerial drones to study whether endangered southern resident killer whales are getting enough of their preferred prey, chinook salmon.
They spent three weeks in August and September monitoring pods of southern and northern resident killer whales in the Salish Sea and off the central coast of B.C.
Project lead Andrew Trites says because of a lack of historical data and behavioural observations of southern residents, the northern residents are an important point of comparison.
He says like southern residents, they feed primarily on chinook and chum salmon and face many similar threats from water and noise pollution, increased shipping traffic and reduced abundance of food but unlike their southern counterparts, the northern population has increased significantly.
The southern resident killer whales number 73 while their northern counterparts stand at about 300.
Over the coming months, the team will analyze their data and try to build a comprehensive picture of resident killer whale feeding behaviour to inform conservation and recovery efforts.
READ MORE: ‘Orcas are not for entertainment:’ Activist plans to disrupt West Coast whale watching
The Canadian Press


This website is kind of blogging site. Regularly posting some python concepts here. It gonna be a discussion in the forum. So please do read, comment your perspective.


Coding Quiz
This project was undertaken to create a site to give the user an experience of taking a quiz of several questions. In which completing the quiz it would tell the user if the answer was correct or incorrect. If incorrect the quiz then would give the correct answer and move to the next question. Upon completion the user would be given their score and allow to enter their name in the high scores table.
Workday Scheduler
This project was undertaken to create a site to give the user an application where they could create a hourly scheduler to plot out their activities for the current day. It generates working hours from 6:00 am through 6:00 pm along with input boxes to enter that time slot's activity. Then it gives the user the option to save the activity in local storage so when they refresh the site it will be retained. Also the site color codes the hour time slots by past, current and future.
Weather Dashboard
This project was undertaken to create a site to give the user an experience finding the current weather conditions for a specific city. In which completing the quiz it would tell the user if the answer was correct or incorrect. If incorrect the quiz then would give the correct answer and move to the next question. Upon completion the user would be given their score and allow to enter their name in the high scores table.
Brew Hopper
This project was undertaken to create a site to give the user an experience of getting their location and then generating a search radius. The application then pulls up a list of all the local breweries in that search radius and allows the user to pick out a variety and put their location on the map and generates the fastest routes to those breweries.


{% extends "base.html" %} {% block page_meta %} {% endblock page_meta %} {% block content %}
The page you requested was not found.


|
KratosMultiphysics
KRATOS Multiphysics (Kratos) is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.
|
This application features continuum-based meshfree and particle methods with main motivations of simulating non-linear large deformable materials, such as free-surface flows, geomechanical phenomena, and extreme events involving impact, penetration, fragmentation, blast, multi-phase interaction, failure evolution, etc.
The recent research and development have been focused solely on the Material Point Method (MPM) and on partiotioned coupled formulations MPM-FEM and MPM-DEM.
This application is part of the Kratos Multiphysics Platform. Instructions on how to download, install and run the software in your local machine for development and testing purposes are available for both Linux and Windows distributions Installation page.
Build Kratos and check the configuration files
In LINUX: check that in the /path_to_kratos/scripts/configure.sh the followinglines are written:
In WINDOWS: check that in the /path_to_kratos/scripts/configute.bat the following lines appears:
so the Particle Mechanics application is compiled along with auxiliary linear solvers required.
Some use-cases and validation examples are available in the Particle Mechanics section of the Examples repository. Also, some unit tests of the main features can be found in the tests folder.
A GiD user interface for the MPM application is also available. It is located in GiD interface repository in GiD interface repository.
It requires GiD - Pre and Post Processing software.
Particle or meshfree methods are a category of methods where the state of a system is represented by a set of particles, without a fixed connectivity; hence, making such methods suitable for the analysis of moving discontinuities and large deformations with breaking and fragmentation. This approach does not suffer from the mesh distortion and entanglement issues posed by other Lagrangian discretizations such as the finite element method.
The MPM is an hybrid thechnique which uses a fixed background grid (or mesh) for solving the governing equations in a FEM fashion and set of material particles (MP) for storing all the hystorical variables and material informations. MPM has gained a remarkably increasing popularity due to its capability in simulating problems involving historically dependent materials and large deformations. As MPM is able to combine the strengths of Eulerian and Lagrangian methods, it has been utilized in various engineering applications and industrial purposes, in particular in geomechanics and environmental fluid dynamics field.
Recommended references for implementation details of MPM in Kratos:
The following features are currently available and subject to development within the Particle Mechanics Application:
The Particle Mechanics Application is OPEN SOURCE. The main code and program structure is available and aimed to grow with the need of any user willing to expand it. The BSD (Berkeley Software Distribution) licence allows to use and distribute the existing code without any restriction, but with the possibility to develop new parts of the code on an open or close basis depending on the developers.


| read.and.check {coda} | R Documentation |
Input is read interactively and checked against conditions specified
by the arguments what
, lower
, upper
and
answer.in
. If the input does not satisfy all the conditions,
an appropriate error message is produced and the user is prompted
to provide input. This process is repeated until a valid input value
is entered.
read.and.check(message = "", what = numeric(), lower, upper, answer.in, default)
message |
message displayed before prompting for user input. |
what |
the type of |
lower |
lower limit of input, for numeric input only. |
upper |
upper limit of input, for numeric input only. |
answer.in |
the input must correspond to one of the elements of the
vector |
default |
value assumed if user enters a blank line. |
The value of the valid input. When the default
argument is
specified, a blank line is accepted as valid input and in this case
read.and.check
returns the value of default
.
Since the function does not return a value until it receives valid input, it extensively checks the conditions for consistency before prompting the user for input. Inconsistent conditions will cause an error.
Martyn Plummer


--- layout: page title: About header-img: "img/about-bg.png" ---
Just a regular italian who has been many things in his life and many more wants to become! My journey through coding is the epitome of this spirit of adventure, made of many beautiful moments and way more tough ones. If you have questions about me or what I write about, please contact me at: textme.mpgames@gmail.com.


Note: We are using the word “version” in this section because technically, the modified version of a file in your working copy does not belong to a revision until you commit your changes.
When you select “Compare Differences...” from the “Action” menu, a dialog opens to select which two versions of the same file to compare. By default, the original version in the working copy —the BASE revision— is selected on the left, and the modified file in the working copy —the version that's actually in your working copy— is selected on the right.
A list of other revisions is shown in the table below the popup menu. Choose “Existing revision in Repository:” from the popup menu to select a revision to compare with in the table below it. Finally, click the “Compare” button to compare the versions selected on the left and right with eachother.


THE LAY OF THE LAND By Harvey Karten, Ph.D. Northern Arts Entertainment Director: Larry Arrick Writer: Mel Shapiro Cast: Sally Kellerman, Ed Begley, Jr., Tyne Daly, Stuart Margolin, Sandra Taylor
"In and Out," "Private Parts," "The Lay of the Land." The folks making up movie titles appear to be in competition for best double entendres with the makers of XXX videos. In the last instance, writer Mel Shapiro's screenplay has been opened up for the screen, but Larry Arrick's direction is unable to convince us that this is really not in essence a two-character play that should have remained on the stage--or on the tube. It's a small tale, a thin story which cannot sustain its 94 minutes, filled with cartoonish supporting characters and a theme of late mid-life and marital crisis which by now appears stale. Obviously Sally Kellerman's lead role cannot compare to her best-known work, in "M*A*S*H," but to get an idea of how fragile her role is in "The Lay of the Land" you need only rent the video of "Back to School" and marvel at her rendition of the part of an academic. The best thing about the current work, co-produced by Ms. Kellerman and her real-life husband Jonathan D. Krane is the soundtrack, which features her sexy rendition of the song, "Questions." The Big Question is "Does he love me still?" and in a movie which does not prohibit sentimentality, you know the answer.
Kellerman plays the role of a graduate school film instructor, M.J. Dankworth, who has become so complacent in her marriage and her profession that she has fallen behind on her dream project: to film in Brazil. Her husband, Harvey (Ed Begley Jr.) has a similar predicament: he is coming up for tenure as an instructor in Russian literature but his book on Pushkin is going nowhere. As he hits the Big 5-0, his fiftieth birthday, he is unable to concentrate on much of anything; that is, until his grad student Muriel Johanson (Sandra Taylor) who seems to come right out of a centerfold takes an interest this man--who is older than her father. Muriel seduces Harvey with such subtle lines as assuring him that she works out with a personal trainer to avoid being distracted by her horniness. M.J., who is seeing an analyst over a hand wrapped in gauze to treat a psychosomatic allergy throws off such quips as "If my hand isn't better, do I pay you anyway?" Director Larry Arrick comes across best when he occasionally displays surreal episodes to represent momentary daydreams of her subjects. Rapidly edited scenarios feature M.J. with Dr. Guttmacher (Tyne Daly) in an assortment of functions, while Harvey dreams only of his new young sweetheart encouraging his advances. Some cartoonish characters like Dean Bill Whittier (Avery Schreiber) appear now and then, the most egregiously silly being Carmine Ficcone (Stuart Margolin), a private investigator hired by M.J. whom she meets at his ranch and who is determined to seduce her (he's Italian). The story descends into further banality when M.J.'s woman friend describes the compromises she has made to keep her marriage together: she tolerates her husband's affairs with another man. The most mature person in the film is Dr. Smith (Patrick Desmond), Harvey's psychotherapist. He doesn't talk. Rated R. Running Time: 94 minutes. (C) 1997 Harvey Karten
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


I want my story to be heard, as I want the stories of all mental patients to be heard.
In the fall of 1995(August, I believe), when I was a freshwoman in highschool, I started taking Paxil. I weighed 154 lbs. I was depressed, and it worked for me. That, among other things like love and art, brought me out. I stabalized at 20 mg a month or two after taking it. I still went through rough patches (I gained 20 lbs.), but I did okay. I felt like me. Then I went to college, and life was wonderful, but challenging (down to 165 lbs.).
Things started to get bad the tail end of Softmore year of college, Spring 2001. I had gotten lice and shaved my head (I had long hair that I'd promised myself I'd never cut) and I stopped taking Paxil because I hated being tied to drugs and got fed up with the HMO doctors not being avialable.
Junior year, Fall 2001, I moved off campus into a really depressing living situation. Classes were really difficult, and I started getting panic attacks and insomnia. I wondered if I was going crazy, like two of my female relatives both had - in their twenties, no less. I was 20/21 at the time. Just as bad, I had a friend that I had a messed up relationship with, and she was the one I hung out with the most. Maybe we needed each other, in some twisted way. I was also so anxious that I lost 10 lbs. in about 2 weeks, going from 165 to 155 lbs.
Things were hellish, and then, suddenly, they got wonderful. Christmas break came, I started taking Paxil again, and I started seeing a new shrink. Those changes helped give me the courage to get out of my bad living situation, and back on campus, which I loved.  And so happy. And so happy. And so happy... For two weeks straight.
In other words, I had a 'manic episode.' I was aware of cheerfuly driving myself into the ground. I was also terrified of dying, and went to the emergency room twice. I was anxious. My Dad said all I needed was to relax and get a good night's sleep, but I couldn't. Not after what I had just been through. That fall I had been dragging and kicking and puching myself through life. I couldn't just let go...
I was also on Paxil, which was helping to keep me in happy land. At least, that's what I intuitively felt, and I now know you're not supposed to give Paxil to manic people. But instead of just taking me off Paxil, the doctors decided to put me on something else _in addition_(That kinda pissed me off, and made me feel not listened to).
That something was Saroquel, 2.5 miligrams if I remember correctly. That did not go over well. I went from manic to delusional in a heartbeat. Really bad. I had been somewhat delusional before, but that Saroquel, in trying to get me to sleep, just turned off my rational brain. I can remember telling my Mom something like 'It feels like I'm dreaming.' And then It made me flashback to a nightmare I'd had when I was a little kid. There was an evil lady I had to run away from... suffice to say, it didn't go over well with my Mom. Or the police.
Things haven't really gotten that much better.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


manic and impulsive criminal from Zaun, Jinx lives to wreak havoc without care for the consequences. With an arsenal of deadly weapons, she unleashes the loudest blasts and brightest explosions to leave a trail of mayhem and panic in her wake. Jinx despises boredom, and gleefully brings her own chaotic brand of pandemonium wherever she goes. No one knows for sure exactly where Jinx came from, but many urban legends and folktales have sprung up around her. Some have her as a young gang member who fell in with the wrong crowd and was either traumatized by one too many killings, suffered too much at the hands of an enemy, or was simply driven insane by sump fumes.
Master Chief Petty Officer John-117 is arguably the most pivotal and important figure of the human race in the mid-26th century. Abducted at the age of six years old from his homeworld of Eridanus II by the Office of Naval Intelligence (ONI), he was conscripted into the SPARTAN-II program. The initiative was originally designed to quell human rebellion against the Unified Earth Government as the human Insurrection movement neared its tipping point. John endured harsh physical and mental training, survived the physical augmentations required by the program, and was integrated into state-of-the-art Mjolnir battle armor. He was later paired with an incredibly advanced Smart AI known as Cortana. John and Cortana were the culminations of the SPARTAN-II and MJOLNIR programs, allowing a Spartan to safely carry an extremely powerful AI into combat--an advancement that ultimately changed the course of the war. Throughout his training and early career, John emerged as a clear leader among the Spartans and was set to lead a successful UNSC campaign to stop a brewing human civil war. In reality, he became the salvation of the human race itself not once, but twice. First, in the face of an alien hegemony called the Covenant--an alien empire bent on the complete destruction of humanity in order to assure their ascendance into misguided godhood. Most recently, John defended humanity against the efforts of an ancient Forerunner called the Didact, who returned to exact his revenge against humanity for wars fought a hundred millennia before.
Sergeant Marcus Michael Fenix ES is a former Gear soldier in the Coalition of Ordered Governments army. A legendary war hero, Marcus served with distinction in the Pendulum Wars, which earned him the Embry Star, the COG's highest military award, for his actions during the Battle of Aspho Fields. He is also a convicted "coward" for his actions at the Battle of Ephyra. Like the rest of humankind, he saw everything change on Emergence Day. Marcus bravely fought against the Locust for ten years until the Battle of Ephyra, where he abandoned his post to rescue his father, Professor Adam Fenix, but could not reach him in time. With his father presumed dead, Marcus was tried for dereliction of duty and sentenced to 40 years in Jacinto Maximum Security Prison. He was incarcerated for four years before being released by his longtime friend, Dominic Santiago. Marcus was later promoted to replace Lt. Minh Young Kim after the squad leader's death. Along with the rest of Delta Squad, he successfully detonated the Lightmass Bomb and destroyed much of the Locust Hollow. With his reputation restored, Marcus continued fighting against the Locust, culminating in the Sinking of Jacinto
Miles Morales, a young kid from Brooklyn visited his uncle Aaron Davis (which was against his parents' wishes, due to his uncle's criminal past) after being awarded the final spot in a charter school lottery. At his uncle's apartment Miles was bitten by the Oz-enhanced spider, which emerged from Aaron's bag, and Miles discovered he received super-human abilities like camouflage, increased agility, as well as some sort of stun blast, and upon revealing his newly found powers to his best friend, Ganke Lee, both concluded he had power similar to Spider-Man's, including wall-crawling.[18][19] But Miles reacted negatively, as he just wanted to be normal, and decided to leave heroism to the actual Spider-Man. Months later, Spider-Man died saving his family from Osborn. Miles arrived late to the scene. Struck with grief at not helping Peter Parker before his demise, Miles decided to follow Parker's philosophy -- with great power comes great responsibility -- and so continue Peter's legacy.


Gotta Catch a Vibe
Welcome Trainers:
Harness the Power of the Weather to Make the Most of Type Advantages!


Package org.apache.shiro.util
Your run-of-the-mill 'util' package for components and logic widely used across the framework that can't
find their home into a proper OO hierarchy (or, most likely for things used across many hierarchies).
-
Interface Summary Interface Description ByteSource AByteSource
wraps a byte array and provides additional encoding operations.Destroyable Shiro container-agnostic interface that indicates that this object requires a callback during destruction.Factory<T> Generics-aware interface supporting the Factory Method design pattern.Initializable Shiro container-agnostic interface that indicates that this object requires initialization.Nameable Interface implemented by components that can be named, such as via configuration, and wish to have that name set once it has been configured.PatternMatcher Interface for components that can match source strings against a specified pattern string.ThreadState AThreadState
instance manages any state that might need to be bound and/or restored during a thread's execution. -
Class Summary Class Description AbstractFactory<T> TODO - Class JavaDocAntPathMatcher PathMatcher implementation for Ant-style path patterns.Assert Assertion utility class that assists in validating arguments.ByteSource.Util Utility class that can construct ByteSource instances.ClassUtils Utility method library used to conveniently interact withClass
es, such as acquiring them from the applicationClassLoader
s and instantiating Objects from them.CollectionUtils Static helper class for use dealing with Collections.JavaEnvironment Deprecated. This class is no longer used in Shiro and will be removed in the next major version.JdbcUtils A set of static helper methods for managing JDBC API objects.LifecycleUtils Utility class to help callInitializable.init()
andDestroyable.destroy()
methods cleanly on any object.MapContext AMapContext
provides a common base for context-based data storage in aMap
.PermissionUtils Utility class to help with String-to-Permission object resolution.RegExPatternMatcher PatternMatcher
implementation that uses standardjava.util.regex
objects.SimpleByteSource Very simpleByteSource
implementation that maintains an internalbyte[]
array and uses theHex
andBase64
codec classes to support thetoHex()
andtoBase64()
implementations.SoftHashMap<K,V> ASoftHashMap
is a memory-constrained map that stores its values inSoftReference
s.StringUtils Simple utility class for String operations useful across the framework.ThreadContext A ThreadContext provides a means of binding and unbinding objects to the current thread based on key/value pairs. -
Exception Summary Exception Description InstantiationException Runtime exception thrown by the framework when unable to instantiate a Class via reflection.UnknownClassException The Shiro framework'sRuntimeException
equivalent of the JDK'sClassNotFoundException
, to maintain a RuntimeException paradigm.


Just watched a great video by Mike Andrews called How To Break Web Software - A look at security vulnerabilities in web software.
Mike talks about cross-site scripting (XSS), session hijacking, HTTP response splitting and other things. He shows how easy it is to construct such attacks and ways you can prevent them.
Check it out for yourself here.


CMIP models water Southern climate Ocean ACC wind surface changes model variability Antarctic circulation forcing ocean transport CMIP, mean change stress Geophys. Res. SIE formation future eddy fluxes mass observed AAIW bias ice mixed models, sea significant buoyancy subpolar MLD .×. deep response {border-style HIST MOC heat impact large models. strength AABW freshwater px;} #ffffff;} coupled observations position relative Clim. increase inter-model mode associated layer multi-model twenty-first westerly RCP. SAMW biases enhanced particularly properties resolution tends trend Circumpolar Lett. biased cell century does poleward representation state warming consistent differences global influence larger regions strong CDW clear generally gyre gyres jet positive relatively sea-ice shift studies upper vertical weaker Current Oceanogr. Phys. correlation density ensemble extent factors masses mixing processes reduced spatial stratification winds Pacific Rintoul convection dramatic end forcing. interior largely linked maximum number observational owing result scenario stronger winter km ./GL ./JCLI. Bracegirdle Ekman Hemisphere Marshall RCP., Wang Weddell appear atmospheric carbon complex difficult equatorward historical initial isopycnal overturning ozone px; relationship scenarios significantly subtropical transport, {font-family ./JC . Sp ACC, CMIP. Griff Intercomparison Ocean, Ross SIE, Sallée area coherent depth driving figure font-size forcing, increased increases intermediate largest meridional output presently probably recent reduction results seasonal shelf smaller southern structure summer temperature weak Austral Climate Coupled Despite Downes Figure Indian Meijers Model accurate appears available characteristics directly double; drive form formation, formed freshening general important indicates likely lower north parametrization parametrizations poor poorly range setting shallow small strengthening strongly subduction table tend total transformation trends uptake upwelling varies volume waters zonal ./JCLI-D--. ./grl. Assessment February Fyfe Ocean. Oceans Project SAM SAMW/AAIW Water air–sea and, annular anthropogenic assess assessment border-color border-width circumpolar column component control core despite dynamic focus improved improvement itself layers minimum modelled numbers phase possible presence problem pumping reanalysis reproduce residual role scenarios, seen simulations. size solid; south strength, terms topographic value warm way {font-style {font-weight Sv ./jgrc. Adapted Atmos. Bindoff Bruneau IPCC Meredith SAMW, Sea Shuckburgh Treg Turner ]), accurately atmosphere background base better bold bulk consistently contribution contributions correlated courier; curl cycle cycles degree difference different em; errors estimates exchange exhibits exist export factor far flux forced gradients greater grid gyres, having however, included indicate latitude low make makes maxima modelling observations. occurs oceanic open-ocean partially peak period present projected pt;} region regional representative representing responses review salinity sample scenario, schemes shifts shoaling simulated thermal thickness trends. uncertainty used variance wider wind-driven


{% extends "base.html" %} {% block head %} {{ super() }} {% block title %}Elasticsearch Indices Info{% endblock %} {% endblock %} {% block content_body %}
| # | Index | Health | Docs Count | Docs Deleted | Primaries | Primaries Store Size | Replication | Status | Store Size | UUID | Stats Info |
|---|


Warehouse Chief Natools:
Ah, you've returned with my agent's reports. Well done!
Please wait while I read these...
Wait.


Finish and submit a new product
{{product_info.description}}
Navigate for each tab and follow the steps:
Select product configuration and fill the params
Select a platform engine to deploy on
Fill platform parameters
Fill service configs
No services related with
{{platformFormGroup.value | json}}
{{deviceFormGroup.value | json}}


Here is heading1
Here is heading2
Here is heading3
Here is heading4
Here is heading5
Here is heading6
Here is text
with a line break
Here is
bold
text
Here is
italicized
text
first bullet
Open Google in current windo
Open Google in new window
first number


MENU
Home
Registration Login
About us
Terms of Agreement
Contacts
Kupichc
phone number:
38 (063) 881 18 70
my wallets:
fj3jfk3l45464543vfe
my email:
<EMAIL_ADDRESS>Editing
Coming soon


A Long-Term Outcomes Study to Assess STatin Residual Risk Reduction With EpaNova in HiGh Cardiovascular Risk PatienTs With Hypertriglyceridemia (STRENGTH)


uh oh ~ your browser doesn't support all of bitsy's features, so some things might not work right. maybe try another browser, such as:chrome,
firefox
The current font is missing some of the characters used in your dialog. Not all text in your game will display correctly. Consider picking a different font in the settings.
aboutabout
exits_endingsexits & endings
There are no exits or endings in this room yet! You can add one with this tool. :)
marker 1
room 0 (0,0)click in room
room:
x:
y:
marker 2
room 0 (0,0)click in room
room:
x:
y:
exit_one_wayexit options:
transition_effecttransition effect:
exit_one_way_reversereturn exit options:
transition_effecttransition effect:
paintpaint
searchfind
colorscolors
dialogdialog
Select a sprite or item to edit its dialog.
iteminventory
filedownload
download game as html file:
import game from html file:
Note: your browser doesn't support
direct downloads, so sharing requires
some extra steps:
- press share
- a new tab will open
- save that tab
- name it "mygame.html"
- share your game as a web page!


IBM BLUEMIX CLOUDANT
Upload File
Download File
File Name:
Version Number:
Delete File
File Name:
Version Number:
List Files


Nicholas Heiner Health Info
- Allergies: No known medical allergies. Seasonal pollen allergies.
- Habitual medications: none.
- Health Insurance: Through my employer, Netflix. I keep my health insurance card in my wallet.
- Primary care physician: OneMedical.
- Home: San Francisco, California, USA.
- Age: late 20s.
- Power of attorney: Documents are with my family, who you can contact via the phone numbers on the metal tag where you found the link to this page.


Reports any fields which are not used in the toString() method of a class. This can be useful to discover
fields that were added after the toString() method was created and for which the toString() method was not
correctly adjusted. It is possible to exclude fields from this check in the settings accessible via the Generate > toString() dialog.
This inspection will also check for problems with getter methods if 'enable getters in code generation' is enabled
in settings.


The status
field within the Time Zone response object contains
the status of the request. The "status" field may contain the following
values:
OK
indicates that the request was successful.
INVALID_REQUEST
indicates that the request was malformed.
OVER_DAILY_LIMIT
indicates any of the following:
OVER_QUERY_LIMIT
indicates the requestor has exceeded quota.
REQUEST_DENIED
indicates that the API did not complete the
request. Confirm that the request was sent over HTTPS instead of HTTP.
UNKNOWN_ERROR
indicates an unknown error.
ZERO_RESULTS
indicates that no time zone data could be found
for the specified position or time. Confirm that the request is for a
location on land, and not over water.


{% extends 'libya_site/staff.html' %} {% load i18n %} {% block title %}{% trans "Delete All Copy Centres" %}{% endblock %} {% block content %}
{% blocktrans trimmed %} All {{ n_copy_centers }} copy centres in the database are shown below. Are you sure you want to delete them? {% endblocktrans %}
| {{ center.center_id }} | {{ center.name }} |
{% trans "There are currently no copy centres defined." %}
{% endif %}


- Drag new audio connections from small green dots to large green dots.
- Drag new control connections from small blue dots to large blue dots.
- Hover over connections to highlight them, click to delete.
- You can also drag connections from large dots onto other large dots.
- Use the QWERTY keys to play a major scale!
Save me this madness


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
CWP No.7883 of 2016 (O&M) & all other connected cases -1- IN THE HIGH COURT OF PUNJAB AND HARYANA AT CHANDIGARH CWP No.7883 of 2016 (O&M) & all other connected cases Date of decision : 22.02.2017 Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another ...Petitioners Versus Pargat Singh and another ...Respondents CORAM: HON'BLE MR. JUSTICE AMIT RAWAL. Present: Ms. Promila Nain, Advocate for the petitioners. Mr. Ashok Kumar Sama, Advocate for the respondent No.1. Mr. Rahul Sharma, Advocate for respondent No.3. Ms. Himani Kapila, Advocate for Balaji City Developer Pvt. Ltd. **** AMIT RAWAL, J. (Oral)
This order of mine shall dispose of 32 writ petitions bearing CWP-7883-2016 titled as "Chief Engineer, Punjab State Power Corporation Ltd. and another V/S Pargat Singh and another", CWP-8133-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Sanjiv Kumar and another", CWP-8145-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Kulbir Singh and another" CWP-8146-2016 titled as "Chief Engineer, 1 of 9 ::: Downloaded on - 11-07-2017 20:33:52 ::: CWP No.7883 of 2016 (O&M) & all other connected cases -2-
Border Range, Punjab State Power Corporation Ltd. and another V/S Visheshwar Sil @ Vishweshar Singh and another" CWP-8175-2016 titled as "Chief Engineer, Punjab State Power Corporation Ltd. and another V/S Ratwant Kaur and another", CWP-8176-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Simerjit Kaur and another", CWP-8191-2016 titled as "Chief Engineer, Punjab State Power Corporation Ltd. and another V/S Gurinder Kaur and another", CWP-8310-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Gurmukh Singh and another", CWP-8323-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/s Palwinderjit Kaur and another", CWP-8330-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Gurmit Singh and another", CWP-8368-2016 titled as "Punjab State Power Corporation Ltd. V/s Paramjit Kaur and anr.", CWP-8431-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Paramjit Kaur and another", CWP-8433-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/s Kanwaljit Singh and another", CWP-8434-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/s Sukhwinder Kaur and anr.", CWP-8453-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Inderpal Singh and another", CWP-8454-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Paramjit Kaur and another", CWP-
2 of 9 ::: Downloaded on - 11-07-2017 20:33:53 ::: CWP No.7883 of 2016 (O&M) & all other connected cases -3-
8468-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Harjit Singh and another", CWP-8471- 2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Randeep Kaur and anr.", CWP-8489- 2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Parveen Kumar and another", CWP-8707- 2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Karamjit Kaur and another", CWP-8713- 2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Kiran Bala and another" CWP-8721-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Amit Chopra and another", CWP-8812-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Rupinder Kaur and another", CWP-8813-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Ashu and another", CWP-8835-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Gurmukh Singh and another", CWP-9368-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Baljit Kaur and another", CWP-9424-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Sukhpal Singh and another", CWP-8533-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Bharat Bhushan and others", CWP-7468-2016 titled as "Chief Engineer, Border Range, Punjab State 3 of 9 ::: Downloaded on - 11-07-2017 20:33:53 ::: CWP No.7883 of 2016 (O&M) & all other connected cases -4-
Power Corporation Ltd. and another V/s Kulwant Kaur and others", CWP- 7674-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/s Nishan Singh and another", CWP-7731- 2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/S Surjit Singh and another" and CWP- 8918-2016 titled as "Chief Engineer, Border Range, Punjab State Power Corporation Ltd. and another V/s Amrik Singh and another", filed by Punjab State Power Corporation Ltd. against the order of Permanent Lok Adalat, whereby complaint of the residents of Kanwar Avenue Amritsar who on purchase have become owner of the property bearing different plot numbers in Kanwar Avenue Amritsar situated in Colony duly approved by the Municipal Corporation Authorities under TP Scheme No.83 Notification dated 12.04.2001, has been allowed.
Grievance of the complainant before the Lok Adalat was that they had applied for release of temporary electric connection which was duly released by Punjab State Power Corporation Ltd. bearing different account numbers. One of the account number is Temp/8913 and consumption charges have already been paid without committing any default. Thereafter an application for installation of the permanent electric connection along with Form-AA and copy of sale deed and other documents required was submitted but the same was not released on the premise that colonizer of the colony had not got approved the layout of the LD system from Chief Electrical Inspector. The case of the complainant was that LD system and transfer had already been installed by the colonizer in the 4 of 9 ::: Downloaded on - 11-07-2017 20:33:53 ::: CWP No.7883 of 2016 (O&M) & all other connected cases -5-
Kanwar Avenue Colony and the many residents of the colony have been released the connection. This fact in written reply before Lok Adalat was not denied. However, during the pendency of the writ petition, Ms. Promila Nain, has drawn the attention of this Court to Annexure P-9 attached with replication in CWP No.8533 of 2016, regarding issuance of notice of the disconnection of the electricity to other residents owing to the observations rendered by the Lok Adalat. She further submits that Punjab Pollution Control Board, Amritsar vide notice dated 24.03.2015 had issued a direction to the Chief Engineer (Border Range), Punjab State Power Corporation Ltd., Amritsar under Section 33-A of the Water (Prevention and Control of Pollution) Act, 1974 on the premise that it had been decided to close the project due to the violation done by the builders. It is in this aspect of the matter, permanent connection cannot be granted. Reference has also been made to Annexure P-7 i.e. letter dated 07.09.2015 written by an office of Engineer in Chief/Commercial, PSPCL, Patiala to Sub Divisional Officer, Commercial, Mall Mandi, Amritsar on the subject of NOC by PSPCL to Shree Balaji City Developers Private Limited of Kanwar Avenue residential colony on the premise that there was deficiency with regard to the certain documents. All these factors have not been taken into consideration by the Permanent Lok Adalat.
She further submits that during the pendency of the writ petition, builder has already complied with certain requirements as noticed in Annexure P-7 and regard other contemplating to do so very soon and resultantly permanent connection would be released. On completion of the 5 of 9 ::: Downloaded on - 11-07-2017 20:33:53 ::: CWP No.7883 of 2016 (O&M) & all other connected cases -6-
formalities plus deposit of certain amounts, it would be released, in essence, order of Lok Adalat in its letter and spirit would be complied with.
Learned counsel appearing on behalf of respondents submits that Electricity Board had woken up by issuing notices to certain residents of the colony only on account of the observations rendered by the Lok Adalat. Even if the requirement was not done by the Builder, a person cannot be deprived of essential services i.e. electricity as consumption charges have been paid by the consumer and not by the builder. LD System had already been installed and there is no default in that and has drawn the attention of this Court to para Nos.3, 4 and 5 of the reply filed by builder, which reads as under:-
"3. That it is worthwhile to mention here that Shri Balaji City Developer Private Limited has taken the approval of all the objections raised by PSPCL vide memo No.2361/I- 14853 dated 07.09.2015 Annexure P-7 as in the main petition. The following objections has been approved, which is as follows:-
a. Certified copy of resolution authorizing the signatory of sign on behalf of company. On 4th July, 2016-Approved. (Annexure R-1).
b. Copy of approved layout plan by competent authority. On 13th Sept. 2015-Approved (Annexure R-1). c. Copy of License/permission/approval granted by competent authority to develop colony. On 04.07.2016- Approved (Annexure R-1).
D. Detailed load sheet. On 06.08.2016-approved (Annexure R-2).
The above said objection mentioned in Annexure P-7 has been removed an approval has been given in this 6 of 9 ::: Downloaded on - 11-07-2017 20:33:53 ::: CWP No.7883 of 2016 (O&M) & all other connected cases -7-
regard. For the perusal of this Hon'ble Court the copy of the said approvals is attached with this reply as Annexure R-1 and R-2.
4. That it is also pertinent to mention here that regarding the installation of LD system I has also been approved on 06th Aug 2016 estimated cost for laying of LD system inside the colony in case of works of electrification has to be done by PSPCL. Moreover, for Nodal Officer recommends grant of NOC has also been applied, which is pending.
5. That as per the instruction of Punjab Pollution Control Board, we have already collected all the documents and ready to apply for the approval of STP system which has to be approved by the respondent No.3. Its upon them as and when it has to be approved."
and thus, urges this court for dismissal of the present writ petitions.
I have heard learned counsel for the parties and appraised the paper book.
The affidavit filed on behalf of builder attaching the approved layout (Annexure R-1) and licence and permission/detailed load sheet (Annexure R-2) has not been rebutted by any of the resolution. Even specific averments of approval of LD system on 06.08.2016 which is almost year after the letter (Annexure P-7) has also not been denied perhaps on the premise that builder has already submitted the requisite documents and contemplating to the deposit of the dues, if any, of the Electricity Board.
It is strange that the PSPCL had been adopting pick and chose policy for allotting the connection to the various residents of the colony and 7 of 9 ::: Downloaded on - 11-07-2017 20:33:53 ::: CWP No.7883 of 2016 (O&M) & all other connected cases -8-
having brought to the notice of Lok Adalat and accepted by the official of PSPCL, the Electricity Board has woken up and taken the action in this regard. Such type of action on behalf of PSPCL is highly deprecable and not appreciated. There is no denial to the issuance of the temporary connection and consumption charges. Replication has been filed only to deny the written statement filed on behalf of the applicant but not to that of the builder. Non-compliance of the requirement/terms and conditions of the Punjab Water Pollution Control Board cannot be an impediment for the residents for not using the benefit of the essential service i.e. electricity. It appears that PSPCL has been adopting pick and choose policy in denying the issuance of connection to certain applicants who were constrained to knock the door of Lok Adalat vis-a-vis others an action now have been initiated in order to come on a platform of parity. Be that as it may, once Ms. Promila Nain, Advocate on instruction from Bal Krishan, Addl. SCO suffered statement that the builder has already submitted requisite documents and is contemplating to deposit the dues, though no objection had been taken in the written statement before the Lok Adalat regarding pendency of the dues except non-confirming to the sketch plan of LD system, yet had an audacity to raise objection of no dues.
It is strange that the plea of no dues even had not been taken up in the written statement but it has come for the first time from the mouth of Addl. SCO who is present in the Court. The officers at the helm of the affairs are required to be coherent and consistent in their stand but not to adopt a inconsistent stand. Precisely, this was noticed by the Lok Adalat 8 of 9 ::: Downloaded on - 11-07-2017 20:33:53 ::: CWP No.7883 of 2016 (O&M) & all other connected cases -9-
while allowing petition by deplorable the Act of Local Authorities of PSPCL by adopting a pick and choose policy.
I am of the view that order of Lok Adalat is perfectly legal and justified and does not call for interference.
No ground for interference is made out.
Resultantly, writ petitions are dismissed.
This Court also deem it appropriate to issue direction to respondent No.4 to comply with the requirement of PSPCL as early as possible preferably within a period of one month failing which this Court shall not constrained to take action of not complying with the doctrine of legitimate expectation i.e. the promise given to the residents of area while allotting the plots.
It has also been brought to the notice of this Court that against the notices issued of dis-connection, there is interim injunction granted by the Civil Court in favour of the applicants who have been enjoying the facility of the permanent connection.
22.02.2017 (AMIT RAWAL)
pawan JUDGE
Whether speaking/reasoned:- Yes/No
Whether reportable:- Yes/No
9 of 9
::: Downloaded on - 11-07-2017 20:33:53 :::


Classes
The following classes are available globally.
-
This is the main entry point for interacting with Ziti, and provides a Swift-friendly way to access the Ziti C SDK
Configure
Ziti
with aZitiIdentity
. AZitiIdentity
can be created by enrolling with using a one-time JWT. SeeZiti.enroll(_:_:)
. TheZitiIdentity
can also be configured as part ofZiti.init(fromFile:)
and otherZiti
initializers.Ziti
uses a loop to process events, similar toFoudation
‘sRunloop
(though implemented usinglibuv
). StartZiti
processing via theZiti.run(_:)
method, which enters an infinate loop processingZiti
events untilZiti.shutdown()
is called. TtheZiti.perform(_:)
method supports scheduling work to be run on this thread and can be called safely from other threads.See moreSee
See also:ZitiIdentity
required to configure Ziti accessZiti.enroll(_:_:)
create aZitiIdentity
by enrolling using a one-time JWTZiti.init(fromFile:)
create aZitiIdentity
by loading from a JSON file.ZitiConnection
for accessing or providing Ziti servicesZitiUrlProtocol
for registering aURLProtocol
for intercepting HTTP and HTTPS calls make using theURLSession
framework and routing them over aZiti
network.
Declaration
Swift
@objc public class Ziti : NSObject, ZitiUnretained
-
Class that encapsulate the claims of a Ziti one-time JWT file.
Claims are verified as part of the enrollment process.
See moreSee
See also:Ziti.enroll(_:,_:)
Declaration
Swift
public class ZitiClaims : NSObject, Codable
-
Class that enroll an identity with Ziti controller using a one-time JWT file
See moreDeclaration
Swift
@objc public class ZitiEnroller : NSObject, ZitiUnretained
-
Class used for passing information about error conditions encountered while using Ziti
Declaration
Swift
public class ZitiError : NSError
-
Class encapsulating Swft representations of Ziti SDK C events
See moreDeclaration
Swift
@objc public class ZitiEvent : NSObject
-
Class representation of host.v1 service configuration
See moreDeclaration
Swift
public class ZitiHostConfigV1 : Codable, ZitiConfig
-
Identity information for interacting with Ziti
Objects of these types are
Codable
so can easiliy be converted to/from JSON and stored on disk. AZitiIdentity
is created as part ofZiti.enroll(_:_:)
, and can be used to initialiaze on instance ofZiti
.See moreSee
See Also:Declaration
Swift
@objc open class ZitiIdentity : NSObject, Codable
-
Class representation of intercept.v1 service configuration
See moreDeclaration
Swift
public class ZitiInterceptConfigV1 : Codable, ZitiConfig
-
This class manages access to the Keychain, creating and storing keys and certificates needed to access a Ziti network.
This is primarily an internally used class, though certain methods are marked public in order to support senarios where the enrollment is provided by an application other than the one that needs to access Ziti using this identity (which will require the end user to provide their credentials to configure the keychain to allow the application access to the keys and certificates).
See moreDeclaration
Swift
public class ZitiKeychain : NSObject
-
Logger class that mirrors the Ziti C SDK’s logging feature
See moreDeclaration
Swift
public class ZitiLog
-
Class encapsulating Ziti SDK C’s MFA Auth Query
See moreDeclaration
Swift
@objc public class ZitiMfaAuthQuery : NSObject, Codable
-
Class encapsulating Ziti SDK C’s response to an MFA enrollment request
See moreDeclaration
Swift
@objc public class ZitiMfaEnrollment : NSObject, Codable
-
Used for passing context among callbacks and mapping to
Ziti
C SDK functionDeclaration
Swift
@objc public class ZitiPostureContext : NSObject
-
Class encapsulating Ziti SDK C’s posture query
See moreDeclaration
Swift
@objc public class ZitiPostureQuery : NSObject, Codable
-
Class encapsulating Ziti SDK C’s posture query set
See moreDeclaration
Swift
@objc public class ZitiPostureQuerySet : NSObject, Codable
-
Class encapsulating a Ziti SDK C service
See moreDeclaration
Swift
@objc public class ZitiService : NSObject, Codable
-
Class providing a Swift wrapper for Ziti Tunnel SDK C
See moreDeclaration
Swift
public class ZitiTunnel : NSObject, ZitiUnretained
-
Class representation of ziti-tunneler-client.v1 service configuration
See moreDeclaration
Swift
public class ZitiTunnelClientConfigV1 : Codable, ZitiConfig
-
Class to encapsulate a Ziti Tunneler SDK event
See moreDeclaration
Swift
@objc public class ZitiTunnelEvent : NSObject
-
Class encapsulating Ziti Tunnel SDK C Context Event
See moreDeclaration
Swift
@objc public class ZitiTunnelContextEvent : ZitiTunnelEvent
-
Class encapsulating Ziti Tunnel SDK C MFA Event
See moreDeclaration
Swift
@objc public class ZitiTunnelMfaEvent : ZitiTunnelEvent
-
Class encapsulating Ziti Tunnel SDK C Service Event
See moreDeclaration
Swift
@objc public class ZitiTunnelServiceEvent : ZitiTunnelEvent
-
Class encapsulating Ziti Tunnel SDK C API Event
See moreDeclaration
Swift
@objc public class ZitiTunnelApiEvent : ZitiTunnelEvent
-
Class representation of ziti-tunneler-server.v1 service configuration
See moreDeclaration
Swift
public class ZitiTunnelServerConfigV1 : Codable, ZitiConfig
-
Class representation of ziti-url-client.v1 service configuration
See moreDeclaration
Swift
public class ZitiUrlClientConfigV1 : Codable, ZitiConfig
-
URLProtocol
that interceptsHTTP
andHTTPS
URL requests and routes them over the Ziti overlay as configured in your Ziti controller.
See moreZitiUrlProtocol
should be instantiated as part of theInitCallback
ofZiti.run(_:_:)
to ensure Ziti is initialized before starting to intercept services.Declaration
Swift
@objc public class ZitiUrlProtocol : URLProtocol, ZitiUnretained


Before Change
if trial.state != optuna.structs.TrialState.COMPLETE:
continue
if search_space is None:
search_space = trial.distributions
continue
delete_list = []
for param_name, param_distribution in search_space.items():
if param_name not in trial.distributions:
delete_list.append(param_name)
elif trial.distributions[param_name] != param_distribution:
delete_list.append(param_name)
for param_name in delete_list:
del search_space[param_name]
return search_space or {}
After Change
"`product_search_space` function is deprecated. "
"Please use `intersection_search_space` function instead.", DeprecationWarning)
logger = logging.get_logger(__name__)
logger.warning("`product_search_space` function is deprecated. "
"Please use `intersection_search_space` function instead.")
return intersection_search_space(study)


Duration = {{task.duration}} | Repitition = {{task.repitition}}
Last Completed - Today
Duration = {{task.duration}} | Repitition = {{task.repitition}}
{% if task.last_completed == 'NONE' %}Last Completed - Never
{% else %}Last Completed - {{task.last_completed}}
{% endif %}