Digging My Blog With CheeseSalt

Type argument Microsoft.Runtime.CompilerServices.ConfiguredTaskAwaitable violates the constraint of type parameter TAwaiter

Thu, 19 Mar 2015 13:52:00 +0000

You add a reference to StackExchange.Redis in your .NET 4.0 project and you get the following exception:

Method 
System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[System.Boolean].AwaitUnsafeOnCompleted: 
type argument 
'Microsoft.Runtime.CompilerServices.ConfiguredTaskAwaitable`1+ConfiguredTaskAwaiter[StackExchange.Redis.ServerEndPoint]' 
violates the constraint of type parameter 'TAwaiter'.

The solution can be found here:

http://blog.marcgravell.com/2014/03/so-i-went-and-wrote-another-redis-client.html?showComment=1405397410965#c8649668071319126908

Try running Update-Package Microsoft.Bcl

Reference foo.dll could not be resolved because indirect dependency on System.Runtime 1.5.11.0

Thu, 19 Mar 2015 13:41:00 +0000

After adding a reference (via Nuget or a direct reference) to another library from your .NET 4.0 project you get an exception similar to the following:

The primary reference “foo.dll” could not be resolved because it has an indirect 
dependency on the framework assembly “System.Runtime, Version=1.5.11.0, 
Culture=neutral, PublicKey Token=b03f5f7f11d50a3a” which could not be resolved 
in the currently targeted framework. “.NETFramework, Version=v4.0”. To resolve 
this problem, either remove the reference “XYZ.dll” or retarget your application 
to a framework version which contains “System.Runtime, Version=1.5.11.0, 
Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a”

The library you are referencing has a dependency on Microsoft.Bcl.Async, probably because it using Async and Await. The async functionality is baked into .NET 4.5 but is available in 4.0 if you use Microsoft.Bcl.Async.

While researching the error you’ll see a lot of instructions for adding assembly binding redirects. You may also try referencing the System.Runtime.dll that came with your dependency. Those may only fix part of the problem. I did plenty of searching and finally found the full solution here:

http://stackoverflow.com/questions/15551953/how-to-use-the-microsoft-bcl-async-right

There is a known issue that causes MSBuild to think that the referencing library has taken a dependency on an assembly from a newer framework version. There is a fix included in Microsoft.Bcl.Build. The solutions is to simply install the Microsoft.Bcl.Async package directly into your project, it will include Microsoft.Bcl.Build.

In my case I was referencing a library that referenced a library that used Microsoft.Bcl.Async. The library that I referenced included references to the Microsoft.Bcl dlls but I had to add them to my project as well.

Setting Environment Variables on Mac OS X

Wed, 23 Jul 2014 19:47:00 +0000

This is the way I do it and I’m storing the info here because I’ve already looked it up on 3 different occasions.

I store them in my bash profile. To edit that file simply use the following in the terminal:

subl ~/.bash_profile

I use Sublime text editor. You can substitute nano or vm or the command for your preferred editor of choice.

You’ll see stuff like: export SOME_ENVIRONMENT_VARIABLE=”foo”, add whatever you need to add.

After you’ve made your changes you’ll probably want those changes to affect the terminal window you are currently working in. To do that type:

source ~/.bash_profile

Done.

Node to Microsoft SharePoint / Project Online via Edge.js

Tue, 22 Jul 2014 20:45:00 +0000

At LeanKit we’re always creating new integrations with other software and sites. Most of them involve reading from a 3rd party application’s web service API (Microsoft’s TFS via VisualStudio.com, JIRA, GitHub issues and more), performing some type of translation and mapping of the data, and then writing to LeanKit’s web service API to manipulate (add, update, remove) cards on a board. Some integrations also read from LeanKit and write to the target application to provide 2-way syncing of data.

Cards on a LeanKit board that were imported from Microsoft’s Project Online by a node application using Edge.js
to communicate with Microsoft Projects CSOM API dlls.

Recently we have been working with Node.js to offer a “run anywhere” option for our integration services. Using Node has been great when communicating with most web service APIs, especially those that are REST-based but even those that are SOAP-based are not too horrible. But in cases where I am forced to consume WCF web services I’d much rather use a client-side API if one is available. Working with Microsoft Project Server 2013 and specifically Project Online in addition to SharePoint because Project Server is built on SharePoint is one of those cases. SharePoint and Project Server have a CSOM (Client Side Object Model) API that works pretty well. However, the problem for our scenario is those APIs are a pair of .NET dlls which do not compute in our Node environment. Yes, I know there is a SharePoint/Project JSOM (Javascript Object Model) API that might work in our scenario but in my limited experience with it I found it to be… well… to use a technical term: “weird”… and I did not care for it.

