The reader is instructed to change consoleReaderActor.Tell("start");to consoleReaderActor.Tell(ConsoleReaderActor.StartCommand); in two different locations in the text.

Step 1 of "Experience the danger..." probably shouldn't say to open WinTail.sln. The code to uncomment is in Program.cs.

When running the completed code or the code I wrote following the guide I get an unhandled NullReferenceException in ChartingActor.cs in HandleMetrics (See comment below)

private void HandleMetrics(Metric metric)
    {
        if (!string.IsNullOrEmpty(metric.Series) && _seriesIndex.ContainsKey(metric.Series))
        {
            var series = _seriesIndex[metric.Series];
            series.Points.AddXY(xPosCounter++, metric.CounterValue); // <- series.Points is null!
            while(series.Points.Count > MaxPoints) series.Points.RemoveAt(0);
            SetChartBoundaries();
        }
    }

I've managed to reproduce the problem when enabling all performance counters, disabling them and enabling them again and then exit the application.

As I understand actors Receive delegate should be non blocking.

var getStars = _gitHubClient.Activity.Starring.GetAllStargazers(starrers.Owner, starrers.Repo);

//ewww
getStars.Wait();

So the question is how to code non blocking io operation, e.g http request, and another question
is how to code cpu intensive tasks with actors.

Thank you!

Currently working Bootcamp in a Xamarin/Mono 3.12.0 environment. In Lesson 1.4 there's a problem with FileSystemWatcher() which has been a nuisance bug to the Mono community for a while where the Changed state is never passed. Here's the Bugzilla: https://bugzilla.xamarin.com/show_bug.cgi?id=19741

The following is a partial workaround but I haven't had time to properly debug it. This workaround allows for the Changed state to pass but then it seems something might not be working with TailActor(). The workaround is discussed here: http://stackoverflow.com/questions/16859372/why-doesnt-the-servicestack-razor-filesystemwatcher-work-on-mono-mac-os-x

The workaround -- in FileObserver.cs -> Start(), before the _watcher = new FileSystemWatcher(...), insert

// Need this for Mono 3.12.0 workaround
Environment.SetEnvironmentVariable("MONO_MANAGED_WATCHER", "enabled");

Haven't hide time to follow through but I know I need to at least drop this here! Will check back in later this evening and try some more debugging.

Sites such as OneDrive and DropBox are blocked at my company. It might be nice to offer an alternative for those of us in Internet Jail.

I'm running using mono on linux and seem to be getting a deadletter error. This occurs on both the solution I modified as well as the completed solution you provide.

This is what I get

Please provide the URI of a log file on disk.

file.log
[INFO][12/03/2015 10:43:41 p.m.][Thread 0005][akka://MyActorSystem/deadLetters] Message String from akka://MyActorSystem/user/consoleReaderActor to akka://MyActorSystem/deadLetters was not delivered. 1 dead letters encountered.

In the part "What is an actor"

everything is an object in OOP, in the actor modeleverything is an actor.
Repeat this train of thought to yourself.

modeleverything needs a space -> model everything
And after the sentence there should be properly another newline ;-)

This is the code for "GetAndValidateInput" from the lesson 1.2 email:

/// <summary>
/// Reads input from console, validates it, then signals appropriate response
/// (continue processing, error, success, etc.).
/// </summary>
private void GetAndValidateInput()
{
    var message = Console.ReadLine();

...

    else
    {
        var valid = IsValid(message);
        if (valid)
        {
            _consoleWriterActor.Tell(new Messages.InputSuccess("Thank you! Message was valid."));
        }
        else
        {
            Self.Tell(new Messages.ValidationError("Invalid: input had odd number of characters."));
        }

        // continue reading messages from console
        Self.Tell(new Messages.ContinueProcessing());
    }
}

The "Self.Tell" in this line should actually be _ConsoleWriterActor.Tell:

    Self.Tell(new Messages.ValidationError("Invalid: input had odd number of characters."));

When running the completed solution for lesson 2.3 I receive the following error when the below code is run on start up

{CounterType.Cpu, () => new PerformanceCounter("Processor", "% Processor Time", "_Total", true)}

An exception of type 'System.InvalidOperationException' occurred in System.dll but was not handled in user code
Additional information: Cannot load Counter Name data because an invalid index '' was read from the registry.

To solve this we need to clear the counter cache. Solution is here. You might want to add a note to the lesson about this.

The code is wrong in the 2.5 exercise, in Phase 2, in the new implementation of the Pause() method, in the Receive handler for TogglePause messages, Unbecome() is called instead of UnbecomeStacked(). The actual code is correct.

Exception:

