right_link 5.9.0

data/lib/chef/windows/ChefNodeCmdlet/ChefNodeCmdlet.sln

@@ -0,0 +1,35 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ChefNodeCmdlet", "ChefNodeCmdlet\ChefNodeCmdlet.csproj", "{F421745A-3ADE-473A-83DE-C7A3DF1B9557}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestChefNodeCmdlet", "TestChefNodeCmdlet\TestChefNodeCmdlet.csproj", "{3691CA56-6927-4789-9102-0841E99B3F16}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F421745A-3ADE-473A-83DE-C7A3DF1B9557} = {F421745A-3ADE-473A-83DE-C7A3DF1B9557}
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestNextActionCmdlet", "TestNextActionCmdlet\TestNextActionCmdlet.csproj", "{9AF14C55-5808-4335-9BAA-74BD8DE5205B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F421745A-3ADE-473A-83DE-C7A3DF1B9557}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F421745A-3ADE-473A-83DE-C7A3DF1B9557}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F421745A-3ADE-473A-83DE-C7A3DF1B9557}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F421745A-3ADE-473A-83DE-C7A3DF1B9557}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3691CA56-6927-4789-9102-0841E99B3F16}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3691CA56-6927-4789-9102-0841E99B3F16}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3691CA56-6927-4789-9102-0841E99B3F16}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3691CA56-6927-4789-9102-0841E99B3F16}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9AF14C55-5808-4335-9BAA-74BD8DE5205B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9AF14C55-5808-4335-9BAA-74BD8DE5205B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9AF14C55-5808-4335-9BAA-74BD8DE5205B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9AF14C55-5808-4335-9BAA-74BD8DE5205B}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

data/lib/chef/windows/ChefNodeCmdlet/TestChefNodeCmdlet/Program.cs