We want to get tasks from a project hosted on Microsoft Project Online. We have a lot of Javascript code written for Node for handling that data once we get it. We have .NET dlls that provide an API for working with Microsoft Project Online. So how can we tie the two together? How can our Node application communicate with a .NET library?

Well we could create a web service interface to act as a facade for communicating with the library and consume that in our Node application. That’s a decent option and one we considered. Instead we decided to take a look at Edge.js.

Enter Stage Left: Edge.js

What is Edge.js? Pure .NET & Node awesomeness. According to the introduction: Edge.js connects Node.js and .NET ecosystems … on Windows, MacOS, and Linux in one process.

I first learned about Node.js from my super smart friend and co-worker
David Neal: How to leverage SQL Server with Node.js using Edge.js

In layman’s terms: Edge.js allows you to run .NET code in the Node process. Yes, .NET code inside Node! It obviously works on Windows but will also work on MacOS and Linux using Mono as long as the underlying .NET code you are using will run on Mono. In our case the CSOM library we are using will only work on Windows.

Other than my brief explanation above and the examples below I will not provide detailed information about Edge.js, both David’s article and the Edge.js documentation offer plenty of introduction material, quick-start examples, etc. I’ll assume that since you are reading this that you either have some experience with Node or at least some interest so I will not provide details for installing Node or setting up your Node environment, NPM (Node Package Manager), etc.

Wrap that Wrapper

I don’t need to expose everything that the CSOM API can do to my Node application. I only need to perform a few operations like getting a list of projects and getting a list of tasks for a project. In real life I need to do a few other things like attempt to authenticate a user, add a task, update a task, get a list of team members and more but getting projects and tasks should work well for this demo. To simplify code navigation, readability and testing we’ll create a class, ProjectServerClient, to serve as a wrapper to the CSOM API that will only provide the functionality we need. getting projects and tasks. If you have worked with the SharePoint/Project CSOM before then the below code will look somewhat familiar. I fully admit to not being a SharePoint developer so there may be much better ways to do what I’ve done in the example code. Feel free to offer helpful insight, tips and suggestions.

Some things to keep in mind:

Your .NET project’s platform version must be .NET 4.5 or higher because you need Async/Await support for working with Edge.js.
You will need to install the Microsoft Office SharePoint Server 2013 Client Components SDK on your dev box as well as on any machine where this code will run.
You will also need to reference the Micorosoft.ProjectServer.Client dll which you can get from the Project 2013 SDK.
You may also need to enable/install Windows Identity Foundation.
This example uses the SharePointOnlineCredentials to communicate with Project Online (Office 365). If communicating with an on-premise (or other-hosted) installation of Microsoft Project Server you can use NetworkCredentials to authenticate.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using Microsoft.ProjectServer.Client;

using Microsoft.SharePoint.Client;

namespace leankit.integration.client.microsoft.projectserver

{

    public class ProjectServerAuth

    {

        public string Url { get; set; }

        public string Username { get; set; }

        public string Password { get; set; }

    }

    public class ProjectServerClient

    {       

        public static List<Project> GetProjects(ProjectServerAuth auth)

        {

            var projects = new List<Project>();

            using (ProjectContext projContext = new ProjectContext(auth.Url))

            {

                projContext.Credentials = new SharePointOnlineCredentials(auth.Username, auth.Password.ToSecureString());

                projContext.Load(projContext.Web);

                projContext.ExecuteQuery();

                var publishedProjects = projContext.LoadQuery(projContext.Projects);

                projContext.ExecuteQuery();

                foreach (PublishedProject pubProj in publishedProjects)

                {                   

                    projects.Add(MapToProject(pubProj));                    

                }

            }

            return projects;

        }

        public static List<Item> GetTasks(ProjectServerAuth auth, Guid projectId)

        {

            var items = new List<Item>();

            using (ProjectContext projContext = new ProjectContext(auth.Url)) 

            {

                projContext.Credentials = new SharePointOnlineCredentials(auth.Username, auth.Password.ToSecureString());

                projContext.Load(projContext.Web);

                projContext.ExecuteQuery();

                var projects = projContext.LoadQuery(projContext.Projects);

                projContext.ExecuteQuery();

                var project = projects.FirstOrDefault(x => x.Id == projectId);

                if (project != null) 

                {

                    var ts = project.Tasks;

                    projContext.Load(ts);

                    projContext.ExecuteQuery();

                    var tasks =

                        projContext.LoadQuery(

                            ts.IncludeWithDefaultProperties(task =>

                                task.Assignments.IncludeWithDefaultProperties(assignment => assignment.Resource))

                            .Where(t => t.IsActive)));

                    projContext.ExecuteQuery();

                    foreach (var task in tasks)

                    {

                        items.Add(MapToItem(task));

                    }

                }

            }

