Attention: We are retiring the ASP.NET Community Blogs. Learn more >

Contents tagged with Open Source

  • Command Handling the Nancy Way

    4 Comments

    minibuss_small_thumb1_thumb_thumb MiniBuss is a micro service bus framework over msmq which consists of less than 400 lines of code, sitting inside one single source file. The project is hosted over at http://minibuss.codeplex.com and the source code is maintained at https://github.com/johandanforth/MiniBuss

    I’ve been a fan of the Sinatra inspired web framework called Nancy, especially the neat way of setting up handlers for routes. The simplest sample on their site is this:

    public class Module : NancyModule
{
    public Module()
    {
        Get["/greet/{name}"] = x => {
            return string.Concat("Hello ", x.name);
        };
    }
}

    So, I shamelessly dug into the Nancy code and borrowed some 20-30 lines of code and came up with something like this for registering handlers for certain incoming commands on the minibus, what do you think?

    public class CommandHandler : MessageHandler
{
    public CommandHandler()
    {
        WhenReceiving[typeof(SampleMessage1)] = x =>
        {
            Console.WriteLine("sample 1 message: " + x.Text);
        };

        WhenReceiving[typeof(SampleMessage2)] = x =>
        {
            Console.WriteLine("sample 2 message: " + x.Text);
        };
    }
}

    It’s a bit more code but it helps/enforces you to move the handlers off to a certain module. Thoughts?

  • More MiniBuss Updates

    No Comments

    minibuss_small_thumb1_thumb MiniBuss is a micro service bus framework over msmq which consists of less than 400 lines of code, sitting inside one single source file. The project is hosted over at http://minibuss.codeplex.com

    Thanks to @CodingInsomnia for testing out the MiniBuss stuff a bit more than I did Winking smile For the samples, and for my initial testing code, I used a shared assembly with messages (events and commands), which shouldn’t be necessary. So I made a few simple changes and now you can choose to either share messages in an assembly between your sender/receiver and publisher/subscribers OR you can declare local message classes as long as those classes use the same class name and properties it should work.

    The NuGet package has been updated, and the new code is in package version 1.0.2.0.

  • MiniBuss Updates

    No Comments

    minibuss_small_thumb1 I made a small update to MiniBuss, the micro service bus framework. The messages you send, Commands and Events, are no longer dependent on IMessage. The messages sent on the bus can now be any .NET class which can be safely serialized.

    The MiniBuss package on NuGet has been updated (version 1.1.0.1).

    I’m looking for testers, reviewers and co-authors. Areas I want to look more at are multithreading/concurrency and the reply-feature (especially being able to reply to current message in multithreaded scenarios.

  • MiniBuss on Codeplex

    3 Comments

    minibuss_small The micro service bus framework for msmq called MiniBuss is now open source on Codeplex at http://minibuss.codeplex.com

    There is also now a NuGet package available for easy install into projects:

    image

    If you’re interested in co-op on this project, please contact me via Codeplex! I’m looking for devs and tester who knows their c#, msmq and concurrency.

  • A One File .NET Micro Service Bus for MSMQ?

    9 Comments

    This last year our company has invested quite some time in looking at CQRS, which led to looking at great looking service-buses like nServiceBus, Rhino Service Bus and Mass Transit, which led me to do some bus-coding on my own, mostly for fun and for learning MSMQ.

    Inspired by the service buses mentioned above, the result became a bare-bones-one-file “micro service bus” that I call MiniBuss which sits on top of MSMQ. The file itself is only some 400 lines of code and supports send, receive, reply, publish and subscribe/unsubscribe.

    Setting up a sender may look something like this:

    var bus = new MiniBuss.ServiceBus();

    bus.RegisterMessageEndpoint<HelloCommand>("minibuss_receiver1@johan-dell-ssd");

    bus.Start();

    bus.Send(new HelloCommand { Guid = Guid.NewGuid(), Message = "Hello" });

    Create the bus, register a message and tell it where messages of this type should go, start the bus and send the message.

    Setting up a receiver may look something like this:

    var bus = new ServiceBus { LocalEndpoint = "minibuss_receiver1" };

    bus.RegisterMessageHandler<HelloCommand>(command => Console.WriteLine(command.Message + " Guid: " + command.Guid));

    bus.Start();

    Create the bus and tell it which endpoint to listen to (which creates a local MSMQ queue if necessary) and tell it which message type to listen for and which delegate to kick off when such a message is received.

    Similarly, when doing a receive/reply, you would have to create the bus on the sender side with a local endpoint and register a message-handler for replies, like this:

    var bus = new MiniBuss.ServiceBus { LocalEndpoint = "minibuss_sender1" };

    bus.RegisterMessageEndpoint<HelloCommand>("minibuss_receiver1@johan-dell-ssd");

    bus.RegisterMessageHandler<HelloResponse>(reply => Console.WriteLine("Reply from receiver: " + reply.Message));

    bus.Start();

    Console.WriteLine("Sending command...");
    bus.Send(new HelloCommand { Guid = Guid.NewGuid(), Message = "Hello" });

    The receiver would do a bus.reply() like this:

    var bus = new ServiceBus { LocalEndpoint = "minibuss_receiver1" };

    bus.RegisterMessageHandler<HelloCommand>(command =>
    {
        Console.WriteLine(command.Message + " Guid: " + command.Guid);

        bus.Reply(new HelloResponse { Guid = Guid.NewGuid(), Message = "Hello back!" });
    });

    bus.Start();

    The MiniBus also supports publish to multiple subscribers. A simple publisher would create a bus with a local endpoint (to receive subscribe/unsubscribe commands), tell it to handle subscriptions for a certain event, then start publishing something every 5 seconds (as an example):

    var bus = new MiniBuss.ServiceBus { LocalEndpoint = "minibuss_publisher1" };

    bus.HandleSubscriptionsFor<SomethingHappenedEvent>();

    bus.Start();    

    Task.Factory.StartNew(() => PublishingThread(bus), TaskCreationOptions.LongRunning);

    Console.WriteLine("Done, press ENTER to exit");
    Console.ReadLine();
    private static void PublishingThread(MiniBuss.ServiceBus bus)
    {
        while (true)
        {
            Thread.Sleep(5000);
            var guid = Guid.NewGuid();
            Console.WriteLine("Publishing event with guid " + guid);
            bus.Publish(new SomethingHappenedEvent() { Guid = guid, Sent = DateTime.Now });
        }
    }

    Any clients interesting in subscribing to events from the publisher would create a bus with a local endpoint, start the bus and then send a subscribe command to the publisher, telling it you’re interested in subscribing to a certain type of event and which delegate to handle it:

    var bus = new MiniBuss.ServiceBus {LocalEndpoint = "minibuss_subscriber1"};

    bus.Start();

    bus.Subscribe<SomethingHappenedEvent>("minibuss_publisher1@localhost",
        @event => Console.WriteLine("something happened at {0}, event id {1}",
            @event.Sent, @event.Guid));

    Console.WriteLine("Waiting for events, press ENTER to exit");
    Console.ReadLine();

    bus.UnSubscribe<SomethingHappenedEvent>("minibuss_publisher1");

    Now, the question is, what do you think? I know there are issues with the code, like how to make message-handlers multi-threaded/concurrent without messing things up (it’s single threaded right now), and how to best handle exceptions, rollbacks and re-tries . Right now handling exceptions in send and receive works pretty well within a TransactionScope() together with ADO.NET, and if there’s an exception, the message is moved the an error-queue. No re-try or anything, only rollback and move to xxx_error. Also, the publisher doesn’t persist subscriptions, so if it is restarted subscribers wouldn’t know. You know, things like that.

    I’m a user of the micro-orm called Dapper and like it a lot, so I’m thinking that maybe I should release this micro-bus as open source and see where people may take it, if anywhere? Maybe just down the drain because they figure out this service bus is dangerous to use and risk loosing messages or something (which would be extremely good to know :)

    Or maybe this code is useless because you already got nServiceBus and Rhino out there and coders don’t need another service bus?

    What do you say?

  • Pomodoro Timer for the Windows 7 TaskBar

    7 Comments

    EDIT:  The code is now open source on codeplex, on http://pomodorotaskbar.codeplex.com There's a new version available for download there too.

    If you’re into the Pomodoro technique and looking for a pretty simple out-of-the-way timer which sits in the Windows 7 taskbar and is controlled from the Win7 JumpList, this one might be worth trying out.

    NOTE: Icon overlays will NOT work if you're using small TaskBar icons!

    image

    That’s the timer looking like a tomato, with the remaining session minutes written out dynamically as icon overlay.

    image

    The timer has a couple of JumpList Tasks which you can use to control it. The program works well when “pinned” to the taskbar if you prefer it.

    image

    You can also control the timer from the main window with one large action-button (stop, start, stop ringing and restart session).

    image

    When the timer is stopped, you can just click on the remaining minutes-textbox and change the default session length to whatever you like. The value is stored.

    image

    When the session is ended, the window flashes, the tomato shakes and a ringing sound is played a few times to get your attention.

    Note, this is a very simple program which I’m planning to release as open source when I’ve received some feedback. I prefer to keep it simple, but may add session logging. The name as well as the looks may change. .NET 4.0 is required.

  • Some Good Feedback for Writespace

    No Comments

    WritespaceIt’s been a while since I actually looked at the Codeplex statistics for Writespace, but it seems that people keep downloading it and that’s always fun! So far Writespace has been downloaded over 4.000 times which is peanuts compared to other open source tools, but perhaps I helped some people get more productive and that feels good!

    Following the top referring sites I can see that this simple addin for Word gets some good reviews from people that compares it with other similar tools. One of the best articles I’ve seen so far is the one by Rob Oakes, which he calls On Writing – Software that cuts out distraction and clutter where he compares DarkRoom, WriteRoom, Writespace and PyRoom. They are all very similar to each other.

    What’s not so cool is that Writespace is an open source project, and it would have been fun to get some patches or help from other developers. Of the 4.000 downloads, I’m sure there are a whole lot of .NET developers that know their XAML well. I’ve got some feedback for ideas, one guy I know made some changes but didn’t send me code or a patch… pity. If you extend open source software, shouldn’t you share that? Maybe it’s too hard to create a patch?