An exception of type 'System.InvalidOperationException' occurred in System.Windows.Forms.dll but was not handled in user code

Additional information: Cross-thread operation not valid: Control 'sysChart' accessed from a thread other than the thread it was created on.

Stack trace

   at System.Windows.Forms.Control.get_Handle()
   at System.Windows.Forms.Control.Invalidate(Boolean invalidateChildren)
   at System.Windows.Forms.DataVisualization.Charting.Chart.Invalidate()
   at System.Windows.Forms.DataVisualization.Charting.Data.DataManager.Invalidate()
   at System.Windows.Forms.DataVisualization.Charting.ChartElement.System.Windows.Forms.DataVisualization.Charting.IChartElement.Invalidate()
   at System.Windows.Forms.DataVisualization.Charting.ChartElementCollection`1.Invalidate()
   at System.Windows.Forms.DataVisualization.Charting.ChartElementCollection`1.ResumeUpdates()
   at System.Windows.Forms.DataVisualization.Charting.ChartElementCollection`1.ClearItems()
   at System.Collections.ObjectModel.Collection`1.Clear()
   at ChartApp.Actors.ChartingActor.HandleInitialize(InitializeChart ic) in c:\Users\keks\Projects\akka-bootcamp\src\Unit-2\DoThis\Actors\ChartingActor.cs:line 58
   at ChartApp.Actors.ChartingActor.OnReceive(Object message) in c:\Users\keks\Projects\akka-bootcamp\src\Unit-2\DoThis\Actors\ChartingActor.cs:line 43
   at Akka.Actor.UntypedActor.Receive(Object message)
   at Akka.Actor.ActorBase.AroundReceive(Receive receive, Object message)
   at Akka.Actor.ActorCell.ReceiveMessage(Object message)
   at Akka.Actor.ActorCell.Invoke(Envelope envelope)