            return items;

        }      

    }

}

Now that we have a simpler .NET library to work with it needs to have an interface that Edge.js understands. We could convert all of our methods to Async/Await but I will leave them as-is for code reuse purposes and instead create a wrapper for the wrapper, EdgeProjectServerClient.

using System;

using System.Collections.Generic;

using System.Dynamic;

using System.Threading.Tasks;

namespace integration.client.projectserver 

{

    public class EdgeProjectServerClient     

    {

        public async Task<object> GetProjects(IDictionary<string, object> input)

        {

            var auth = new ProjectServerAuth();

            ExpandoMapper<ProjectServerAuth>.Map((ExpandoObject)input["auth"], auth);

            return await Task.Run(() => ProjectServerClient.GetProjects(auth));

        }

        public async Task<object> GetTasks(IDictionary<string, object> input)

        {

            var auth = new ProjectServerAuth();

            ExpandoMapper<ProjectServerAuth>.Map((ExpandoObject)input["auth"], auth);

            var projectId = Guid.Parse(input["projectId"].ToString());

            return await Task.Run(() => ProjectServerClient.GetTasks(auth, projectId));

        }

    }

}

Now we have a couple of methods with signatures that Edge.js can understand. Next we’ll add code to our Node.js app to call into this .NET library.

Node + Edge > Node

Let’s create a module that acts as a client library for talking to our .NET code via Edge.js and call it client.js. Our module will simply expose a couple of methods: getProjects and getTasks, which map to the similarly named methods in our .NET library.

var edge = require("edge"),

    path = require("path"), 

    dllpath = path.join(".", 'dlls');

var Client = function(url, user, password) {

    var auth = { 

            "url": url, 

            "username": user, 

            "password": password 

        };

    var getProjectsMethod = edge.func({

        assemblyFile: path.join( dllpath, 'integration.client.projectserver.dll'),

        typeName: 'integration.client.projectserver.EdgeProjectServerClient',

        methodName: 'GetProjects'

    });

    var getTasksMethod = edge.func({

        assemblyFile: path.join( dllpath, 'integration.client.projectserver.dll'),

        typeName: 'integration.client.projectserver.EdgeProjectServerClient',

        methodName: 'GetTasks'

    });    

    var getProjects = function(callback) {

        var data = { 

            auth: auth

        };

        getProjectsMethod(data, function(err, res) {

            if (err || !res){

                err = err || 'unknown error';

                console.log("err=" + err + ", res=" + res);

                callback(err, null);

            }

            else {

                callback(err, res);

            }

        });        

    };

    var getTasks = function(projectId, callback) {

        var data = { 

            auth: auth, 

            projectId: projectId

        };

        getTasksMethod(data, function(err, res) {

            if (err || !res){

                err = err || 'unknown error';

                console.log("err=" + err + ", res=" + res);

                callback(err, null);

            } else {

                callback(err, res);

            }

        });

    };    

    return {

        getProjects: getProjects,

        getTasks: getTasks,

    };

};

module.exports = Client;

We simply require the “edge” module and then create a proxy for each .NET method we want to call using Edge’s .func() method, think of it as an anonymous function. The getProjectsMethod and getTasksMethod methods are examples of creating the Node.js proxy to a .NET method by specifying the .NET assembly, class and method name. Later we invoke the .NET methods by invoking the getProjectsMethod and getTasksMethod functions. Note: “dlls” is the name of a folder that is a sibling to the Node src folder. It is where I store the dll for the library that contains the ProjectServerClient and EdgeProjectServerClient classes described above in addition all its dependencies.

Finally we just need to write some code in our index.js file that uses our client module to talk to Project Online. Let’s just get a list of our projects and write the name of each to the console. Assuming we have everything installed and setup properly we only need to start up our Node app and it will print out a list of projects hosted on Project Online.

var Client = require("./client.js");

var client = new Client("https://mysite.sharepoint.com/sites/pwa", "admin", "password");

var projects = client.getProjects(function(err, projects) {

    for(var i = 0; i < projects.length; i++) {

        console.log("Project: " + projects[i].Title);

    }

});

Running this file via the command line with the command “node [Path To File]/index.js” results in the below output which is a list of all my projects on my Project Online site!

