rt | Request Tracker , an enterprise-grade issue tracking system

You are running the project via Java 1.8 and add the --add-opens option to the runner. However Java 1.8 does not support it.

So, the first option is to use Java 11 to run the project, as Java 11 can recognize this VM option.

Another solution is to find a place where --add-opens is added and remove it. Check Run configuration in IntelliJ IDEA (VM options field) and Maven/Gradle configuration files for argLine (Maven) and jvmArgs (Gradle)

GeneratePdf does not match the default name pattern for test classes. The default pattern is Test*|*Test|*Tests.

You can change it in your Gradle file with

There's a few misunderstandings in this attempt.

1. There is one instance of a meta-class per type. Thus if we want to allow a given type to only be instantiated once, the correct scoping is an attribute in the meta-class, not a my. A my would mean there's one global object no matter which type we create.
2. The compose method, when subclassing ClassHOW, should always call back up to the base compose method (which can be done using callsame). Otherwise, the class will not be composed.
3. The method_table method returns the table of methods for this exact type. However, most classes won't have a new method. Rather, they will inherit the default one. If we wrap that, however, we'd be having a very global effect.

While new is relatively common to override to change the interface to construction, the bless method - which new calls after doing any mapping work - is not something we'd expect language users to be overriding. So one way we could proceed is to just try installing a bless method that does the required logic. (We could also work with new, but really we'd need to check if there was one in this class, wrap it if so, and add a copy of the default one that we then wrap if not, which is a bit more effort.)

Here's a solution that works:

Install llvm with debug mode enabled:

Ad.1. You can go either way - store the current RT in the DB and check if it's there, or store all the used RTs and check that the current RT is not there. Either will work. With the latter option you get that additional benefit of being able to revoke all RTs if you see someone trying to reuse an RT. On the other hand, as you pointed out, it may mean that the database will get substantially large. That's the kind of decisions you have to make when designing your system: I want to provide better RT security but I will need to spend more money on a larger DB.

Of course you don't have to keep all the tokens indefinitely. There is no added value in checking that someone reused a token from two years ago.

Ad. 2. Different systems can have different ways of deciding what is a "refresh token family", but I would say these are tokens issued for the given user and client. Maybe in some cases you could limit that to a given audience. In some Identity Server you will have some sort of consent object saved and tokens related to this consent object. This can also be a good candidate for identifying all the tokens you need to revoke.

Ad. 3. Access and refresh tokens are not meant to be used as a mechanism for session. The token just expires, there is no concept of a user logging out. If you really want this sort of feature you will have to keep information about tokens in the database together with an information whether the user has actively logged out. If so, then you can decline those tokens. It is a bit of a workaround, though, and usually using sessions will just be more straightforward in this case.

First of all, handler is not callable, it's a member struct of Client_v2. You need to access it through the dot operator: self.handler.handle().

On to the actual question:

Runtime::spawn requires the provided future to be 'static + Send, i.e., it can't borrow data and it must be possible to move it to another thread.

The 'static requirement is due to the parent thread possibly exiting before the thread executing the future, thus any data given to the task must be ensured to live at least as long as the task itself.

It must be Sendable because the tokio runtime is free to move spawned Futures between the threads of its threadpool.

The relevant requirement for your error is the first one, the future produced by Handler::handle is not 'static because the function borrows self as a shared reference: async fn handle(&self). Calling this function produces a Future + 'a where 'a is the lifetime of &'a self, i.e. you could write the whole signature as fn handle<'a>(&'a self) -> impl Future + 'a + Send but Runtime::spawn needs you to return impl Future + 'static + Send.

To prove that you're not borrowing data from &self in handle, you can use an async {} block and explicitly state the return type as impl Future + Send + 'static:

I installed pyttsx3 using the two commands in the terminal on the Raspberry Pi:

1. sudo apt update && sudo apt install espeak ffmpeg libespeak1
2. pip install pyttsx3

I followed the video youtube.com/watch?v=AWhDDl-7Iis&ab_channel=AiPhile to install pyttsx3. My functional code should also be listed above. My question should be resolved but hopefully useful to anyone looking to write a similar program. I have made minor tweaks to my code.

The used (spring standard) "factory" implements FactoryBean as InitializingBean ...

The version of @PactTestFor method still needs to use version 3.