Exercise Uint3/Lesson2 (https://github.com/petabridge/akka-bootcamp/tree/master/src/Unit-3/lesson2) is not fully explained.
Programming steps in lecture do not cover all changes in GithubCommanderActor.
Thanks good I can use code from "Completed" folder.

Actual source code for PreRestart

 /// <summary>
        ///     User overridable callback: '''By default it disposes of all children and then calls `postStop()`.'''
        ///     <p />
        ///     Is called on a crashed Actor right BEFORE it is restarted to allow clean
        ///     up of resources before Actor is terminated.
        /// </summary>
        /// <param name="reason">the Exception that caused the restart to happen.</param>
        /// <param name="message">optionally the current message the actor processed when failing, if applicable.</param>
        protected virtual void PreRestart(Exception reason, object message)
        {
            Context.GetChildren().ToList().ForEach(c =>
            {
                Context.Unwatch(c);
                Context.Stop(c);
            });
            PostStop();

Directly contradicts https://github.com/petabridge/akka-bootcamp/tree/master/src/Unit-1/lesson6#poststop

The following line of code:

if (message.Equals(StartCommand))

I was wondering if a passed on message can be null. I couldn't find anything this way in the documentation so I assume it could be and therefore the could would be less fragile this way:

if (message == StartCommand)

or

if (StartCommand.Equals(message))

Strange sentence here:

But in addition to processing messages it receives, and actors are also able to do 3 other special actions:

It looks like the field FileObserver._absoluteFilePath isn't actually used since the file name and directory are parsed out and stored separately. If that's accurate (and don't think there's a reason to keep it), I'd be happy to submit a PR removing it from the lesson sources and text.

In section "The /user actor hierarchy", it states:

For example, if we were running on localhost, the full address of actor b2 would beakka.tcp://MyActorSystem@localhost:9001/user/a1/b2

Based on the examples, I believe it should be:
akka.tcp://MyActorSystem@localhost:9001/user/a2/b2

what is the valid URI format that I can provide in the console window when the program runs? say I have my log file on the C drive in this path C:\test\log.txt

If you type anything but exit, and then type exit I get a DeathWatchNotification when the shutdown occurs.

1. Open solution from https://github.com/petabridge/akka-bootcamp/tree/master/src/Unit-1/lesson1/Completed
2. Run start up project
3. type foo
4. hit enter
5. type exit
6. hit enter
7. DeathWatchNotifcation will be displayed during shutdown

See this section:
https://github.com/petabridge/akka-bootcamp/tree/master/src/Unit-3/lesson3#how-do-i-use-the-hocon-config

The only sentence in this section starts with small letter and has no point at the end. It is too complex for understanding either.

While it is not directly related to Akka.Net course, I believe samples should not introduce anti-patterns.

In the explanation at the conclusion of exercise 1.5, it says:

"This one is a little counter-intuitive. Here's the deal. In this case, we aren't using the handle for consoleWriterActor to talk directly to it. Instead we are putting that IActorRef inside a message that is getting sent somewhere else in the system for processing."

However, at this point in the exercises the code is still making direct "Tell()" calls using the _consoleWriterActor in several places in FileValidatorActor (in the distributed "Completed" code) along with packaging it into a StartTail message. Of course this misstatement doesn't change the overall spirit of the explanation. I just found it a distraction.

Hello,
Just passed lessons 3 and 4, noticed that a NullReferenceException sometimes occurs in ChartingActor in method HandleMetrics on series.Points object. This exception occurs when closing the application.

https://github.com/petabridge/akka-bootcamp/blob/8391bc4782c6a29f41ea2e01c31de179b04e65cc/src/Unit-1/lesson4/README.md#but-what-happens-to-the-current-message-when-an-actor-fails - this may not be technically correct. Need to investigate.

With the completed charting app, it seems the desired behavior is that if you pause the app, the old data will continue to move to the left, with all new data points being at Y=0 (bottom of the chart).

But, if you pause the chart, and then turn off all of the toggles it will stop moving the old data to the left. Additionally if you turn any of them back on (still in the paused state), the data will again move to the left (because the toggles do not involve the charting actor directly -- it just receives the add/remove series events).

I recommend passing the toggle messages to the charting actor instead of the toggle actors directly. This way, the charting actor can decide if it wants to route the messages on to the toggle actors, or if it would rather stash them instead.

ActorOf is not a method of ActorRef.

// create the children of actor a2
ActorRef b1 = a2.ActorOf(Props.Create<BasicActor>(), "b1");
ActorRef b2 = a2.ActorOf(Props.Create<BasicActor>(), "b2");

Link: https://github.com/petabridge/akka-bootcamp/tree/master/src/Unit-1/lesson4#actor-path--actor-position-in-hierarchy

When running this under Mono on OS X (10.9.5), FileStream doesn't read file to the end after modification saved. As a result TailActor doesn't notify _reporterActor about changes. This line always gets empty string:

var text = _fileStreamReader.ReadToEnd();

https://github.com/petabridge/akka-bootcamp/blob/master/src/Unit-1/lesson4/Completed/TailActor.cs#L92

It looks like Mono issue.

The original file in DoThis for unit3 doesn't contain using Akka.Routing; but after adding all the code in Lesson 1, the code in PreStart uses BroadcastGroup which belongs to Akka.Routing.

In Lesson 3.3 we are asked to update the implementation of BecomeAsking in GithubCommanderActor, but it's does not exist in the ZIP version downloaded from DropBox (link received in email).

Analysing "Completed" code from Git repo, it seems that the ZIP is outdated.

I will enumerate all the things I noticed in this lesson.

In no particular order:

• High level overview image points to the wrong url: It should be: https://github.com/petabridge/akka-bootcamp/blob/master/src/Unit-2/lesson3/images/system_overview_2_3.png
• In the introduction to scheduling a code snippet contains the wrong code to access the scheduler from inside an actor: It says: Context.System.system.Scheduler.ScheduleOnce() where it should obviously be: Context.System.Scheduler.ScheduleOnce()
• I noticed one grammar error. This sentence is wierd: "Scheduled messages become are scheduled onto the CLR threadpool and use Task.Delay under the hood. "

Thats it :)

I tried out the tails on some real world 1.7GB log file (yeah I should trim it) and got an OutOfMemory Exception (ok what did I really expect - ReadToEnd on that file ...). So I tried to "fix" it. I wrote my own ReadToEnd where I'm reading chunks of 1MB:

    private const int MaxCharsToRead = 1024 * 1024; // 1MB

    private string ReadToEnd() 
    {
        var buffer = new char[MaxCharsToRead];
        var charsRead = _fileStreamReader.ReadBlock(buffer, 0, MaxCharsToRead);

        if (charsRead == buffer.Length) // buffer is full, probably more bytes waiting
        {
            Self.Tell(new FileWrite(_filePath));   
        }
        return new string(buffer);
    } 

Additionally, I've changed the end of the constructor to:

    Self.Tell(new FileWrite(_filePath));

So that I wouldn't really need the InitialRead anymore, but now two things:

1. is this a good approach? Is Akka.Net (or the actor model in general) supposed to be used like this?
2. This works when I redirect stdout to a file, but I'm still getting OutOfMemory errors when having normal console output. Is there a way to throttle this? I could have a callback - notifying that the message has been processed and the next message can be processed, but that would be quite complicated (given the existing solution) and not really useful, as I want to process the messages at my pace, not knowing what kind of actors are sitting behind.

full code can be found here: https://github.com/pgrm/akka-bootcamp/blob/master/src/Unit-1/DoThis/TailActor.cs

In lesson 1.4 we're advised to update the ValidationActor constructor to take two parameters, but when we're asked to update the instantiation code, the new code still only contains one parameter -- this doesn't work!

New code that still only uses one parameter:

Props validationActorProps = Props.Create(() => new FileValidatorActor(consoleWriterActor));

We're never asked to update this code to add in the second parameter. -- It's easy enough to figure this out, but the code & instructions should still be updated.

There is a problem with running the code for Unit 2 in Xamarin on OS X Yosemite, the application cannot run.

Any workarounds or gtk# alternative?

Hi,
I'm working behind a proxy and I had issues connecting to github using octokit. I managed to solve this issue by adding the following settings to the configuration file.
<system.net>
<defaultProxy useDefaultCredentials="true" />
</system.net>

It seems Octokit has evolved. There is a warning message in the lesson 3 solution:

Warning CS0618 'Repository.SubscribersCount' is obsolete: 'This property has been obsoleted. Please use WatchedClient.GetAllWatchers instead.' ...\Visual Studio 2015\Projects\GithubActors\Actors\RepoResultsActor.cs 61

                row.Cells[4].Value = repo.SubscribersCount;

The whole section starting with Use Become to adopt a new behavior confused me for a minute - the animated diagrams of how the stack works are labled Become(...), not BecomeStacked(...). There is also a note saying Become will delete the old behavior off the stack, making me wonder what the deal was with all this stack talk if it always deletes the previous top?!

It was just confusing for a bit - maybe explicitly say early on there are 2 variations - Become() clears the stack and pushes, BecomeStacked() just pushes?

In the lesson 1.4 final diagram I think, but I am not 100% sure, that FileObserver sends FileWrite to TailActor and not to TailCoordinatorActor.

Code samples in the readme.md files are started with

```csharp

That seems to work well when displayed online in GitHub. But if I look at the .md file with a markdown editor like Mou it does not render well:

So the question should really be: What to optimize the markdown for? GitHub or any other markdown editor/reader?

In the mail the code is written like this

private void GetAndValidateInput()
{
    var message = Console.ReadLine();
    <snip if string.IsEmptyOrNull part>
    else
    {
        var valid = IsValid(message);
        if (valid)
        {
            _consoleWriterActor.Tell(new Messages.InputSuccess("Thank you! Message was valid."));
        }
        else
        {
            Self.Tell(new Messages.ValidationError("Invalid: input had odd number of characters."));
        }

        // continue reading messages from console
        Self.Tell(new Messages.ContinueProcessing());
    }
}

However, this results in unexpected behavior when an invalid message are entered - upon pressing enter, nothing happens - and then the parsing of the messages are delayed by a few Console.ReadLine's.

In the examples in your completed folder, it is correctly written like this (same part of the funtion)

var valid = IsValid(message);
if (valid)
{
    consoleWriterActor.Tell(new Messages.InputSuccess("Thank you! Message was valid."));

     // continue reading messages from console
    Self.Tell(new Messages.ContinueProcessing());
}
else
{
    Self.Tell(new Messages.ValidationError("Invalid: input had odd number of characters."));
}

Where the Self.Tell part has been moved into the if(valid) part of the if statement.

NOTE: Ask is a blocking, synchronous operation.

http://api.getakka.net/docs/stable/html/E25BBF1C.htm
http://api.getakka.net/docs/stable/html/4BD93F0C.htm
As I can see, both extension methods return Task, which can be awaited inside RecieveActor. So this is probably outdated.

I'm trying to make sense of the code as I'm going through it, and am really stumbling over how things are named. The two things that create ambiguity are:

• We have GithubCommanderActor and GithubCoordinatorActor. I'm trying to reason in my mind about what might be the difference between something that "commands" and something that "coordinates." I don't think this is very clear. To make the point, the comment for GithubCommanderActor says, "Top-level actor responsible for coordinating...".
• For the commander's messages, we've got CanAcceptJob and AbleToAcceptJob. Again, just looking at these names, it's hard to distinguish what they are used for -- seems like two ways of saying the same thing. I'm pretty sure that "can" and "able to" are exactly synonymous. This makes it hard to comprehend what GithubCommanderActor is doing as I read through the code.

Could these names be changed to something more descriptive that could be used to help a newcomer to the code follow along? If something occurs to me when I reach the end of the lesson I'll update this issue.

Following lessons 1.1 and 1.2 from the email instructions leaves the program.cs Main with Actor creation like this:

var consoleWriterActor = MyActorSystem.ActorOf(Props.Create(() => new ConsoleWriterActor()));
var consoleReaderActor = MyActorSystem.ActorOf(Props.Create(() => new ConsoleReaderActor(consoleWriterActor)));

This gave me a build error on the following line:
consoleReaderActor.Tell(ConsoleReaderActor.StartCommand);

"StartCommand" unable to resolve symbol.

The completed code example has the creation of the Actors with names being assigned to them:
// make our first actors!
IActorRef consoleWriterActor = MyActorSystem.ActorOf(Props.Create(() => new ConsoleWriterActor()),
"consoleWriterActor");
IActorRef consoleReaderActor =
MyActorSystem.ActorOf(Props.Create(() => new ConsoleReaderActor(consoleWriterActor)),
"consoleReaderActor");

Which resolves the build issue, but doesn't explain why you need to pass in the second (name) parameter when creating your Actors.

In TailActor.cs the actor opens and holds a Stream pointing to the input file. The actor never closes the stream or associated stream reader.

This is probably not an issue in this particular case, since the stream is supposed to be opened for the duration of the app but since this is lesson material it might be a good idea to clarify such use cases. Or maybe show how to control the lifetime of the actor & stream.

Nevertheless this raises a few questions:

Should actors own disposable resources? If yes when are these resources supposed to be released?

Assuming an app needs to open and close multiple files what is the best way to ensure no resources are leaked?

Is the general recommendation to avoid controlling resource lifetime with messages (for ex to have a message to open the file and a message to close the file) and instead have the resource operation inside a message handler ( on receive ReadFromFile message - open file, read content, close file - pass content to other actor ).?

Thanks, and btw awesome idea with the akka bootcamp.

The instructions just say:

ConsoleReaderActor is set up to read from the console. Have it send a message to ConsoleWriterActor containing the content that it just read.

   // in ConsoleReaderActor.cs
   _consoleWriterActor.Tell(read);

So you know what file to put it into, but not where (i.e. what method) -- I almost just put it in the constructor (since that's basically what we were doing up until that step), but then I thought better of it and decided to search around, and finally identified the comment in the code.

Please include more details in the walkthrough.

Lines 91-93 of Unit-3\lesson3\README.md looks like this:

#### How do I use the HOCON config?
setting up router needs a router config
as long as the router config passed isn't "no router" then it will

This is not written as a complete sentence; I actually have no idea what is meant.

At the bottom of the lessons is a paragraph that says:

If there is a problem with the code running, or something else that needs to be fixed in this lesson, please create an issue and we'll get right on it. This will benefit everyone going through Bootcamp.

The "create an issue" link is invalid for the three lessons I've received so far. It takes me to a GitHub 404 page.

Hello,
In Unit 3, Lesson 2, after using the pool router to accelerate the job I discovered that the tool was unable to complete the fetch for some repositories.
It is annoying since it cannot allow us to see the performance difference for the entire process.
After investigation I saw that it comes from an Octokit.ForbiddenException with the following message:

"You have triggered an abuse detection mechanism and have been temporarily blocked from calling the API. Please retry your request again later."

It makes sense and I'm not sure that is a real issue. I just wanted to let you know about that.
Maybe I missed something or it could be a good idea to detect these kind of errors and notify the user.

If you need more information let me know!

There is no need to cast message object when it is told actor.
This

            else if(message is Messages.InputError)
            {
                _consoleWriterActor.Tell(message as Messages.InputError);
            }

gives the same result as

            else if(message is Messages.InputError)
            {
                _consoleWriterActor.Tell(message);
            }

When we replace all of the ChartingActor's Receive declarations into their own method, the presented code does not show the type parameter, but is required since it cannot be inferred from the delegate.

private void Charting()
{
    Receive(ic => HandleInitialize(ic));
    Receive(addSeries => HandleAddSeries(addSeries));
    Receive(removeSeries => HandleRemoveSeries(removeSeries));
    Receive(metric => HandleMetrics(metric));
    Receive(pause =>
    {
        SetPauseButtonText(true);
        BecomeStacked(Paused);
    });
}

Should be:

        private void Charting()
        {
            Receive<InitializeChart>(ic => HandleInitialize(ic));
            Receive<AddSeries>(addSeries => HandleAddSeries(addSeries));
            Receive<RemoveSeries>(removeSeries => HandleRemoveSeries(removeSeries));
            Receive<Metric>(metric => HandleMetrics(metric));
            Receive<TogglePause>(pause =>
            {
                SetPauseButtonText(true);
                BecomeStacked(Paused);
            });
        }

Same issue for the Paused method.