Hi Rahul,
Typesafe Console has been end-of-lifed quite some time ago.
Instead you should look into Takipi or Kamon.io while we're working to provide
something new and exciting in partnership with 3rd parties :-)
EOL annoucement:
Typesafe announces the End-Of-Life cycle for commercial support
Awesome, thanks for sharing and your continued enthusiasm the project! :-)
On Thu, Jul 9, 2015 at 6:04 PM, Anton Kulaga antonkul...@gmail.com wrote:
Hi all,
I updated my akka-http-extensions (
https://github.com/denigma/akka-http-extensions ) to 0.5-RC4 So, now it
also contains allow
Hi Sam,
thanks for pointing out that frustration point - we'll include this commit
adding more info about how it works
https://github.com/spray/akka/commit/b8cc008fa2288612e0d2059b3741afd8a63aa5df
in the docs (please note it's still WIP, not all docs are there yet).
On Sun, Jul 12, 2015 at 6:49
Hi Sam,
Yes, interesting catch - we do not publish scaladocs as a jar.
I guess we did not bump into this previously since many Scala devs (including
us) use IDEs which understand Java = understand JavaDoc (or they use source
jars, I think IntelliJ does).
I don't know the initial reasoning about
Merged, thanks a lot! Keep on hakking :-)
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 2 July 2015 at 07:10:54, Stephen McDonald (stephen...@gmail.com) wrote:
Hi all,
I just wanted to share a project I've been working on over the last 6 months.
I've called it CurioDB [1], it's a
That's pretty awesome! Thanks for sharing :-)
If you would like to we're happy to promote it on the community page:
http://akka.io/community/#projects-using-akka
Just submit a PR with your project details to
https://github.com/akka/akka.github.com/pulls and we'll happily merge it :)
--
Cheers,
, so it may be a viable option for medium sized apps.
Hope this helps!
On Thu, Jul 2, 2015 at 12:18 PM, Konrad Malawski kt...@typesafe.com wrote:
Hi Filippo,
In order to run servlets you'd have to implement a proper servlet
container. Akka Http does not aim to implement servlet spec.
The reason
Hi Mark,
which site are you referring to specifically?
As you can see on http://akka.io/docs/ we're linking to RC4.
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 29 June 2015 at 12:37:53, Mark van Buskirk (markvanbusk...@gmail.com) wrote:
I see the site is now giving the RC3
Glad that it worked out for you :-)
Thanks for sharing the conclusion!
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 29 June 2015 at 00:25:13, Harit Himanshu (harit.subscripti...@gmail.com)
wrote:
I used maven-shade plugin and then it worked
On Wed, Jun 24, 2015 at 5:06 AM, Patrik
Dear hakkers,
we—the Akka committers—proudly present the second development milestone for
Akka 2.4. Since the release of Akka 2.4-M1 (one month ago) much has
happened, in particular around Akka Persistence and Akka Cluster tools.
Besides a plethora of small improvements the main changes relative
If I remember it correctly the Aggregator pattern has done it's job once
it has aggregated the values,
thus it stops itself. You could use these in the actor-per-request model,
but it's of course possible to have more aggregators inside as well.
On Wed, Jun 24, 2015 at 2:21 PM, Matheus Lima
We have ideas that might help to improve from the current recovery style,
but nothing directly planned.
It's related to this ticket: https://github.com/akka/akka/issues/17837 but
still quite researchy.
Currently you'll need to clean the persistent data before restarting
sharding.
On Thu, Jun 25,
appropriate given we are talking split
brain, though ^_^ ). How should I fix it?
Anyways: thanks for the reply. As I mentioned there, is there any risk
of race condition in performing this operation?
Thanks,
D.
On Tuesday, 23 June 2015 14:52:22 UTC+1, Konrad Malawski wrote:
Hi Diego,
I
Http has not been performance tuned yet, but we plan to do so after 1.0
(which is around 2 weeks away or so).
I'd suggest starting out with Spray currently, and then doing the move to
Akka Http should not be painful at all, since the routing DSLs are very
similar and most of the directives are
Hi Chris,
I think the feature you're after is described in the ticket:
https://github.com/akka/akka/issues/17732
https://github.com/akka/akka/issues/17346
Also see here for an in depth response about this issue:
https://github.com/akka/akka/issues/17816
On Thu, Jun 4, 2015 at 2:47 PM, Chris
Have you looked into the examples inside the Spec Martynas linked to?
It's as easy as using the FutureDirectives as seen here:
https://github.com/akka/akka/blob/4b603ad018b1b909bb331b26ab7ec5464d86cd50/akka-http-tests/src/test/scala/akka/http/server/directives/FutureDirectivesSpec.scala#L26
On
Hi Harit,
No, the multi-jvm plugin is developed mostly for our own needs, that is: for
testing Akka itself across many nodes.
We see other teams successfully using it as well, but no-one has really adapted
it to be usable from maven.
Myself having maintained (and still maintaining) a rather
Oh, my mistake then, sorry :-)
I missed the fact that you're using a GZIPInputStream and not just the file,
all good then - InputStreamSource should be good for that use case :-)
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 23 June 2015 at 17:30:16, BigAl (albert.pastr...@intenthq.com)
In general a variation of the work pulling pattern helps to pull only as
much data as you need to the other node:
See here: http://doc.akka.io/docs/akka/snapshot/scala/howto.html
On Mon, Jun 22, 2015 at 7:23 AM, Vishnu Sharavan Nag
vishnushara...@gmail.com wrote:
Patrik,
Any suggestions
SynchronousFileSource will be even better than InputStreamSource :-)
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 23 June 2015 at 15:31:24, BigAl (albert.pastr...@intenthq.com) wrote:
Thanks a lot!
Will use the InputStreamSource for sure, looking forward for the RC4 :-)
On Tuesday,
Hi there,
nice blog and example app!
Please use SynchronousFileSource instead of using getLines from the scala
io.Source - it will be much faster (much):
Here's docs on how to use it:
http://doc.akka.io/docs/akka-stream-and-http-experimental/1.0-RC2/scala/stream-io.html#Streaming_File_IO
On
I'm not aware of any open source usages of it but would not be surprised if
someone did,
given where Akka is often used... However not sure if those teams would be
reachable via this mailing list,
banks tend to don't like to talk about what they are doing somehow.
On Mon, Jun 22, 2015 at 3:32 PM,
Hi Diego,
I believe you answered this question here as well and Patrik answered there:
https://groups.google.com/forum/#!topic/akka-user/j6wQfhJAQb4
In general you can delete the data and restart the cluster, it will create
new shard allocations.
We are thinking about ideas how to make this
Hi Leon,
You're correct - we provide default helpers ...Support classes/traits for
Java and Scala - for Java it's Jackson and for Scala it's using SprayJson.
This however means that if your routes are in a scala file, you can mix in
the scala Support trait. Scala and Java classes are pretty much
Hej Krzysiek,
Wouldn't it be more interesting for your case to have small self-confined
apps which you can qualify as long chain of actor message passing or a
lot messages per second?
Those should be easy to construct manually and then you'd see how you
impacted performance in those cases.
Have
Hi Bill,
I don't see a reason why such implementation wouldn't make sense - in fact
many of the other NoSQL stores nowadays are very dynamo inspired :-)
So I'd say it's just a matter of actually sitting down and implementing it.
PS: We're in the middle of the final adjustment phase in Akka
It's been discussed a bit (most recently during ScalaDays),
with Play being the primary interested-party however we have not actively
looked into it yet.
It would definitely match our streaming http model very-very-nicely!
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 18 June 2015 at
Awesome email, thanks the kudos and for spending the time to write it up, Guido!
Allow me to swiftly chime in on one of the touched upon topics :-)
I find in particular Maven app assembler an awesome plugin, it gives the
developer a way to provide execution scripts to admins, then admins can do
Awesome, thanks a lot Guido!
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 16 June 2015 at 10:55:03, Patrik Nordwall (patrik.nordw...@gmail.com) wrote:
Awesome, thanks for making Akka better!
/Patrik
On Tue, Jun 16, 2015 at 10:51 AM, Guido Medina oxyg...@gmail.com wrote:
I'll send you
Hi Maatary!
You may enjoy this talk I have on the need for async
https://vimeo.com/122085562 in which I talk about how async IO differs
from synchronous IO.
See from 17th minute for the part about IO.
On Thu, Jun 11, 2015 at 8:25 AM, Derek Williams de...@fyrie.net wrote:
It is asynchronous
That's quite possibly the only thing missing. Would you like to submit a
PullRequest and we'll look into it there?
On Sat, Jun 6, 2015 at 2:40 PM, James Carman jcar...@savoirtech.com wrote:
It looks to be as simple as adding:
OSGi.contrib
to the sbt file for contrib. Is that all there is
Just noticed the PR, thanks!
https://github.com/akka/akka/pull/17673
On Sat, Jun 6, 2015 at 3:36 PM, Konrad Malawski kt...@typesafe.com wrote:
That's quite possibly the only thing missing. Would you like to submit a
PullRequest and we'll look into it there?
On Sat, Jun 6, 2015 at 2:40 PM
All APIs in Akka 2.3.x support Java 6 / 7 - only the lambda things
require Java 8,
so it's easy to spot them (and you won't accidentally bump into them I'd
say).
Also remember that using Scala gives you the even more conciseness and
power as Java 8 APIs yet does not require Java 8 :-)
Note: Akka
Harit, please do not double post the same question to scala-user and akka-user
at the same time.
You'll get all your Akka questions answered on akka-user, no worries.
Since it's a community forum it may take some time but we never leave questions
unanswered.
Thanks in advance!
--
Cheers,
:
so as I understand
Scala 2.11.6 and
Akks 2.3.11
are good enough to use with Java 7? Right?
Thanks a lot
+ Harit Himanshu
On Monday, June 1, 2015 at 1:05:40 PM UTC-7, Konrad Malawski wrote:
All APIs in Akka 2.3.x support Java 6 / 7 - only the lambda things require
Java 8,
so it's easy to spot
Hi Anton,
sorry it took me so long to dig through to to this email.
I think this is simply a case of the second implementation of something
being better since you grasped the domain batter,
while implementing the first iteration :-) We do not recommend Actors as
solve it all, however the points
Hi Harit,
Allow me to respond in-line to sentences where I have something to say:
1. As deployed on client’s box it’s not trivial to know if its is up
and running. Supervisor hierarchy would help the project to recover from
errors if possible, or else inform us (in some way,
On Friday, 29 May 2015 17:27:48 UTC+1, Konrad Malawski wrote:
Hi Petr,
Firstly - do not use the io.Source + getLines trick to get lines from a
File, it's horribly slow :-)
Instead use the SynchronousFileSource*as shown in
stream-io.html#Streaming_File_IO
http://doc.akka.io/docs/akka-stream-and-http
Hi TS,
there's a number of ways you can achieve this,
one is: expectMsgAnyOf(...) and then another expectMsgAnyOff with one
message (the received one) less from the expected collection,
another one is fishForMessage() where you implement a partial function
which can fish for the message you want
?
Extract an interface (trait) and in tests provide a NoopImplementation
instance of it.
- Regarding Mocking, I would consider your advice and try to stay away
from it, I need to learn how to use your advice (I am new to this entire
ecosystem)
On Fri, May 29, 2015 at 9:38 AM, Konrad Malawski kt
I agree with Giovanni's hints here - your domain actors should talk using
your domain language (the messages).
Of course you can always just create an HttpRequest message (see http model
in the docs) if you want to send that,
however I'd recommend to test the http things more for the routing and
Removed this spam message.
Sorry hakkers, it slipped through the cracks.
We do not accept job offers completely unrelated to akka on this board.
On Thu, May 28, 2015 at 8:14 PM, rambabu dandugula
ram.codeforce3...@gmail.com wrote:
Hi,
We currently have an opportunity for a *Azure
a way to make them both implicit.
Maybe this is a more general scala question, like: how can I make all the
parameters of a lambda implicit, because { implicit x= ... } works while {
implicit (x,y) = ...} doesn't .
Cheers
G
On Friday, 29 May 2015 19:07:08 UTC+2, Konrad Malawski wrote:
Hi Giovanni
Akka Persistence is *experimental* in the 2.3.x release series,
however we have seen and worked with customers who have had it in production
for about a year now and have been really happy with it. So yes, it's
pretty stable and used in the wild world.
Having that said, we are currently working
Hi there,
I have never used that feature in logback, but in general there should be a
reset char sequence,
which resets the font style back to normal.
In general it's [0m however no idea how that relates to logback's pattern.
On Sat, May 23, 2015 at 2:38 AM, TS test.tester1...@gmail.com wrote:
When testing Actors one should rather test the behaviours (the messages
sent to and from an Actor) instead of mocking.
Please note that since mockito (great tool) holds values in thread locals
and may not work as you'd expect it to with multithreaded code. Unless that
has changed I'd recommend
Hi Richard!
No, not referring to the effort required to keep up with the Akka team :)
Which reminds me I promised myself to do some sports this week... ;-)
I just came across this:
https://github.com/scalapenos/stamina
and wondered if anyone had any thoughts about it.
Looks pretty cool
Hi Guido,
we're happy to take performance improvement contributions however they
should be backed with some JMH benchmark to prove the claimed perf benefits
:-)
You can easily run benchmarks by just adding one to our akka-bench-jmh
subproject.
Looking forward to the PR, then we can discuss
Hi Laxman,
I'd actually say that a 7KB message is not very small, sounds like a normal
sized message (you're probably using java serialization?).
I'd rather recommend using a better serializer, like protobuf, or kryo etc
in order to get the message size lower than worrying about tcp chunk sizes,
of chunks we write and read to the
kernel is
akka.io.tcp.direct-buffer-size which defaults to 128KiB.
You can also enable akka.io.trace-logging which will show you exactly how
large chunks are being written.
On Fri, May 29, 2015 at 6:04 PM, Konrad Malawski kt...@typesafe.com wrote:
Hi Laxman
Hi Petr,
Firstly - do not use the io.Source + getLines trick to get lines from a
File, it's horribly slow :-)
Instead use the SynchronousFileSource*as shown in
stream-io.html#Streaming_File_IO
http://doc.akka.io/docs/akka-stream-and-http-experimental/1.0-RC3/scala/stream-io.html#Streaming_File_IO
def run: Unit = LogReaderDisruptor.main(Array())
is a method that is supposed to run forever, plus it required some setup
(that is available on client's machine or test environment),
By that do you mean that the main() is never returning? If so, then you're
blocking the Actor and wasting an
Hi Giovanni,
Firstly, sorry we don't have docs on this yet, but they are coming soon! (
check this with a higher version number soon
http://doc.akka.io/docs/akka-stream-and-http-experimental/1.0-M2/scala/http/custom-directives.html
)
Both these directives are implemented in terms of the extract
Hi Chanan,
I am not aware of tools of the like of Swagger for plain actor messaging.
What we see people do and also encourage is to keep Actor messages in their
companion objects.
For example like so:
object RegistrationActor {
case class Register(…)
object Registration {
trait Failure
Hi David,
seems we worked out that one on gitter during the evening accidentally :-)
// Note for others, notice the */n* typo in the separator :-)
Happy hakking!
On Thu, May 21, 2015 at 11:48 PM, David Hooker dudeh...@gmail.com wrote:
Hi all-
Seems like it should be simple, so I'm just
The back pressure is propagated to the client thanks to TCPs built in
mechanisms for this - on the server side we simply do not read from the socket
until demand is available, which causes the back pressure to be propagated
properly.
Konrad,
So if we are *not* using a congestion control
Hello there,
Have a look at Cluster Sharding
http://doc.akka.io/docs/akka/2.3.11/contrib/cluster-sharding.html it's
exactly that :-)
It will become a stable module in 2.4 (which will get its first milestone
*very soon*).
On Mon, May 18, 2015 at 9:11 AM, Artyom Bolshakov tweek...@gmail.com
wrote:
Hi there Matteo,
You’ve arrived in the right place to ask Akka questions :-)
There are two talks I’m aware of which show a demo how the backpressure
mechanism really works when working with http.
1) One is Roland Kuhn’s talk on ScalaDays SF 2015:
Is this a child actor we’re talking about or a top level one?
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 7 May 2015 at 21:18:27, Moiz Raja (moizr...@gmail.com) wrote:
I have a need to wait for an actor to be terminated because I need to recreate
a new actor with the same name on
Looks good! Always useful to show how to use various styles of app :-)
If you’d like to contribute your PlayJsonSupport to Akka I think we’d like to
include it,
as we currently do for spray-json. Here’s the related ticket:
https://github.com/akka/akka/issues/15917
--
Cheers,
Konrad 'ktoso’
Hi Michael,
We have discussed such proposal in the past and decided that it does not carry
it’s own complexity weight.
We would have to special case some letters as markers, or introduce something
else to mark what the “placeholder part” is,
we also really do want to encourage developers to
Thanks for pointing this out - good catch!
Fixed: https://github.com/typesafehub/activator-akka-stream-scala/pull/25
// Note to self, doubleckeck if travis actually works as expected on these
repos.
On Sat, May 2, 2015 at 1:50 AM, Richard Rodseth rrods...@gmail.com wrote:
You're probably aware
Hi Simone!
All examples in the docs are compiled and tested before we release them, so let
ma assure you the code is valid.
The entire code is listed here if you’d like to have a look at the complete
file:
github is not working, it must be some problem with my
environment :(
_S
On Sat, May 2, 2015 at 7:04 PM, Konrad Malawski konrad.malaw...@typesafe.com
wrote:
Hi Simone!
All examples in the docs are compiled and tested before we release them, so let
ma assure you the code is valid.
The entire
, Konrad Malawski konrad.malaw...@typesafe.com
wrote:
Seems you forgot to extend RawDocument in Document, which manifested itself in
being unable to wire up flows of not-compatible types.
I forked and fixed the minor typos in your code:
https://gist.github.com/ktoso/8140969c4aead4103317
Happy
Thanks for reporting!
Yes, we did include some bugfixes in those areas in the .9 and .10 releases,
glad it helps!
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 30 April 2015 at 09:36:11, Kai Yu (niels.henric.a...@gmail.com) wrote:
It turned out, the issues I encountered are specific
Dear Hakkers,
we—the Akka committers—are happy to announce the second Release Candidate
for Akka Streams HTTP. This release updates Akka Streams to use the *1.0.0
final* version of the Reactive Streams interfaces in order to allow
inter-op with various other implementations. An announcement
On a personal style-preference note I’m with Jakub here.
While not specifically required for inference or things like that, it does
read/write itself nicer with 2 parameter lists.
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 28 April 2015 at 12:53:30, Jakub Liska
Hi Soumya,
Why do you have the concurrent hash map in the Actor at all?
When using Actors you can easily have a *var* with an *immutable.Map*
which you can update/read from the Actor's receive. If you need to use
Futures,
apply the *pipeTo* pattern to forward the action to self.
Of course, if you
Hi Oliver,
Have you read the section of our docs about cyclic graphs and deadlocks?
http://doc.akka.io/docs/akka-stream-and-http-experimental/1.0-M2/scala/stream-graphs.html#Graph_cycles__liveness_and_deadlocks
Because akka streams (all reactive streams implementations) are purely
demand driven,
Excellent answer Adam.
An interesting point to add here is that when using Scala there is no need
to call unhandled() explicitly, because Scala’s PartialFunction allows us
to inspect if the function is able to handle a message or not. If not (no case
x = matches the message), we call unhandled()
Hi Magnus,
the answer to this question is very journal dependent.
It's up to the Journal to pick how to serialize your messages.
If a journal picks to serialize in human-readable formats you'd get that.
For example in a database like mongo you could just pick a JSON serializer
to put it into the
Hi everyone,
we've discussed about serialization formats a few times on this list,
I think the discussion here: Best practices using Akka Persistence with
long-running projects?
Hi Anton,
The artifact names have changed a bit for the RC1 release, sorry we forgot to
mention this in the announcement!
Patrik followed up already in the announcement thread:
https://groups.google.com/d/msg/akka-user/bhZ3AwXkTSs/sf8uIa8j6AIJ
I fixed the docs site as well:
Thanks for pointing that one out!
I fixed the page: https://github.com/akka/akka.github.com/pull/196
Thanks again and happy hakking!
-- konrad
W dniu niedziela, 26 kwietnia 2015 14:13:32 UTC+2 użytkownik Anton Kulaga
napisał:
akka-http-testkit-experimental_2.11 changed to
Hi Harit,
the Java API is feature-complete (as all our Java APIs) - you can do anything
you might possibly need in plain Java.
The note speaks about the conciseness of the code - we find that tests written
in Scala are much more readable because of
how we can utilise the language to provide a
Thanks for reporting!
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 6 April 2015 at 12:53:30, folex (0xd...@gmail.com) wrote:
https://github.com/akka/akka/issues/17140
On Friday, April 3, 2015 at 6:11:02 PM UTC+3, Akka Team wrote:
Hi folex,
thanks for reporting.
Around that time this
Hi there,
if you mean the new akka-typed module then: no. It's currently an preview
which has not been released yet (it will be in 2.4),
this it does not yet have integration with peristence.
If you mean the old static interface typed actors then the answer is also
no.
These are only meant as an
Hi Leszek,
Are you sure you have the sphinx-build command available? It’s not complaining
about the directory, it is complaining about the lack of sphinx.
Have you installed Sphinx?
Here’s how: http://doc.akka.io/docs/akka/snapshot/dev/documentation.html
--
Cheers,
Konrad 'ktoso’ Malawski
We won't be splitting the release *cycle* (because it wins us being able to
use source dependencies between http and stream modules, which allows us to
move faster),
however: the next release will already mark akka-streams RC1
Hi there,
we talked about this briefly in the team yesterday, the outcome is that we
do not want to expose such low level abstraction as ActorProcessor.
Instead you'll be better off using mapAsync to integrate with an Actor,
which then can do whatever it needs to do.
Also, current consensus about
Hi guys,
quick update on the topic.
It has indeed uncovered a bug in the PromiseActorRef.
It does handle sending Termination properly, but did so with a mistaken actor
in the Terminated(…) message, thus you wouldn’t get the Terminated you were
waiting for, and the above explanation of Yaroslav
Hi Allen!
The error looks a bit weird… We don’t have any parameter named g2 (well, it
only takes one parameter) in the snippet you provided.
Would you be able to provide a more complete snippet and complete compile error?
Thanks!
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @ Typesafe
On 30 March
and I found the bug.
Sincerely,
Allen
On Sunday, March 29, 2015 at 6:54:18 PM UTC-4, Konrad Malawski wrote:
Hi Allen!
The error looks a bit weird… We don’t have any parameter named g2 (well, it
only takes one parameter) in the snippet you provided.
Would you be able to provide a more complete
Don't use FileBasedMailboxType, it's deprecated and not something we
recommend doing (semantics wise).
Use Persistent Actors, they are documented here:
http://doc.akka.io/docs/akka/current/scala/persistence.html
On Tue, Mar 24, 2015 at 4:03 AM, Aditya Devisetty adityadevise...@gmail.com
wrote:
Thanks for reporting Giovanni!
The old ticket was: https://github.com/akka/akka/issues/16934
But a few slipped through: https://github.com/akka/akka/issues/16963,
could you add your finding to this ticket so we don’t miss it?
Thanks in advance!
--
Cheers,
Konrad 'ktoso’ Malawski
Akka @
Hello Dan,
not yet, but it's being worked on :-)
Here's the add your +1 if you'd love that feature ticket:
https://github.com/akka/akka/issues/16848
Here's the ongoing technical discussion on the topic:
https://github.com/akka/akka/issues/16887
Soon. :-)
On Tue, Mar 10, 2015 at 3:07 AM, Dan
Hi Bogdan,
in M4 we changed the graph DSL to be more typed (we like types :-)), a
brief introduction can be found in the announcement email:
https://groups.google.com/forum/#!topic/akka-user/8UNq8QdkYoI
Please do remember that the milestones are considered pre-alpha, everything
can change,
Dear hakkers,
We—the Akka committers—are pleased to be able to announce the availability
of Akka 2.2.5.
This is the fourth maintenance release of the 2.2 branch, and was sponsored
by Manhattan Associates, Inc.
It includes a fix concerning file-based durable mailboxes, which might have
grown
Hi Tim!
I can’t reproduce what you mention, which exact jar are we talking about?
I downloaded the source jar from:
http://search.maven.org/#artifactdetails%7Ccom.typesafe.akka%7Cakka-stream-experimental_2.11%7C1.0-M4%7Cjar
and it does seem to contain valid javadoc, or am I missing something?
//
Hi Manuel,
as discussed on LambdaDays today: this won't work, because what guarantees
persist() is meant to give.
Instead you could become() and then do things inside there, or send other
commands to yourself to which the actor should react.
On Thu, Feb 26, 2015 at 11:52 AM, Anders Båtstrand
Hi Paul,
You raise a valid point about still using java serialization in some places
by default.
In general we strongly advertise against using the java serializer (slow,
and schema evolution hostile) - which again is the culprit here...
You're right however that it's one of our internal classes
Hi Yuri,
that’s correct. You can think of Akka HTTP as the “next Spray”.
Once it’s stable and performance tuned we’ll recommend teams to migrate over
from spray to Akka HTTP (and the migration shouldn’t be too painful).
It will also contain features which were missing in Spray - such as
Hi Sam,
Both are true.
Spray is Spray, and Akka-HTTP is Akka-HTTP.
It’s not the same code base - the internals have been completely rewritten –
thus, the SSL things are not reimplemented yet.
We’re working on it though and it will be part of akka-http soon.
--
Cheers,
Konrad 'ktoso’ Malawski
Hi Jean!
Without skimming your actual benchmarks let me reply right away – Akka HTTP is
definitely a great long-term candidate for what you’re after,
but(!) currently we have not yet performance tuned the underlying streams
architecture. It is expected that 1.0-M3 is not crazy fast. We do plan
Hi Łukasz,
That's one of the patterns we should include in the docs I think - I opened
an issue https://github.com/akka/akka/issues/16882 for it.
In general you'll want to have a processing stage in your handler Flow
which is able to react to completion.
Examples of such elements are either
Hi Arek,
Thanks for your effort! I read through your impl and would like to share a
few hints:
Please do not ever rely on java finalization – ever.
For one thing, it's unreliable – no-one guarantees that these will ever be
called. [60]
Hello there!
There isn't an 1:1 update of that page for 2.3.x but you may simply want to
follow the introduction chapter
http://doc.akka.io/docs/akka/2.3.9/intro/index-java.html of the docs
section by section :-)
* http://doc.akka.io/docs/akka/2.3.9/intro/getting-started.html - for setup
help
*
This is really awesome, kudos Tim!
Hoping to get to play around with it a bit more soon.
Answering some in-lined questions you mention:
* We do not yet have websockets in akka-http, but they are on the roadmap :-)
* I think the lack of scala.js can be excused in this case, awesome execution!
--
Hi Alexey!
This sounds like it should be thought of and perhaps shipped together with the
Streams Testkit once we get to implementing it.
Feel free to add your ideas to this ticket:
https://github.com/akka/akka/issues/15748 in which we’re tracking ideas on what
a Streams TestKit should look
601 - 700 of 903 matches
Mail list logo