Project: Demo Integration

Project: Test Project 1

Project: Test Project 2

Project: Hello World

Building out additional functionality like getting tasks for each project, getting a list of team members, updating a task, etc. is just a matter of continuing down the same path that we have already started together.

Hopefully you’ll find leveraging your .NET code base with Edge.js as useful and interesting as I have. If you have any questions feel free to give me a shout via the comments below or on Twitter: @danhounshell.

Kiatechinfo.com for your Kia maintenance

Wed, 04 Jun 2014 19:55:00 +0000

When you decide that you want to do some work on your beloved Kia yourself but do not own a service manual then head on over to kiatechinfo.com. Simply create an account and look up the procedure for whatever it is you want to do. Amazingly they have an online version of their factory service manuals that looks to me to be 100% complete.

Pro Tips:

In my experience when printing directions for a specific procedure Google Chrome does not render any images or sometimes just the first one. Firefox renders them all fine though.
Read through the full list of instructions before going off to your garage to start getting your hands dirty. It may include one or many lines like “Remove alternator (See section EE: Alternator)”. You will have to browse to the specified section and print those instructions separately.
You may find maintenance instructions for smaller things like changing a belt included in a section titled General, Troubleshooting, Repair, Installation, or something else. Some of the pages will be broken up into sections for Removal and then Installation and finally small maintenance tasks last. Or sometimes those smaller tasks are listed first. It can take a little bit of looking but you will eventually find what you need.
Follow the instructions. Do not think, like I did, “There is no reason for me to loosen those water pump pulley bolts now, I can get to them much easier after the belts are off and all this other stuff around it is removed”. Unfortunately after the belts are off and all the other stuff is removed there is nothing providing tension on the pulley to allow you to loosen the bolts. The instructions are there in a specific order for a reason.

I have used instructions from the Kiatechinfo site to change a CV axle, change the water pump and timing belt, replace the rear hatch (after a small boo-boo) and several other smaller maintenance jobs for my 2005 Kia Spectra5 with just over 100,000 miles on it. It is nice to have a manufacturer support its customers by providing documentation rather than forcing them to purchase factory service manuals or worse buy something from other publishers, like Chilton’s, etc.

Python version 3.x.x is not supported by node-gyp error

Tue, 13 May 2014 14:00:10 +0000

Problem: You try to npm install a node package on Windows and get an error similar to: Python version 3.x.x is not supported by node-gyp

Issue: You have Python 3.x installed and node-gyp needs version 2.7. You may already have 2.7 installed but your PATH var for python is pointing to the new one.

Fix: If you do not already have Python 2.7 installed then do so. Next find the path to that install and do the following: npm config set python C:\Python27\python.exe (using whatever your path to it is). Now you can go back and npm install the original package you were trying to install before getting the error.

Default value must be string or number error when running npm adduser

Tue, 13 May 2014 13:35:00 +0000

Problem: You try to run npm adduser command and get an error message that starts with something like “Default value must be string or number”.

Cause: It is attempting to access your default email address which you do not have set.

Fix: npm config set email youremail@yourdomain.com and then retry npm adduser again

I can hit RabbitMQ fine from local but when I try from remote it does not work

Fri, 25 Apr 2014 13:30:39 +0000

I’ve run into this now a couple of times. The cause may be from the (sometimes) default binding to 127.0.0.1 in the rabbitmq-env.conf file. Update the file, changing the value of NODE_IP_ADDRESS to 0.0.0.0 which will bind it to all IP addresses on the machine. Or you can bind it to just a specific one.

http://superuser.com/questions/464311/open-port-5672-tcp-for-access-to-rabbitmq-on-mac

Where is Dan?

Thu, 18 Jul 2013 03:02:35 +0000

I spread this news on Twitter and Facebook months ago but thought it was about time to do the same thing here. Wednesday, May 1st was my last day as an employee of Telligent. I worked for Telligent for over six years and I loved every minute of it. I worked with some very bright (most of them much smarter than me!), dedicated and hard-working folks. I worked on tough, challenging problems and had a lot of fun as well. With the exception of a few jobs I have spent about 5 years at each of my previous stops. After that amount of time I must start getting restless and maybe a little bored. But it was still very tough to leave Telligent. I can honestly say that at least a few tears were shed, at least by me.

On May 6th I became a member of the dev team at LeanKit. If you have not heard of LeanKit then you will soon. LeanKit is going places – big, big places and I’m just grateful to be along for the ride. I don’t know what I did to deserve to be in the company of such a great team but I am honestly thankful. Much of the thanks goes to my friend David Neal – I trusted that if he was asking me to join then it was something special. “Special” is really the best word to describe the company, the culture, the people, the product, the location… everything. I’m in. I’m all in.