@@ -0,0 +1,374 @@
+/////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2010-2011 RightScale Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+/////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections;
+using System.IO;
+using System.IO.Pipes;
+using RightScale.Chef.Protocol;
+using RightScale.Common.Protocol;
+
+namespace TestChefNodeCmdlet
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            // resolve persistent node path.
+            string nodeFilePath = null;
+
+            if (2 == args.Length && args[0] == "-nf")
+            {
+                nodeFilePath = args[1];
+            }
+            else
+            {
+                Console.WriteLine("Usage: TestChefNodeCmdlet -nf <nodefile>");
+                Console.WriteLine();
+                Console.WriteLine("The nodefile is a JSON text file containing initial values and which receives any modified node values.");
+                return;
+            }
+
+            // load initial node values, if any.
+            string nodeFileText = ReadTextFile(nodeFilePath);
+
+            // use JSON transport to unmarshal initial nodes.
+            ITransport transport = new JsonTransport();
+            IDictionary nodeHash = new Hashtable();
+
+            if (nodeFileText.Length > 0)
+            {
+                nodeHash = (IDictionary)transport.NormalizeDeserializedObject(transport.ConvertStringToObject<object>(nodeFileText));
+            }
+            
+            // current and new resource hashes.
+            IDictionary currentResourceHash = new Hashtable();
+            currentResourceHash.Add("name", "test name");
+
+            IDictionary newResourceHash = new Hashtable(currentResourceHash);
+
+            // create pipe server using JSON as transport.
+            PipeServer pipeServer = new PipeServer(Constants.CHEF_NODE_PIPE_NAME, transport);
+
+            Console.WriteLine("Hit Ctrl+C to stop the server.");
+            for (; ; )
+            {
+                try
+                {
+                    Console.WriteLine("Waiting for client to connect...");
+                    pipeServer.WaitForConnection();
+                    for (; ; )
+                    {
+                        // use duck typing to determine type of request.
+                        IDictionary requestHash = (IDictionary)transport.NormalizeDeserializedObject(pipeServer.Receive<object>());
+
+                        if (null == requestHash)
+                        {
+                            break;
+                        }
+
+                        bool validRequest = false;
+
+                        if (requestHash.Contains(Constants.JSON_COMMAND_KEY))
+                        {
+                            if (requestHash.Contains(Constants.JSON_PATH_KEY) && requestHash.Contains(Constants.JSON_NODE_VALUE_KEY))
+                            {
+                                if (requestHash[Constants.JSON_COMMAND_KEY].ToString() == "SetChefNodeRequest")
+                                {
+                                    SetChefNodeRequest request = new SetChefNodeRequest((ICollection)requestHash[Constants.JSON_PATH_KEY],
+                                                                                        requestHash[Constants.JSON_NODE_VALUE_KEY]);
+                                    Console.WriteLine(String.Format("Received: {0}", request.ToString()));
+
+                                    InsertNodeHash(nodeHash, request.Path, transport.NormalizeDeserializedObject(request.NodeValue));
+
+                                    SetChefNodeResponse response = new SetChefNodeResponse(request.Path);
+                                    Console.WriteLine(String.Format("Responding: {0}", response.ToString()));
+                                    pipeServer.Send(response);
+
+                                    // save change to node file.
+                                    WriteTextFile(nodeFilePath, transport.ConvertObjectToString(nodeHash, true));
+                                    validRequest = true;
+                                }
+                                else if (requestHash[Constants.JSON_COMMAND_KEY].ToString() == "SetCurrentResourceRequest")
+                                {
+                                    SetCurrentResourceRequest request = new SetCurrentResourceRequest((ICollection)requestHash[Constants.JSON_PATH_KEY],
+                                                                                                      requestHash[Constants.JSON_NODE_VALUE_KEY]);
+                                    Console.WriteLine(String.Format("Received: {0}", request.ToString()));
+
+                                    InsertNodeHash(currentResourceHash, request.Path, transport.NormalizeDeserializedObject(request.NodeValue));
+
+                                    SetCurrentResourceResponse response = new SetCurrentResourceResponse();
+                                    Console.WriteLine(String.Format("Responding: {0}", response.ToString()));
+                                    pipeServer.Send(response);
+                                    validRequest = true;
+                                }
+                                else if (requestHash[Constants.JSON_COMMAND_KEY].ToString() == "SetNewResourceRequest")
+                                {
+                                    SetNewResourceRequest request = new SetNewResourceRequest((ICollection)requestHash[Constants.JSON_PATH_KEY],
+                                                                                              requestHash[Constants.JSON_NODE_VALUE_KEY]);
+                                    Console.WriteLine(String.Format("Received: {0}", request.ToString()));
+
+                                    InsertNodeHash(newResourceHash, request.Path, transport.NormalizeDeserializedObject(request.NodeValue));
+
+                                    SetNewResourceResponse response = new SetNewResourceResponse();
+                                    Console.WriteLine(String.Format("Responding: {0}", response.ToString()));
+                                    pipeServer.Send(response);
+                                    validRequest = true;
+                                }
+                            }
+                            else if (requestHash.Contains(Constants.JSON_PATH_KEY))
+                            {
+                                if (requestHash[Constants.JSON_COMMAND_KEY].ToString() == "GetChefNodeRequest")
+                                {
+                                    GetChefNodeRequest request = new GetChefNodeRequest((ICollection)requestHash[Constants.JSON_PATH_KEY]);
+                                    Console.WriteLine(String.Format("Received: {0}", request.ToString()));
+
+                                    object nodeValue = QueryNodeHash(nodeHash, request.Path);
+                                    GetChefNodeResponse response = new GetChefNodeResponse(request.Path, nodeValue);
+
+                                    Console.WriteLine(String.Format("Responding: {0}", response.ToString()));
+                                    pipeServer.Send(response);
+                                    validRequest = true;
+                                }
+                                else if (requestHash[Constants.JSON_COMMAND_KEY].ToString() == "GetCurrentResourceRequest")
+                                {
+                                    GetCurrentResourceRequest request = new GetCurrentResourceRequest((ICollection)requestHash[Constants.JSON_PATH_KEY]);
+                                    Console.WriteLine(String.Format("Received: {0}", request.ToString()));
+
+                                    object nodeValue = QueryNodeHash(currentResourceHash, request.Path);
+                                    GetCurrentResourceResponse response = new GetCurrentResourceResponse(request.Path, nodeValue);
+
+                                    Console.WriteLine(String.Format("Responding: {0}", response.ToString()));
+                                    pipeServer.Send(response);
+                                    validRequest = true;
+                                }
+                                else if (requestHash[Constants.JSON_COMMAND_KEY].ToString() == "GetNewResourceRequest")
+                                {
+                                    GetNewResourceRequest request = new GetNewResourceRequest((ICollection)requestHash[Constants.JSON_PATH_KEY]);
+                                    Console.WriteLine(String.Format("Received: {0}", request.ToString()));
+
+                                    object nodeValue = QueryNodeHash(newResourceHash, request.Path);
+                                    GetNewResourceResponse response = new GetNewResourceResponse(request.Path, nodeValue);
+
+                                    Console.WriteLine(String.Format("Responding: {0}", response.ToString()));
+                                    pipeServer.Send(response);
+                                    validRequest = true;
+                                }
+                            }
+                        }
+                        if (false == validRequest)
+                        {
+                            // unknown request type; hang up and try again.
+                            break;
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    Console.WriteLine(e.Message);
+                }
+                finally
+                {
+                    pipeServer.Close();
+                }
+            }
+        }
+
+        // Summary:
+        //  inserts a node value at the hash depth indicated by path.
+        //
+        // Parameters:
+        //   nodeHash:
+        //      node hash
+        //
+        //   path:
+        //      path into hash where each array element represents a level of hash depth.
+        //
+        //   nodeValue:
+        //      node value to insert.
+        private static void InsertNodeHash(IDictionary nodeHash, string[] path, object nodeValue)
+        {
+            for (int pathIndex = 0, pathCount = path.Length; pathIndex < pathCount; ++pathIndex)
+            {
+                string key = path[pathIndex];
+
+                // insert node value if at end of path.
+                if (pathIndex + 1 == pathCount)
+                {
+                    if (nodeHash.Contains(key))
+                    {
+                        nodeHash.Remove(key);
+                    }
+                    nodeHash.Add(key, nodeValue);
+                }
+                else
+                {
+                    // insert/update a child hash and continue.
+                    IDictionary subHash = null;
+
+                    if (nodeHash.Contains(key))
+                    {
+                        object child = nodeHash[key];
+
+                        if (child is IDictionary)
+                        {
+                            subHash = (IDictionary)child;
+                        }
+                        else
+                        {
+                            nodeHash.Remove(key);
+                        }
+                    }
+                    if (null == subHash)
+                    {
+                        subHash = new Hashtable();
+                        nodeHash.Add(key, subHash);
+                    }
+                    nodeHash = subHash;
+                }
+            }
+        }
+
+        // Summary:
+        //  queries a node value at the hash depth indicated by path.
+        //
+        // Parameters:
+        //   nodeHash:
+        //      node hash
+        //
+        //   path:
+        //      path into hash where each array element represents a level of hash depth.
+        //
+        // Returns:
+        //  node value to insert.
+        private static object QueryNodeHash(IDictionary nodeHash, string[] path)
+        {
+            // special case for querying the root hash.
+            if (1 == path.Length && 0 == path[0].Length)
+            {
+                return nodeHash;
+            }
+            for (int pathIndex = 0, pathCount = path.Length; pathIndex < pathCount; ++pathIndex)
+            {
+                string key = path[pathIndex];
+
+                if (pathIndex + 1 == pathCount)
+                {
+                    return nodeHash.Contains(key) ? nodeHash[key] : null;
+                }
+                if (nodeHash.Contains(key))
+                {
+                    object child = nodeHash[key];
+
+                    if (child is IDictionary)
+                    {
+                        nodeHash = (IDictionary)child;
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            return null;
+        }
+
+        // Summary:
+        //  reads a text file and returns its content as a string.
+        //
+        // Parameters:
+        //   filePath:
+        //      path to text file
+        //
+        // Returns:
+        //  text read from file or empty.
+        public static string ReadTextFile(string filePath)
+        {
+            FileStream fileStream = null;
+            StreamReader streamReader = null;
+
+            try
+            {
+                fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Read);
+                streamReader = new StreamReader(fileStream);
+
+                return streamReader.ReadToEnd();
+            }
+            catch (IOException)
+            {
+                return "";
+            }
+            finally
+            {
+                if (null != streamReader)
+                {
+                    streamReader.Close();
+                    streamReader = null;
+                }
+                if (null != fileStream)
+                {
+                    fileStream.Close();
+                    fileStream = null;
+                }
+            }
+        }
+
+        // Summary:
+        //  writes the text given as a string to the given file.
+        public static void WriteTextFile(string filePath, string text)
+        {
+            StreamWriter streamWriter = null;
+
+            try
+            {
+                string parentDirPath = Path.GetDirectoryName(filePath);
+
+                if (parentDirPath.Length > 0 && false == Directory.Exists(parentDirPath))
+                {
+                    Directory.CreateDirectory(parentDirPath);
+                }
+
+                streamWriter = File.CreateText(filePath);
+                streamWriter.Write(text);
+                streamWriter.Flush();
+            }
+            finally
+            {
+                if (null != streamWriter)
+                {
+                    try
+                    {
+                        streamWriter.Close();
+                    }
+                    catch (Exception)
+                    {
+                    }
+                }
+            }
+        }
+    }
+}

data/lib/chef/windows/ChefNodeCmdlet/TestChefNodeCmdlet/Properties/AssemblyInfo.cs

@@ -0,0 +1,16 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("TestChefNodeCmdlet")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("RightScale")]
+[assembly: AssemblyProduct("TestChefNodeCmdlet")]
+[assembly: AssemblyCopyright("Copyright (c) 2010-2011 RightScale Inc")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: ComVisible(false)]
+[assembly: Guid("779c8da1-7f5d-4d15-a84b-329070ac87f1")]
+[assembly: AssemblyVersion("1.0.0.1")]
+[assembly: AssemblyFileVersion("1.0.0.1")]

