update sample

.travis.yml

+language: csharp
+sudo: required
+dist: trusty
+mono: none
+dotnet: 1.0.0
+
+install:
+  - export DOTNET_CLI_TELEMETRY_OPTOUT=1
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then rvm get stable; brew update; brew install openssl; fi
+os:
+  - linux
+  - osx
+osx_image: xcode7.3
+before_script:
+  - chmod a+x ./build.sh
+script:
+  - ./build.sh
+notifications:
+  email: false

CHANGELOG.md

+# Change Log
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+_Nothing yet..._
+
+## [0.7.0] - 2017-06-08
+### Changed
+- SqlServer: Set migration history's table name and schema.
+
+### Fixed
+- Services not being disposed correctly after a job execution. [#4](https://github.com/mrahhal/MR.AspNetCore.Jobs/issues/4)
+
+## [0.6.0] - 2017-04-22
+### Changed
+- SqlServer: Move to using EFCore to manage internal migrations and connections to the database.
+
+[Unreleased]: https://github.com/mrahhal/MR.AspNetCore.Jobs/compare/0.7.0...HEAD
+[0.7.0]: https://github.com/mrahhal/MR.AspNetCore.Jobs/compare/0.6.0...0.7.0
+[0.6.0]: https://github.com/mrahhal/MR.AspNetCore.Jobs/compare/0.5.0...0.6.0

appveyor.yml

+version: '{build}'
+os: Visual Studio 2015
+environment:
+  BUILDING_ON_PLATFORM: win
+  BuildEnvironment: appveyor
+  Jobs_SqlServer_ConnectionStringTemplate: Server=.\SQL2012SP1;Database={0};User ID=sa;Password=Password12!
+services:
+  - mssql2012sp1
+build_script:
+- ps: ./ConfigureMSDTC.ps1
+- ps: ./build.ps1
+test: off
+artifacts:
+- path: artifacts/packages/*.nupkg
+deploy:
+  provider: NuGet
+  on:
+    appveyor_repo_tag: true
+  api_key:
+    secure: PWCeOQ12fgAhPiBjgkBAqHbvaPQArarsO2sI+8KCeXjBjE+AHaMIMW8b7efmDzQ6
+  skip_symbols: true
+  artifact: /artifacts\/packages\/.+\.nupkg/

build.cake

+#addin "nuget:https://www.nuget.org/api/v2?package=Newtonsoft.Json&version=9.0.1"
+
+#load "./build/index.cake"
+
+var target = Argument("target", "Default");
+
+var build = BuildParameters.Create(Context);
+var util = new Util(Context, build);
+
+Task("Clean")
+	.Does(() =>
+{
+	if (DirectoryExists("./artifacts"))
+	{
+		DeleteDirectory("./artifacts", true);
+	}
+});
+
+Task("Restore")
+	.IsDependentOn("Clean")
+	.Does(() =>
+{
+	var settings = new DotNetCoreRestoreSettings
+	{
+		ArgumentCustomization = args =>
+		{
+			args.Append($"/p:VersionSuffix={build.Version.Suffix}");
+			return args;
+		}
+	};
+	DotNetCoreRestore(settings);
+});
+
+Task("Build")
+	.IsDependentOn("Restore")
+	.Does(() =>
+{
+	var settings = new DotNetCoreBuildSettings
+	{
+		Configuration = build.Configuration,
+		VersionSuffix = build.Version.Suffix,
+		ArgumentCustomization = args =>
+		{
+			args.Append($"/p:InformationalVersion={build.Version.VersionWithSuffix()}");
+			return args;
+		}
+	};
+	foreach (var project in build.ProjectFiles)
+	{
+		DotNetCoreBuild(project.FullPath, settings);
+	}
+});
+
+Task("Test")
+	.IsDependentOn("Build")
+	.Does(() =>
+{
+	foreach (var testProject in build.TestProjectFiles)
+	{
+		DotNetCoreTest(testProject.FullPath);
+	}
+});
+
+Task("Pack")
+	.Does(() =>
+{
+	var settings = new DotNetCorePackSettings
+	{
+		Configuration = build.Configuration,
+		VersionSuffix = build.Version.Suffix,
+		OutputDirectory = "./artifacts/packages"
+	};
+	foreach (var project in build.ProjectFiles)
+	{
+		DotNetCorePack(project.FullPath, settings);
+	}
+});
+
+Task("Default")
+	.IsDependentOn("Build")
+	.IsDependentOn("Test")
+	.IsDependentOn("Pack")
+	.Does(() =>
+{
+	util.PrintInfo();
+});
+
+Task("Version")
+	.Does(() =>
+{
+	Information($"{build.FullVersion()}");
+});
+
+Task("Print")
+	.Does(() =>
+{
+	util.PrintInfo();
+});
+
+RunTarget(target);

build.ps1

+<#
+
+.SYNOPSIS
+This is a Powershell script to bootstrap a Cake build.
+
+.DESCRIPTION
+This Powershell script will download NuGet if missing, restore NuGet tools (including Cake)
+and execute your Cake build script with the parameters you provide.
+
+.PARAMETER Script
+The build script to execute.
+.PARAMETER Target
+The build script target to run.
+.PARAMETER Configuration
+The build configuration to use.
+.PARAMETER Verbosity
+Specifies the amount of information to be displayed.
+.PARAMETER Experimental
+Tells Cake to use the latest Roslyn release.
+.PARAMETER WhatIf
+Performs a dry run of the build script.
+No tasks will be executed.
+.PARAMETER Mono
+Tells Cake to use the Mono scripting engine.
+.PARAMETER SkipToolPackageRestore
+Skips restoring of packages.
+.PARAMETER ScriptArgs
+Remaining arguments are added here.
+
+.LINK
+http://cakebuild.net
+
+#>
+
+[CmdletBinding()]
+Param(
+    [string]$Script = "build.cake",
+    [string]$Target = "Default",
+    [ValidateSet("Release", "Debug")]
+    [string]$Configuration = "Debug",
+    [ValidateSet("Quiet", "Minimal", "Normal", "Verbose", "Diagnostic")]
+    [string]$Verbosity = "Normal",
+    [switch]$Experimental = $true,
+    [Alias("DryRun","Noop")]
+    [switch]$WhatIf,
+    [switch]$Mono,
+    [switch]$SkipToolPackageRestore,
+    [Parameter(Position=0,Mandatory=$false,ValueFromRemainingArguments=$true)]
+    [string[]]$ScriptArgs
+)
+
+[Reflection.Assembly]::LoadWithPartialName("System.Security") | Out-Null
+function MD5HashFile([string] $filePath)
+{
+    if ([string]::IsNullOrEmpty($filePath) -or !(Test-Path $filePath -PathType Leaf))
+    {
+        return $null
+    }
+
+    [System.IO.Stream] $file = $null;
+    [System.Security.Cryptography.MD5] $md5 = $null;
+    try
+    {
+        $md5 = [System.Security.Cryptography.MD5]::Create()
+        $file = [System.IO.File]::OpenRead($filePath)
+        return [System.BitConverter]::ToString($md5.ComputeHash($file))
+    }
+    finally
+    {
+        if ($file -ne $null)
+        {
+            $file.Dispose()
+        }
+    }
+}
+
+Write-Host "Preparing to run build script..."
+
+if(!$PSScriptRoot){
+    $PSScriptRoot = Split-Path $MyInvocation.MyCommand.Path -Parent
+}
+
+$TOOLS_DIR = Join-Path $PSScriptRoot "tools"
+$NUGET_EXE = Join-Path $TOOLS_DIR "nuget.exe"
+$CAKE_EXE = Join-Path $TOOLS_DIR "Cake/Cake.exe"
+$NUGET_URL = "https://dist.nuget.org/win-x86-commandline/latest/nuget.exe"
+$PACKAGES_CONFIG = Join-Path $TOOLS_DIR "packages.config"
+$PACKAGES_CONFIG_MD5 = Join-Path $TOOLS_DIR "packages.config.md5sum"
+
+# Should we use mono?
+$UseMono = "";
+if($Mono.IsPresent) {
+    Write-Verbose -Message "Using the Mono based scripting engine."
+    $UseMono = "-mono"
+}
+
+# Should we use the new Roslyn?
+$UseExperimental = "";
+if($Experimental.IsPresent -and !($Mono.IsPresent)) {
+    Write-Verbose -Message "Using experimental version of Roslyn."
+    $UseExperimental = "-experimental"
+}
+
+# Is this a dry run?
+$UseDryRun = "";
+if($WhatIf.IsPresent) {
+    $UseDryRun = "-dryrun"
+}
+
+# Make sure tools folder exists
+if ((Test-Path $PSScriptRoot) -and !(Test-Path $TOOLS_DIR)) {
+    Write-Verbose -Message "Creating tools directory..."
+    New-Item -Path $TOOLS_DIR -Type directory | out-null
+}
+
+# Make sure that packages.config exist.
+if (!(Test-Path $PACKAGES_CONFIG)) {
+    Write-Verbose -Message "Downloading packages.config..."
+    try { (New-Object System.Net.WebClient).DownloadFile("http://cakebuild.net/download/bootstrapper/packages", $PACKAGES_CONFIG) } catch {
+        Throw "Could not download packages.config."
+    }
+}
+
+# Try find NuGet.exe in path if not exists
+if (!(Test-Path $NUGET_EXE)) {
+    Write-Verbose -Message "Trying to find nuget.exe in PATH..."
+    $existingPaths = $Env:Path -Split ';' | Where-Object { (![string]::IsNullOrEmpty($_)) -and (Test-Path $_) }
+    $NUGET_EXE_IN_PATH = Get-ChildItem -Path $existingPaths -Filter "nuget.exe" | Select -First 1
+    if ($NUGET_EXE_IN_PATH -ne $null -and (Test-Path $NUGET_EXE_IN_PATH.FullName)) {
+        Write-Verbose -Message "Found in PATH at $($NUGET_EXE_IN_PATH.FullName)."
+        $NUGET_EXE = $NUGET_EXE_IN_PATH.FullName
+    }
+}
+
+# Try download NuGet.exe if not exists
+if (!(Test-Path $NUGET_EXE)) {
+    Write-Verbose -Message "Downloading NuGet.exe..."
+    try {
+        (New-Object System.Net.WebClient).DownloadFile($NUGET_URL, $NUGET_EXE)
+    } catch {
+        Throw "Could not download NuGet.exe."
+    }
+}
+
+# Save nuget.exe path to environment to be available to child processed
+$ENV:NUGET_EXE = $NUGET_EXE
+
+# Restore tools from NuGet?
+if(-Not $SkipToolPackageRestore.IsPresent) {
+    Push-Location
+    Set-Location $TOOLS_DIR
+
+    # Check for changes in packages.config and remove installed tools if true.
+    [string] $md5Hash = MD5HashFile($PACKAGES_CONFIG)
+    if((!(Test-Path $PACKAGES_CONFIG_MD5)) -Or
+      ($md5Hash -ne (Get-Content $PACKAGES_CONFIG_MD5 ))) {
+        Write-Verbose -Message "Missing or changed package.config hash..."
+        Remove-Item * -Recurse -Exclude packages.config,nuget.exe
+    }
+
+    Write-Verbose -Message "Restoring tools from NuGet..."
+    $NuGetOutput = Invoke-Expression "&`"$NUGET_EXE`" install -ExcludeVersion -OutputDirectory `"$TOOLS_DIR`""
+
+    if ($LASTEXITCODE -ne 0) {
+        Throw "An error occured while restoring NuGet tools."
+    }
+    else
+    {
+        $md5Hash | Out-File $PACKAGES_CONFIG_MD5 -Encoding "ASCII"
+    }
+    Write-Verbose -Message ($NuGetOutput | out-string)
+    Pop-Location
+}
+
+# Make sure that Cake has been installed.
+if (!(Test-Path $CAKE_EXE)) {
+    Throw "Could not find Cake.exe at $CAKE_EXE"
+}
+
+# Start Cake
+Write-Host "Running build script..."
+Invoke-Expression "& `"$CAKE_EXE`" `"$Script`" -target=`"$Target`" -configuration=`"$Configuration`" -verbosity=`"$Verbosity`" $UseMono $UseDryRun $UseExperimental $ScriptArgs"
+exit $LASTEXITCODE

build.sh

+dotnet --info
+dotnet restore
+dotnet test test/Cap.Consistency.EntityFrameworkCore.Test/Cap.Consistency.EntityFrameworkCore.Test.csproj -f netcoreapp1.1
+dotnet test test/Cap.Consistency.Test/Cap.Consistency.Test.csproj -f netcoreapp1.1
\ No newline at end of file

build/common.props

+<Project>
+
+	<Import Project="version.props" />
+
+	<PropertyGroup Label="Build">
+		<TargetFrameworks>netstandard1.6</TargetFrameworks>
+	</PropertyGroup>
+
+	<PropertyGroup Label="Package">
+		<Product>Cap</Product>
+		<Authors>Savorboard</Authors>
+		<PackageProjectUrl>https://github.com/ouraspnet/cap</PackageProjectUrl>
+		<PackageLicenseUrl>https://github.com/ouraspnet/cap/blob/master/LICENSE</PackageLicenseUrl>
+	</PropertyGroup>
+
+</Project>

build/index.cake

+#load "./util.cake"
+#load "./version.cake"

build/util.cake

+public class Util
+{
+	public Util(ICakeContext context, BuildParameters build)
+	{
+		Context = context;
+		Build = build;
+	}
+
+	public ICakeContext Context { get; set; }
+	public BuildParameters Build { get; set; }
+
+	public void PrintInfo()
+	{
+		Context.Information($@"
+Version:       {Build.FullVersion()}
+Configuration: {Build.Configuration}
+");
+	}
+
+	public static string CreateStamp()
+	{
+		var seconds = (long)(DateTime.UtcNow - new DateTime(2017, 1, 1)).TotalSeconds;
+		return seconds.ToString().PadLeft(11, (char)'0');
+	}
+}

build/version.cake

+using System.Xml;
+
+public class BuildParameters
+{
+	public BuildParameters(ICakeContext context)
+	{
+		Context = context;
+	}
+
+	public ICakeContext Context { get; }
+	public BuildVersion Version { get; private set; }
+	public string Configuration { get; private set; }
+	public bool IsTagged { get; private set; }
+	public bool IsCI { get; private set; }
+	public DirectoryPathCollection Projects { get; set; }
+	public DirectoryPathCollection TestProjects { get; set; }
+	public FilePathCollection ProjectFiles { get; set; }
+	public FilePathCollection TestProjectFiles { get; set; }
+
+	public static BuildParameters Create(ICakeContext context)
+	{
+		var buildParameters = new BuildParameters(context);
+		buildParameters.Initialize();
+		return buildParameters;
+	}
+
+	public string FullVersion()
+	{
+		return Version.VersionWithSuffix();
+	}
+
+	private void Initialize()
+	{
+		InitializeCore();
+		InitializeVersion();
+	}
+
+	private void InitializeCore()
+	{
+		Projects = Context.GetDirectories("./src/*");
+		TestProjects = Context.GetDirectories("./test/*");
+		ProjectFiles = Context.GetFiles("./src/*/*.csproj");
+		TestProjectFiles = Context.GetFiles("./test/*/*.csproj");
+
+		var buildSystem = Context.BuildSystem();
+		if (!buildSystem.IsLocalBuild)
+		{
+			IsCI = true;
+			if ((buildSystem.IsRunningOnAppVeyor && buildSystem.AppVeyor.Environment.Repository.Tag.IsTag) ||
+				(buildSystem.IsRunningOnTravisCI && string.IsNullOrWhiteSpace(buildSystem.TravisCI.Environment.Build.Tag)))
+			{
+				IsTagged = true;
+			}
+		}
+
+		Configuration = Context.Argument("Configuration", "Debug");
+		if (IsCI)
+		{
+			Configuration = "Release";
+		}
+	}
+
+	private void InitializeVersion()
+	{
+		var versionFile = Context.File("./build/version.props");
+		var content = System.IO.File.ReadAllText(versionFile.Path.FullPath);
+
+		XmlDocument doc = new XmlDocument();
+		doc.LoadXml(content);
+
+		var versionMajor = doc.DocumentElement.SelectSingleNode("/Project/PropertyGroup/VersionMajor").InnerText;
+		var versionMinor = doc.DocumentElement.SelectSingleNode("/Project/PropertyGroup/VersionMinor").InnerText;
+		var versionPatch = doc.DocumentElement.SelectSingleNode("/Project/PropertyGroup/VersionPatch").InnerText;
+		var versionQuality = doc.DocumentElement.SelectSingleNode("/Project/PropertyGroup/VersionQuality").InnerText;
+		versionQuality = string.IsNullOrWhiteSpace(versionQuality) ? null : versionQuality;
+
+		var suffix = versionQuality;
+		if (!IsTagged)
+		{
+			suffix += (IsCI ? "ci-" : "dv-") + Util.CreateStamp();
+		}
+		suffix = string.IsNullOrWhiteSpace(suffix) ? null : suffix;
+
+		Version =
+			new BuildVersion(int.Parse(versionMajor), int.Parse(versionMinor), int.Parse(versionPatch), versionQuality);
+		Version.Suffix = suffix;
+	}
+}
+
+public class BuildVersion
+{
+	public BuildVersion(int major, int minor, int patch, string quality)
+	{
+		Major = major;
+		Minor = minor;
+		Patch = patch;
+		Quality = quality;
+	}
+
+	public int Major { get; set; }
+	public int Minor { get; set; }
+	public int Patch { get; set; }
+	public string Quality { get; set; }
+	public string Suffix { get; set; }
+
+	public string VersionWithoutQuality()
+	{
+		return $"{Major}.{Minor}.{Patch}";
+	}
+
+	public string Version()
+	{
+		return VersionWithoutQuality() + (Quality == null ? string.Empty : $"-{Quality}");
+	}
+
+	public string VersionWithSuffix()
+	{
+		return Version() + (Suffix == null ? string.Empty : $"-{Suffix}");
+	}
+}

