Running Docker on Windows 10 Home

If you try to install Docker for Windows on Windows 10 Home edition, it would fail with a message that it requires Windows Professional. The reason is, that the current Docker requires Hyper-V enabled. But do not worry. If you have a CPU with Hyper-V (you can check it with msinfo32), there's a way, how install Docker on your machine. All credits goes to the Docker users in this forum post, especially to Marcel Hesselbarth and his blog Windows 10 Home Hyper-V aktivieren (in German).

1. Make a file hyperv.bat file and run is at Administrator:

@rem Install Hyper-V on Windows Home
pushd "%~dp0"
dir /b %SystemRoot%\servicing\Packages\*Hyper-V*.mum >hyper-v.txt
for /f %%i in ('findstr /i . hyper-v.txt 2^>nul') do dism /online /norestart /add-package:"%SystemRoot%\servicing\Packages\%%i"
del hyper-v.txt
Dism /online /enable-feature /featurename:Microsoft-Hyper-V -All /LimitAccess /ALL
pause

You need to reboot a computer after that.

2. Change your registry: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion and change EditionID from Core to Professional

3. Install Docker for Windows.

4. Change your registry back.

And voilà, we have a Docker running on Windows 10.

Python logger by class

Common Python logging practice is to have one logger per module (e.s. see the Fang's blog):

import logging
logger = logging.getLogger(__name__)

However, the general habit in other OOP programming languages (Java, C#, ...) is to have one (private static) logger per class:

public class MyObject {
    private final static Logger LOG = Logger.getLogger(MyObject.class.getName());
}

In Python, a logger per class may be created, too:

import logging
class Foo(object):
    __log = logging.getLogger(__name__ + '.Foo')

    def foo(self):
        self.__log.info('foo called')


class Bar(Foo):
    __log = logging.getLogger(__name__ + '.Bar')

    def bar(self):
        self.__log.info('bar called')


bar = Bar()
bar.foo()
bar.bar()

>>> INFO:__main__.Foo:foo called
>>> INFO:__main__.Bar:bar called

Note the double leading underscore __log to exploit the Python name mangling to simulate a private attribute. However, it is not very convenient to write the name of the class as a string. One way to avoid that is to init the logger after the class has been created:

class Bar(Foo):
    def bar(self):
        self.__log.info('bar called')


Bar._Bar__log = logging.getLogger(__name__ + Bar.__name__) # manual name mangling

Still not very nice. We had to type the name of the class manually again. So let's exploit a decorator black magic to do it automatically:

def addlogger(cls: type):
    aname = '_{}__log'.format(cls.__name__)
    setattr(cls, aname, logging.getLogger(cls.__module__ + '.' + cls.__name__))
    return cls


@addlogger
class Foo(object):
    def foo(self):
        self.__log.info('foo called')


@addlogger
class Bar(Foo):
    def bar(self):
        self.__log.info('bar called')


bar = Bar()
bar.foo()
bar.bar()

>>> INFO:__main__.Foo:foo called
>>> INFO:__main__.Bar:bar called

And voilà, we have a private static logger for each class with just one simple line or code.

.NET and Windows proxy problems

Windows has two HTTP APIs, which are unfortunatelly not 100% compatible in case of proxy settings:

• WinINet, used by Internet Explorer and most of the Windows C/C++ applications. Window proxy settings dialog sets the proxy for the WinINet
• WinHTTP used by .NET.

So, when you develop a .NET application, is may happen that on a certain computer the Internet Explorer and other apps are connecting well, while your .NET app cannot connect to the Internet.
Since some proxy settings are hidden to the user by the "Automatically detect settings"checkbox, I have made a simple program WinProxyViewer, which may be run with a inexperienced user and the result sent to the application authors.

Default Credentials

.NET does not pick up the proxy credentials entered in the Windows proxy settings, e.g. see this StackOverflow thread. One solution is to add to the application config:

<system .net="">
  <defaultproxy usedefaultcredentials="true" />
</system>

But I preffer the solution in the code (at least for the desktop apps):

try
{
    System.Net.IWebProxy proxy = System.Net.WebRequest.DefaultWebProxy;
    PropertyInfo propInfo = proxy.GetType().GetProperty("WebProxy", BindingFlags.NonPublic | BindingFlags.Instance);
    ((System.Net.WebProxy)propInfo.GetValue(proxy)).UseDefaultCredentials = true;
}
catch (Exception ex)
{
    // log the exception
}

More proxies

The automatic proxy script for the WinINet may contain more proxy servers. The WinINet chooses next cycle the list until it finds the first proxy working. While the .NET (WinHTTP) use the first proxy from the list always, event when it does not work. So the .NET app may be disconnected, while the Internet Explorer is working. There is not known remedy for that. Fortunately, such situations are very rare.

NTLM proxy

.NET (WinHTTP) cannot automatically detect NTLM proxy and use Window credentials for it like the WinINet. There is not known remedy for that. NTLM proxies are sometimes used in the enterpise environments.

Summary

.NET app cannot be 100% compatible with all the Windows proxy settings. A possible solution for that is to have own proxy settings in the app. But the app may be used by people who cannot (security or have no knowledge) to set the proxy settings in the .NET app. So they may be situations, when .NET stays disconnected.

Atlassian Bamboo and xUnit testing

I needed to run xUnit test on the Atlassian Bamboo Cloud (OnDemand) build server. It has no runner for xUnit, but can be run from the command line by xunit.runner.console.

Configure your build server

On the build server, just NuGet the runner:

nuget.exe xunit.runner.console

The Bamboo cannot parse xUnit output. It can handle the nUnit output nd the xUnit has an option to print results in the nUnit format. So, create a simple xunit.cmd script:

@echo off
@rem xunit runner for Bamboo

if "%2"=="" (
  echo Usage: test.dll report.xml
  exit /b 1
)

if not exist %~dp2 mkdir %~dp2

"c:\path\to\xunit.runner.console.2.1.0\tools\xunit.console.exe" %1 -nunit %2

Configure Bamboo

Then go to your Bamboo Administration - Agents Summary and choose your agent. Add a new capability:

Capability type	Executable
Executable label	xUnit
Path	c:\path\to\xunit.cmd

To add the xUnit to you plan's job, just add the Command task after the project build (e.g. MSBuild, or NAnt). I expect you have a module MyProjectTests in your solution. Then configure the xUnit task:

Executable	xUnit
Argument	bin\Release\MyProjectTests.dll test-reports\MyProjectTests.xml
Working sub directory	MyProjectTests

The final trick is to add the NUnit Parser task, just take care to put is as the final task:

NUnit Test Results File/Directory

MyProjectTests/test-reports/*.xml

The bamboo logic is, that:

1. Any task fails, and no test result is found, it assumes the compilation error has occurred.
2. Any task fails, and a test result is found, it assumes a test has failed.
3. All tasks pass, the build is OK. If the test results are found, they are picked up.

C# Caliburn.Micro Check Unmatched Elements

Caliburn.Micro is a great C# MVVM framework. It saves the developer's fingers with the binding by the x:Name convention:

<textbox x:name="Username" />

However, when one mistypes the x:Name or rename the property in the ViewModel then the Caliburn silently does not apply the binding. Such mistakes are hard to track. Fortunately Caliburn comes with the help of ViewModelBinder.HandleUnmatchedElements. We have a simple rule in the project: if the x:Name starts with the capital letter, then it has to be binded by the Caliburn. Then I have been able to plug in a simple method to check for unmathched elements starting with the capital:

ViewModelBinder.HandleUnmatchedElements = (elems, type) =>
{
    if (!elems.Any())
        return;

    // elems with Name with the first letter upper case
    elems = elems.Where(e => !string.IsNullOrEmpty(e.Name) && e.Name.StartsWith(e.Name.Substring(0, 1).ToUpperInvariant()));
    if (!elems.Any())
        return;

    throw new InvalidOperationException(type + " contains Caliburn unmatched elements " + string.Join(",", elems.Select(e => e.Name)));
};

C# Safe Event Pattern

C# language has a very good support for event programming. However, is does not address a two common issues with event handlers:

1. An event handler is registered more times, but we want to call it just once.
2. An event handler is registered from longer living object then the event source. Then the event handler must be unregistered. Otherwise it may cause memory leaks.

First issue is usually simple to solve. The memory leaks are best avoided when using weak references. There are several solutions to .NET weak event references. e.g. see The .NET weak event pattern in C#. I have decided to go with .NET 4.5 WeakEventManager. The following pattern makes it easy for MyEvent consumer to write the code without worrying about event handler unregistering.

private event MyEventArgs _myEvent;

public event EventHandler<MyEventArgs> MyEvent
{
    add
    {
        // first unregister if registered
        MyEvent-= value;
        // register
        WeakEventManager<ThisType, MyEventArgs>.AddHandler(_myEvent, "MyEvent", value);
    }
    remove
    {
        WeakEventManager<ThisType, MyEventArgs>.RemoveHandler(_myEvent, "MyEvent", value);
    }
}

Log4net Configuration for Desktop Application

I have configured log4net for out current project, a plain Windows Desktop application. I wanted log to rolling file into the AppData\Local folder. Not the Roaming folder, since log are specific to the machine and it is waste of resources to let them roam around. Also I wanted to see logs in console, but in DEBUG mode only, not in production. First problem to find the AppData\Local\MyAppName has been solved by log4net.Util.PatternString class. It parses a special %envFolderPath and %appdomain patterns. The second problem, to configure ConsoleAppender just in DEBUG mode has several solutions. It is possible to load different configs, or to configure ConsoleAppender programatically. I have decided to create own DebugFilter, which denies all log in production mode. This way I have just one log4net config file. The cons is that it is very slightly less efficient to have configured an Appender which denies all log, but it's OK for most of applications.

<log4net>
  <appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
    <file type="log4net.Util.PatternString" value="%envFolderPath{LocalApplicationData}\%appdomain\log.txt" />
    <appendToFile value="true" />
    <maxSizeRollBackups value="2" />
    <maximumFileSize value="10MB" />
    <rollingStyle value="Size" />
    <staticLogFileName value="true" />
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%date [%thread] %-5level %logger - %message%newline" />
    </layout>
  </appender>
  <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%date [%thread] %-5level %logger - %message%newline" />
    </layout>
    <filter type="cvtBackend.Logging.DebugFilter" />
  </appender>
  <!-- Setup the root category, add the appenders and set the default level -->
  <root>
    <level value="INFO" />
    <appender-ref ref="RollingLogFileAppender" />
    <appender-ref ref="ConsoleAppender" />
  </root>
</log4net>

And the DebugFilter:

    /// 

    /// log4net filter which allows logging in DEBUG mode only.
    /// 
    public class DebugFilter : FilterSkeleton
    {
        public override FilterDecision Decide(LoggingEvent loggingEvent)
        {
#if DEBUG
            return FilterDecision.Neutral;
#else
            return FilterDecision.Deny;
#endif
        }
    }