I could go on and on, but if you want to know more about LeanKit, Kanban, what I’m working on, why I love it so much, etc. then give me a shout. You know where to find me.

Outsourcing your Blog engine’s functionality

Thu, 18 Jul 2013 02:38:00 +0000

[NOTE: I wrote this blog post over 2 years ago and recently found it in my Windows Live Writer drafts. I must have saved it to come back later and do some editing but forgot about it. It seems to be fairly up to date so I’m hitting the Publish button. Sorry it is 2 years late ]

I’ve been working on and with Graffiti for quite some time. While Graffiti was a Telligent product I built some custom widgets and themes. After it became an open source project I contributed to the project’s core. But since then my excitement for Graffiti and blog engines in general has waned. Why? Because I don’t need a full-blown blog engine and maybe you don’t either.

To be fair to Graffiti and WordPress, they are great products and provide much more than just blog functionality. And I will still make use of them in many situations. Really they are both now CMS platforms and have a plethora of addons that are continuously rolling out that really extend the products. WordPress won’t die anytime soon, if ever. I’m purely talking about the functionality needed for a blog, specifically for a developer who has the ability to seek out and use other options.

This no-blog option is not for the faint of heart and I’m not saying that you should take this route, but it is something I’m considering. It is definitely not for someone who just wants a simple “push a button now I have a blog” blog. But for someone who is constantly tweaking and experimenting like me it makes sense.

The functionality that we’ve come to expect from a blogging engine has grown over the last 10 years. Blogs began as a Web Log – a collection of simple static web pages. At at some point clever enterprising developers moved the content to data stores, thus the birth of the blog engines. Once we had the content stored in a database we needed some sort of admin control panel to provide for adding, updating and deleting. Then we added comments and pingbacks and trackbacks. Contact forms became a necessity. We added RSS so all our friends will know when we post a new article. Someone decided a good blog engine should have built-in analytics. We began using our blogs to host our kids’ pictures and our recent word docs, resumes and other files so the engines began providing file management and slideshow functionality. And then came the birth of “flare”: my last 6 pics on Flickr, and the 4 videos I liked on YouTube. In the past couple of years we added “follow me on Twitter and here are my last 10 tweets”. Over that same time we also added more and more CMS-like features to our blogs.

However, I’ve noticed a trend to use less of a blogging engine’s functionality. It’s not that we no longer want all the functionality I mentioned above, it’s that we don’t want/expect it to all come from the blog engine itself. In our brave new world of “SOA”, “SAAS” and “Cloud Computing”, buzzword bingo aside, we have come to realize that it is best to focus on core functionality and leave the fringe pieces to someone else who focuses on that as their core functionality. In other words, we are choosing “the best of breed” (for those who have not gotten their fill of catchy buzzy phrases).

Need some examples?

1. Google Analytics – I’ve been using this for so long to track activity on my sites that I cannot even remember when I started.

2. Disqus – I don’t need my blog engine to provide commenting functionality, I’d rather use Disqus. It also handles trackbacks and catching any “social” mentions of your post.

3. Kontactr – I recently switched my home page (a primarily static html/JavaScript page) to use Kontactr to provide a contact form.

4. Twitter, Foursquare, etc. widgets – I can use JavaScript to query most social networks myself rather than depend on a widget provided by my blog platform. You can easily find a JQuery Plugin for nearly anything by doing a simple search.

5. Windows Live Writer – I don’t need my blog engine to provide create/edit post functionality for me. I can do everything I need with Windows Live Writer.

6. Feedburner – handles distribution of my syndication feeds rather nicely.

7. Flickr, YouTube, SlideShare and DropBox – easily handle hosting all my photos, videos, presentations, files, etc.

I am sure both we can think of more examples.

What functionality is missing that still requires a bull-blown blog engine? Content and version management? How about using a combination of Git and DropBox that will handle deploying content updates for you as well as easily handling versioning. What could be better than having a real version control system?

You could get rid of your database by using static files to hold each post’s content. Either use the Git/Dropbox approach or have a WindowsLiveWriter endpoint that would convert sent content to static files.

If you hand off all the above then what do you have left? You really only need some type of routing engine to serve up the static content based on the requested Url and something that wires up the configuration for the 3rd party stuff mentioned above. That does not really sound like much of a blog engine to me, in fact I’d suggest that it could mostly be done with JavaScript and maybe, just maybe, a few lines of server-side code.