build/version.props

+<Project>
+	<PropertyGroup>
+		<VersionMajor>0</VersionMajor>
+		<VersionMinor>7</VersionMinor>
+		<VersionPatch>2</VersionPatch>
+		<VersionQuality></VersionQuality>
+		<VersionPrefix>$(VersionMajor).$(VersionMinor).$(VersionPatch)</VersionPrefix>
+	</PropertyGroup>
+</Project>

samples/Sample.Kafka/AppDbContext.cs

@@ -10,6 +10,16 @@ namespace Sample.Kafka
 {
     public class AppDbContext : DbContext
     {
+
+        public AppDbContext(DbContextOptions options) : base(options) {
+        }
+
         public DbSet<ConsistencyMessage> Messages { get; set; }
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
+            //optionsBuilder.UseSqlServer
+            base.OnConfiguring(optionsBuilder);
+        }
+
     }
 }

samples/Sample.Kafka/Controllers/ValuesController.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Cap.Consistency.Consumer;
+using Cap.Consistency.Infrastructure;
 using Cap.Consistency.Kafka;
 using Cap.Consistency.Producer;
 using Microsoft.AspNetCore.Mvc;
@@ -13,13 +14,25 @@ namespace Sample.Kafka.Controllers
     public class ValuesController : Controller, IConsumerService
     {
         private readonly IProducerClient _producer;
+        private readonly AppDbContext _dbContext;
 
-        public ValuesController(IProducerClient producer) {
+        public ValuesController(IProducerClient producer, AppDbContext dbContext) {
             _producer = producer;
+            _dbContext = dbContext;
         }
 
         [Route("/")]
         public IActionResult Index() {
+
+            _dbContext.Add(new ConsistencyMessage {
+                Id = Guid.NewGuid().ToString(),
+                SendTime = DateTime.Now,
+                Payload = "testdata",
+                UpdateTime = DateTime.Now
+            });
+
+            _dbContext.SaveChanges();
+
             return Ok();
         }
 

samples/Sample.Kafka/Migrations/20170616102520_InitMessages.Designer.cs

+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Sample.Kafka;
+using Cap.Consistency.Infrastructure;
+
+namespace Sample.Kafka.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20170616102520_InitMessages")]
+    partial class InitMessages
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+            modelBuilder
+                .HasAnnotation("ProductVersion", "1.1.2")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("Cap.Consistency.Infrastructure.ConsistencyMessage", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Payload");
+
+                    b.Property<DateTime>("SendTime");
+
+                    b.Property<int>("Status");
+
+                    b.Property<DateTime?>("UpdateTime");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Messages");
+                });
+        }
+    }
+}

