Calla | Virtual Meetups through Jitsi | Video Utils library

Broadly, actors run on an dispatcher which selects a thread from a pool and runs that actor's Receive for some number of messages from the mailbox. There is no guarantee in general that an actor will run on a given thread (ignoring vacuous examples like a pool with a single thread, or a dispatcher which always runs a given actor in a specific thread).

That dispatcher is also a Scala ExecutionContext which allows arbitrary tasks to be scheduled for execution on its thread pool; such tasks include Future callbacks.

So in your actor, what happens when a messageA is received?

• The actor calls createApi() and saves it
• It calls the callA method on api
• It closes api
• It arranges to forward the result of callA when it's available to the sender
• It is now ready to process another message and may or may not actually process another message

What this actually means depends on what callA does. If callA schedules a task on the execution context, it will return the future as soon as the task is scheduled and the callbacks have been arranged; there is no guarantee that the task or callbacks have been executed when the future is returned. As soon as the future is returned, your actor closes api (so this might happen at any point in the task's or callbacks' execution).

In short, depending on how api is implemented (and you might not have control over how it's implemented) and on the implementation details, the following ordering is possible

• Thread1 (processing messageA) sets up tasks in the dispatcher
• Thread1 closes api and arranges for the result to be piped
• Thread2 starts executing task
• Thread1 moves on to processing some other message
• Thread2's task fails because api has been closed

In short, when mixing Futures and actors, the "single-threaded illusion" in Akka can be broken: it becomes possible for arbitrarily many threads to manipulate the actor's state.

In this example, because the only shared state between Futureland and actorland is local to the processing of a single message, it's not that bad: the general rule in force here is:

• As soon as you hand mutable (e.g. closeable) state from an actor to a future (this includes, unless you can be absolutely sure what's happening, calling a method on that stateful object which returns a future), it's best for the actor to forget about the existence of that object

How then to close api?

Well, assuming that callA isn't doing anything funky with api (like saving the instance in some pool of instances), after messageA is done processing and the future is completed, nothing has access to api. So the simplest, and likely most correct, thing to do is arrange for api to be closed after the future has completed, along these lines

Usually, the implementation of AuthenticationManager is a ProviderManager, which will loop through all the configured AuthenticationProviders and try to authenticate using the credentials provided.

One of the AuthenticationProviders, is DaoAuthenticationProvider, which supports a UsernamePasswordAuthenticationToken and uses the UserDetailsService (you have a customUserDetailsService) to retrieve the user and compare the password using the configured PasswordEncoder.

There is a more detailed explanation in the reference docs about the Authentication Architecture.

I solved my problem by changing every date object to datetime.date.

• Explanation

I believe you are using wso2am-3.1.0 vanilla pack along with a custom sequence file which probably has a mediator using "json-eval($.)" expression. Please confirm. This is a known issue in the wso2am-3.0.0 and wso2am-3.1.0 vanilla packs.

This is becasue when we use json-eval($.) expression in a sequence in the /repository/deployment/server/synapse-configs/default/sequences directory and when it gets deployed, the synapse is setting the GsonJsonProvider [1] to represent the JSON inside the Jayway JsonPath[2].

Since the GsonJsonProvider is getting loaded, even if we remove the particular sequence file which has the json-eval($.) expression in a property mediator, the issue will still persists until we restart the server.

But, if we do not use the json-eval($.) expression at all in a sequence in the /repository/deployment/server/synapse-configs/default/sequences directory, we will not get the above error when we enable the JSON schema validation as the jsonsmartjsonprovider [3] is used to represent the JSON inside the Jayway JsonPath.

Since the JSON object representation is getting different in the error scenario, it throws the IllegalArgumentException in that case.

• Solution

You can approach one of the following solution as suggested below.

1. This issue has been fixed in the latest WUM/updated pack. If you have the WSO2 subscription then you can get the latest update.
2. You can deploy a new wso2am-3.1.0 vanilla pack and invoke the API calls without the sequence having json-eval($.) expression.

[1] https://www.javadoc.io/doc/com.jayway.jsonpath/json-path/latest/com/jayway/jsonpath/spi/json/GsonJsonProvider.html

[2] https://github.com/wso2/wso2-synapse/blob/417ce10dec58579b758e12f41909f17c09d25a64/modules/core/src/main/java/org/apache/synapse/mediators/eip/EIPUtils.java#L348

[3] https://www.javadoc.io/doc/com.jayway.jsonpath/json-path/latest/com/jayway/jsonpath/spi/json/JsonSmartJsonProvider.html

In your reducer, update code for FILTER_BY_VALUE action like below:-

First you are importing App from ./App. You need to import from ./AppWrapper. Second, you don't pass initialState in the reducer so the state doesn't have the initial value so this error occurs. You just need add initialState in reducer like this:

For handling (06032021_toibhoc_mp_01_1_col_r1.pdf, 06032021_toibhoc_PP_01_1_col_r1.pdf, 06032021_toiind_mp_01_1_col_r1.pdf)

First, you can read the Config file

When you click the confirm button first time, confirm() will be invoked and as a result context.callback() and context.resolve() will be invoked. When context.resolve() gets invoked it resolves the promise i.e. changes its internal state from pending to resolved.
Now, on subsequent clicks of the confirm button same thing happens but since the promise is already resolved (by first click) even though context.resolve() gets invoked nothing happens.
As for then(), it accepts a callback function as an argument. This callback function is called asynchronously when the promise resolves or rejects(first time only). You can go through https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then for a detailed explanation of how then() works.

You can use setTimeout function