data/lib/chef/windows/ChefNodeCmdlet/TestChefNodeCmdlet/TestChefNodeCmdlet.csproj

@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{3691CA56-6927-4789-9102-0841E99B3F16}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>TestChefNodeCmdlet</RootNamespace>
+    <AssemblyName>TestChefNodeCmdlet</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\$(Configuration)</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\$(Configuration)</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ChefNodeCmdlet\ChefNodeCmdlet.csproj">
+      <Project>{F421745A-3ADE-473A-83DE-C7A3DF1B9557}</Project>
+      <Name>ChefNodeCmdlet</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

data/lib/chef/windows/ChefNodeCmdlet/TestNextActionCmdlet/Program.cs

@@ -0,0 +1,136 @@
+/////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2010-2011 RightScale Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+/////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections;
+using System.IO;
+using System.IO.Pipes;
+using RightScale.Chef.Protocol;
+using RightScale.Common.Protocol;
+
+namespace TestNextActionCmdlet
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            // resolve persistent node path.
+            string pipeName = null;
+            string nextActionPath = null;
+
+            if (4 == args.Length && args[0] == "-pn" && args[2] == "-na")
+            {
+                pipeName = args[1];
+                nextActionPath = args[3];
+            }
+            else
+            {
+                Console.WriteLine("Usage: -pn <pipe name> -na <next action file path>");
+                Console.WriteLine();
+                Console.WriteLine("The <pipe name> is any legal file name which uniquely distinguishes the pipe server.");
+                Console.WriteLine("The <next action file path> is a text file containing a list of actions to execute in PowerShell.");
+                return;
+            }
+
+            FileStream fileStream = null;
+            StreamReader streamReader = null;
+
+            try
+            {
+                // read next action file linewise.
+                fileStream = new FileStream(nextActionPath, FileMode.OpenOrCreate, FileAccess.Read);
+                streamReader = new StreamReader(fileStream);
+
+                // use JSON transport to unmarshal initial nodes.
+                ITransport transport = new JsonTransport();
+
+                // create pipe server using JSON as transport.
+                PipeServer pipeServer = new PipeServer(pipeName, transport);
+
+                Console.WriteLine("Hit Ctrl+C to stop the server.");
+
+                bool moreCommands = true;
+
+                while (moreCommands)
+                {
+                    try
+                    {
+                        Console.WriteLine("Waiting for client to connect...");
+                        pipeServer.WaitForConnection();
+
+                        GetNextActionRequest request = pipeServer.Receive<GetNextActionRequest>();
+
+                        if (null == request)
+                        {
+                            break;
+                        }
+                        Console.WriteLine(String.Format("Received: {0}", request.ToString()));
+
+                        for (;;)
+                        {
+                            string nextLine = streamReader.ReadLine();
+
+                            if (null == nextLine)
+                            {
+                                moreCommands = false;
+                                nextLine = "exit";
+                            }
+                            if (nextLine.Trim().Length > 0)
+                            {
+                                GetNextActionResponse response = new GetNextActionResponse(nextLine);
+
+                                Console.WriteLine(String.Format("Responding: {0}", response.ToString()));
+                                pipeServer.Send(response);
+                                break;
+                            }
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        Console.WriteLine(e.Message);
+                    }
+                    finally
+                    {
+                        pipeServer.Close();
+                    }
+                }
+            }
+            catch (IOException e)
+            {
+                Console.WriteLine(e.Message);
+            }
+            finally
+            {
+                if (null != streamReader)
+                {
+                    streamReader.Close();
+                    streamReader = null;
+                }
+                if (null != fileStream)
+                {
+                    fileStream.Close();
+                    fileStream = null;
+                }
+            }
+        }
+    }
+}

data/lib/chef/windows/ChefNodeCmdlet/TestNextActionCmdlet/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("TestNextActionCmdlet")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("TestNextActionCmdlet")]
+[assembly: AssemblyCopyright("Copyright (c) 2010-2011 RightScale Inc")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("721bf2bf-e02b-48fa-bac3-d0d189195f96")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.1")]
+[assembly: AssemblyFileVersion("1.0.0.1")]