samples/Sample.Kafka/Migrations/20170616102520_InitMessages.cs

+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Sample.Kafka.Migrations
+{
+    public partial class InitMessages : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Messages",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    Payload = table.Column<string>(nullable: true),
+                    SendTime = table.Column<DateTime>(nullable: false),
+                    Status = table.Column<int>(nullable: false),
+                    UpdateTime = table.Column<DateTime>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Messages", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Messages");
+        }
+    }
+}

samples/Sample.Kafka/Migrations/AppDbContextModelSnapshot.cs

+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Sample.Kafka;
+using Cap.Consistency.Infrastructure;
+
+namespace Sample.Kafka.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    partial class AppDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+            modelBuilder
+                .HasAnnotation("ProductVersion", "1.1.2")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("Cap.Consistency.Infrastructure.ConsistencyMessage", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Payload");
+
+                    b.Property<DateTime>("SendTime");
+
+                    b.Property<int>("Status");
+
+                    b.Property<DateTime?>("UpdateTime");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Messages");
+                });
+        }
+    }
+}

samples/Sample.Kafka/Sample.Kafka.csproj

@@ -12,11 +12,14 @@
     <PackageReference Include="Microsoft.AspNetCore" Version="1.1.2" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="1.1.3" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="1.1.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="1.1.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="1.1.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer.Design" Version="1.1.2" />
     <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="1.1.2" />
   </ItemGroup>
   <ItemGroup>
     <DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="1.0.1" />
+    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="1.0.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\src\Cap.Consistency.EntityFrameworkCore\Cap.Consistency.EntityFrameworkCore.csproj" />

samples/Sample.Kafka/Startup.cs

@@ -28,7 +28,9 @@ namespace Sample.Kafka
         // This method gets called by the runtime. Use this method to add services to the container.
         public void ConfigureServices(IServiceCollection services) {
 
-            services.AddDbContext<AppDbContext>();
+            services.AddDbContext<AppDbContext>(x => {
+                x.UseSqlServer(Configuration["ConnectionString"]);
+            });
 
             services.AddConsistency()
                     .AddEntityFrameworkStores<AppDbContext>()

samples/Sample.Kafka/appsettings.json

 {
+  "ConnectionString": "Server=192.168.2.206;Initial Catalog=AspNetCoreSpa;User Id=cmswuliu;Password=h7xY81agBn*Veiu3;MultipleActiveResultSets=True",
   "Logging": {
     "IncludeScopes": false,
     "LogLevel": {