knife-topo 0.0.3

data/lib/chef/knife/topo_update.rb

@@ -0,0 +1,110 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2014 ThirdWave Insights LLC
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/knife'
+require_relative 'topo_cookbook_upload'
+
+class Chef
+  class Knife
+    class TopoUpdate < Chef::Knife
+
+      deps do
+        Chef::Knife::TopoCookbookUpload.load_deps
+      end
+
+      banner "knife topo update [ TOPOLOGY ] (options)"
+
+      option :data_bag,
+      :short => '-D DATA_BAG',
+      :long => "--data-bag DATA_BAG",
+      :description => "The data bag the topologies are stored in"
+
+      # Make called command options available
+      self.options = Chef::Knife::TopoCookbookUpload.options.merge(self.options)
+
+      def initialize (args)
+        super
+        @topo_upload_args  = initialize_cmd_args(args, [ 'topo', 'cookbook', 'upload', '' ])
+
+        # All called commands need to accept union of options
+        Chef::Knife::TopoCookbookUpload.options = options
+      end
+
+      def run
+
+        bag_name = topo_bag_name(config[:data_bag])
+
+        if !@name_args[0]
+             ui.confirm("Do you want to update all topologies in the #{bag_name} data bag", true, true)
+        end
+
+        topo_name = @name_args[0]
+        
+        if topo_name
+          # update a specific topo
+          ui.info "Updating topology: #{topo_name} in data bag: #{bag_name}"
+          
+          unless current_topo = load_from_server(bag_name, topo_name)
+            ui.fatal "Topology #{bag_name}/#{topo_name} does not exist on server - use 'knife topo create' first"
+            exit(1)
+          end
+          
+          unless topo = load_from_file(bag_name, topo_name)
+            ui.info "No topology found in #{topologies_path}/#{bag_name}/#{topo_name}.json - exiting  without action"
+            exit(0)
+          end
+
+          update_topo(topo)
+
+        else
+          # find all topologies from server then update them from file, skipping any that have no file
+          ui.info "Updating all topologies in data bag: #{bag_name}"
+
+          unless dbag = load_from_server(bag_name)
+            ui.fatal "Data bag #{bag_name} does not exist on server - use 'knife topo create' first"
+            exit(1)
+          end
+
+          dbag.keys.each do |topo_name|
+
+            topo = load_from_file(bag_name, topo_name)
+            if !topo
+              # do not update topologies that are not in the local workspace
+              ui.info("No topology file found in #{topologies_path}/#{bag_name}/#{topo_name}.json - skipping")
+            else
+              ui.info("Updating topology #{topo_name}")
+              update_topo(topo)
+            end
+          end
+        end
+        ui.info "Updates done"
+ 
+      end
+
+      def update_topo(topo)
+        topo.save
+        @topo_upload_args[3] = topo['name']
+        upload_cookbooks(@topo_upload_args) if (!config[:no_upload])           
+        create_or_update_nodes(topo)
+      end
+
+      include Chef::Knife::TopologyHelper
+      
+    end
+  end
+end

data/lib/chef/knife/topology_helper.rb

@@ -0,0 +1,280 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2014 ThirdWave Insights LLC
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/data_bag'
+require 'chef/encrypted_data_bag_item'
+require 'chef/knife/core/object_loader'
+
+class Chef
+  class Knife
+    module TopologyHelper
+      
+      # load one or more topologies from file
+      def load_topologies(topology_file_path)
+
+        if ! topology_file_path.end_with?('.js', '.json')
+          show_usage
+          ui.fatal "TOPOLOGY_FILE must be a '.js' or '.json' file"
+          exit(1)
+        end
+
+        topologies = loader.object_from_file(topology_file_path)
+        topologies = [topologies] if !topologies.kind_of?(Array)
+        
+        topologies
+      end
+      
+      # create the topology data bag
+      def create_bag(bag_name)
+        # check that the name is valid
+        begin
+          Chef::DataBag.validate_name!(bag_name)
+        rescue Chef::Exceptions::InvalidDataBagName => e
+          ui.fatal(e.message)
+          exit(1)
+        end
+
+        # create the data bag
+        begin
+          data_bag = Chef::DataBag.new
+          data_bag.name(bag_name)
+          data_bag.create
+          ui.info("Created topology data bag [#{bag_name}]")
+        rescue Net::HTTPServerException => e
+          raise unless e.to_s =~ /^409/
+          data_bag  = Chef::DataBag.load(bag_name)
+          ui.info("Topology data bag #{bag_name} already exists")
+        end
+
+        data_bag
+      end
+
+        # make sure the chef environment exists
+      def check_chef_env(chef_env_name)
+
+        if chef_env_name
+          begin
+            chef_env = Chef::Environment.load(chef_env_name)
+          rescue Net::HTTPServerException => e
+            raise unless e.to_s =~ /^404/
+            ui.info "Creating chef environment " + chef_env_name
+            chef_env = Chef::Environment.new()
+            chef_env.name(chef_env_name)
+            chef_env.create
+          end
+        end
+
+        chef_env
+      end
+
+      # Merges topology properties into nodes, returning the merged nodes
+      def merge_topo_properties(nodes, topo_hash)
+
+        if nodes
+          merged_nodes = nodes.clone
+          merged_nodes.each do |nodeprops|
+
+            nodeprops['chef_environment'] ||=  topo_hash['chef_environment'] if topo_hash['chef_environment']
+
+            # merge in the topology tags
+            nodeprops['tags'] |= topo_hash['tags'] if topo_hash['tags']
+            
+            normal_defaults = topo_hash['normal'] || {}
+            nodeprops['normal'] = normal_defaults.merge(nodeprops['normal'] || {})
+
+          end
+        end
+
+        merged_nodes
+
+      end
+
+      # Get nodes from the topology, create them and/or set their run lists
+      def create_or_update_nodes(topo)
+
+        topo_hash = topo.raw_data
+        nodes = merge_topo_properties(topo_hash['nodes'], topo_hash)
+        config[:disable_editing] = true
+
+        if nodes.length > 0
+         nodes.each do |updates|
+            node_name = updates['name']
+            begin
+              # load then update and save the node
+              node = Chef::Node.load(node_name)
+              if updated_values = update_node_with_values(node, updates)
+                ui.info "Updating #{updated_values.join(', ')} on node #{node.name}"
+                node.save
+                ui.output(format_for_display(node)) if config[:print_after]
+              else
+                ui.info "No  updates found for node #{node.name}"
+              end
+
+            rescue Net::HTTPServerException => e
+              raise unless e.to_s =~ /^404/
+              # Create the node
+              node = Chef::Node.new
+              node.name(node_name)
+              update_node_with_values(node, updates)
+              create_object(node)
+            end
+        end
+        else
+          ui.info "No nodes found for topology #{topo_hash.name}"
+        end
+      end
+
+      # Make updates into the original node, returning the list of updated properties.
+      def update_node_with_values(node, updates)
+        updated_properties = []
+
+        if updates['run_list']
+          updated_run_list = RunList.new
+          updates['run_list'].each { |e| updated_run_list << e }
+          if (updated_run_list != node.run_list)
+            updated_properties << 'run_list'
+            node.run_list(*updated_run_list)
+          end
+        end
+
+        new_chef_environment = updates['chef_environment']
+        if new_chef_environment && new_chef_environment != node.chef_environment
+          updated_properties << 'chef_environment'
+          node.chef_environment(new_chef_environment)
+        end
+
+        orig_num_tags = node.tags.length
+        updates['tags'] ||= [] # make sure tags are initialized
+        node.tag(*updates['tags'])
+        updated_properties << 'tags' if node.tags.length > orig_num_tags
+
+        normal_updates = updates['normal'] || {}
+        normal_updates.each do |key, value|
+          if (value != node.normal[key])
+            updated_properties << "normal.#{key}"
+            node.normal[key] = value
+          end
+        end
+
+        # return false if no updates, else return array of property names
+        updated_properties.length > 0 && updated_properties
+      end
+
+      # Load a topology from local data bag item file
+      def load_from_file(bag_name, topo_name)
+        return unless topo_file = loader.find_file("#{topologies_path}", bag_name, topo_name + '.json')
+
+        item_data = loader.object_from_file(topo_file)
+        item_data = if use_encryption
+          secret = read_secret
+          Chef::EncryptedDataBagItem.encrypt_data_bag_item(item_data, secret)
+        else
+          item_data
+        end
+        item = Chef::DataBagItem.new
+        item.data_bag(bag_name)
+        item.raw_data = item_data
+        item
+      end
+
+      # read in the topology bag item
+      def load_from_server(bag_name, item_name = nil)
+        begin
+          if (item_name)
+            item = Chef::DataBagItem.load(bag_name, item_name)
+            item = Chef::EncryptedDataBagItem.new(item.raw_data, read_secret) if use_encryption
+          else
+            item = Chef::DataBag.load(bag_name)
+          end
+        rescue Net::HTTPServerException => e
+          raise unless e.to_s =~ /^404/
+        end
+        item
+      end
+
+      # Replace existing run list in a node
+      def set_run_list(node, entries)
+        node.run_list.run_list_items.clear
+        entries.each { |e| node.run_list << e }
+      end
+
+      # Name of the topology bag
+      def topo_bag_name(name=nil)
+        @topo_bag_name = name if (name)
+        @topo_bag_name ||= "topologies"
+      end
+
+      # Path for the topologies data bags.
+      # For now, use the standard data_bags path for our topologies bags
+      def topologies_path
+        @topologies_path ||= "data_bags"
+      end
+
+      # Loader to get data bag items from file
+      def loader
+        @loader ||= Knife::Core::ObjectLoader.new(DataBagItem, ui)
+      end
+
+      # Determine if the bag items are/should be encrypted on server
+      # NOTE: This option isnt currently enabled
+      def use_encryption
+        if config[:secret] && config[:secret_file]
+          ui.fatal("please specify only one of --secret, --secret-file")
+          exit(1)
+        end
+        config[:secret] || config[:secret_file]
+      end
+
+      # Return the secret key to encrypt/decrypt data bag items
+      def read_secret
+        if config[:secret]
+          config[:secret]
+        else
+          Chef::EncryptedDataBagItem.load_secret(config[:secret_file])
+        end
+      end
+      
+      # initialize args for another knife command
+      def initialize_cmd_args(args, new_name_args)
+        args = args.dup
+        args.shift(2 + @name_args.length) 
+        cmd_args  = new_name_args + args
+      end
+
+      # run another knife command
+      def run_cmd(command_class, args)        
+        command = command_class.new(args)
+        command.config[:config_file] = config[:config_file]
+        command.configure_chef
+        command.run
+        
+        command
+      end
+      
+      # upload cookbooks - will warn and continue if upload fails (e.g. may be frozen)
+      def upload_cookbooks(args)      
+        begin
+          run_cmd(Chef::Knife::TopoCookbookUpload, args)
+        rescue Exception => e
+            raise if Chef::Config[:verbosity] == 2
+        end        
+      end
+
+    end
+  end
+end

data/test-repo/.chef/dummy.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAqZszg6n+ukMvore53ROFNQAAZhEfW0H9erLqC/4Go/lkRhwl
+d/BOu3bexV2bQFh8Eqg/0VfP0/eOGx4pt6lOP1W20isWr0sGnf8DID2oB/Vi/NhS
++zfnos/TMXbJSvXryfpMUB6YKhraC645Q0zuBDHm+3fjGol6nND/tVWCW9h+og7d
+WTZLOVUbbD949F7WBVEcbNp66e49AaZ5yYevVJtjCQRQQ1E9d+/WsMM0Nv24VEc2
+oEmbH4U0/+g+WKiJB4m/IDJ4RXco3JtFNpkM/HeKHcc0Niw1A8aLVv5Bp3hYkEnh
+VidA+H2nZ7IxNOzF3wzJAUwxmg89hC2X1t9WUQIDAQABAoIBAGCZrBKOrS3LfIMy
+H6NiLdmNAa0gjXp9sHDFHHbuHTwhnFIuT8zrSvyM7L7+3KEehLRfrdF/MTjqY77g
+RCR+QrniCPnVXttCYSd2CoK/e0flJJccYs8A/WaG9iPTIz0VqlFkxThQ5Jv+pThH
+6AeD9oDfJ08M7oW7zeEpTKssY84JKE7iAPjBoRF8wMjJPbJB6HEDKPT6pPL9fyjF
++FkD01XxaI4Ip5vXsc0+Lckf9uItD5SP4CDcFVxFtU+4m/iJjBrUxeUDrzWCzOY4
+SgfD9aJ3J79acQ4omtvD0iGUSu/4CwSpAyuw0qzBOS2tmYyaiz0EK2YGg3IbE9xz
+jPjnj40CgYEA1ai6cb/9PBfF82sG6e23fie2odHN6Lt5Ex7AmCjGg7yVly1rLm7f
+LxCA+bJfwyOmx7/rptECAFnQeahVcsLQ3KXDwm0IP8Ow60s83Tk0HNrejlIK7f5i
+8PlvO7Z+bhbTqKDI12YuKJ74pBw4WCP7U4fmxWNryFj1/7o8gPgsqesCgYEAyzeZ
+3lbya3Txl3gYhS5Ppeuqave/q1jcCYUmoTqCfyZxqQyCmuVpMN/S6zx/vTAlFqHK
+OsE5v9GD+NuvfhXga4+9FH4nMdbdhYntHLSwgAW/WPShVsNM2WCibIZtkOoI3Bkl
+wYQF+PZNGPmAChaEsE7oq6vavHD5DHeVmn3M1bMCgYBbLeZjJMutGXggqUwKCKiF
+7ezCogZ9i4Pf5P/L75rIHXK5UWisKCSWsTRZWwYDAPPryruGNSvlem69fFj64KjB
+gPxJvL4IeDrILxOKVR8oMT9I/Tos1qLis5AEq5zI3nT1Qah0Q+bu7uitIF3rP2/B
+9f1Fv2f/1/cjaxbm8wIcgQKBgBx4t8gc6m3/vnF4VAcky+f1MrU17Na25m03CIiC
+SBJEcpw6snm9NpWwZj6rBUKeYjPfixPcSpkDY7gUH2xM6FppkxYx7o/fCL5S6rOg
+5TGqnHp8G7aqOjQig98snmE1SPR9WXrZYnTVHUwoeLXxHboN9C9JLqZENcB3aLBy
+e6ZdAoGACeT2RLyEngm2XVcdNeiXbtwu8+qhoK4FHX5eFKmO2hm+xDo/601acaH+
+LdFDMKfGevjqTCVS9ZD3SgELSk+KpAvXpVmOzXaX/n/eGCVOYxsWPEKhwpEUsIml
+9rq1jU/phQw7627WvP8UbwMbNl1u1SDCJwFTFssVmZ3pDI4nth8=
+-----END RSA PRIVATE KEY-----

data/test-repo/.chef/knife.rb

@@ -0,0 +1,13 @@
+# See http://docs.opscode.com/config_rb_knife.html for more information on knife configuration options
+
+current_dir = File.dirname(__FILE__)
+log_level                :info
+log_location             STDOUT
+node_name                "workstation"
+client_key               "#{current_dir}/dummy.pem"
+validation_client_name   "validator"
+validation_key           "#{current_dir}/dummy.pem"
+chef_server_url          "http://10.0.1.1:8889"
+cache_type               'BasicFile'
+cache_options( :path => "#{ENV['HOME']}/.chef/checksums" )
+cookbook_path            ["#{current_dir}/../cookbooks"]

data/test-repo/Berksfile

@@ -0,0 +1,4 @@
+source "https://api.berkshelf.com"
+
+cookbook 'testapp', :path => './cookbooks/testapp' 
+

data/test-repo/Instructions.txt

@@ -0,0 +1,48 @@
+# Assumptions for this demo: chefDK, Vagrant, VirtualBox and chef-zero
+
+# chefDK can be obtained from:
+http://www.getchef.com/downloads/chef-dk/
+
+# vagrant can be installed from:
+https://www.vagrantup.com/downloads.html
+
+# VirtualBox can be obtained from:
+https://www.virtualbox.org/wiki/Downloads
+
+# If you have chefDK installed, you can use the embedded chef-zero
+/opt/chefdk/embedded/bin/chef-zero
+
+# or install it
+sudo gem install chef-zero
+
+# Copy test-repo into a working directory, either downloading it from github or copying it from the installed
+# knife-topo gem. You can use
+gem env
+# to get the path to your gems and then
+cp -R <path-to-gem>/knife-topo/test-repo ~
+cd ~/test-repo
+
+# From the test-repo, do the following to start the virtual machines on a private network using vagrant - 
+# Note: you may be prompted to select the network to bridge to
+vagrant up 
+
+# Once the virtual machines are created, start chef-zero listening on the same private network:
+chef-zero -H 10.0.1.1
+
+# In another terminal, in test-repo:
+berks install
+berks upload
+
+# To create and bootstrap the test1 topology
+knife topo import exchange.json
+knife topo create sys1_test test1
+knife topo bootstrap sys1_test test1 -x vagrant -P vagrant --sudo
+
+
+# To check the bootstrap has succeeded, browse to:
+http://localhost:3031
+# You should see a "Welcome" message
+
+
+
+

data/test-repo/Vagrantfile

@@ -0,0 +1,67 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# This Vagrantfile was inspired by Joshua Timberman's blog
+# http://jtimberman.housepub.org/blog/2012/03/18/multivm-vagrantfile-for-chef/
+
+#
+# Vagrantfile for two-machine test topology. Runs with a private network
+# and port forwarding from 3001 on appserver guest, to port 303n on host (i.e. 3031 for topo with id 1). 
+# ipaddresses are 10.0.1.2, 10.0.1.3 for dbserver, appserver. 
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+id = 1 
+qual = "0#{id}"
+
+ # Define the options for each node
+nodes = {
+	:dbserver => {
+		:hostname => "dbserver#{qual}",
+		:ipaddress => "10.0.#{id}.2"
+	},
+	:appserver => {
+		:hostname => "appserver#{qual}",
+		:ipaddress => "10.0.#{id}.3",
+		:forwardports => [ 
+		{
+			:guest => 3001, 
+			:host => (3030 +  id) 
+		}
+		]
+	}
+}
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+
+	# setup each node using config ("options") defined above
+	nodes.each do |node, options|
+		config.vm.define node do |node_config|
+		
+			# setup networking using private network, with port forwarding where needed to access
+			# TODO how to let ip be optional in either case
+			net_type = ( options.has_key?(:public)) ? :public_network : :private_network
+			if options.has_key?(:public)
+    			node_config.vm.network net_type, ip: options[:ipaddress]			
+			else
+				node_config.vm.network net_type, ip: options[:ipaddress]		
+			end
+			
+			if options.has_key?(:forwardports)
+				options[:forwardports].each do |port|
+					node_config.vm.network :forwarded_port, guest: port[:guest], host: port[:host]
+				end
+			end
+			node_config.vm.hostname = options[:hostname]
+		end
+	end
+
+  # Setup the generic config across both servers
+  config.vm.box = "ubuntu64"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  config.vm.box_url = "http://files.vagrantup.com/precise64.box"
+
+end

data/test-repo/cookbooks/README.md

@@ -0,0 +1,54 @@
+This directory contains the cookbooks used to configure systems in your infrastructure with Chef.
+
+Knife needs to be configured to know where the cookbooks are located with the `cookbook_path` setting. If this is not set, then several cookbook operations will fail to work properly.
+
+    cookbook_path ["./cookbooks"]
+
+This setting tells knife to look for the cookbooks directory in the present working directory. This means the knife cookbook subcommands need to be run in the `chef-repo` directory itself. To make sure that the cookbooks can be found elsewhere inside the repository, use an absolute path. This is a Ruby file, so something like the following can be used:
+
+    current_dir = File.dirname(__FILE__)
+    cookbook_path ["#{current_dir}/../cookbooks"]
+
+Which will set `current_dir` to the location of the knife.rb file itself (e.g. `~/chef-repo/.chef/knife.rb`).
+
+Configure knife to use your preferred copyright holder, email contact and license. Add the following lines to `.chef/knife.rb`.
+
+    cookbook_copyright "Example, Com."
+    cookbook_email     "cookbooks@example.com"
+    cookbook_license   "apachev2"
+
+Supported values for `cookbook_license` are "apachev2", "mit","gplv2","gplv3",  or "none". These settings are used to prefill comments in the default recipe, and the corresponding values in the metadata.rb. You are free to change the the comments in those files.
+
+Create new cookbooks in this directory with Knife.
+
+    knife cookbook create COOKBOOK
+
+This will create all the cookbook directory components. You don't need to use them all, and can delete the ones you don't need. It also creates a README file, metadata.rb and default recipe.
+
+You can also download cookbooks directly from the Opscode Cookbook Site. There are two subcommands to help with this depending on what your preference is.
+
+The first and recommended method is to use a vendor branch if you're using Git. This is automatically handled with Knife.
+
+    knife cookbook site install COOKBOOK
+
+This will:
+
+* Download the cookbook tarball from cookbooks.opscode.com.
+* Ensure its on the git master branch.
+* Checks for an existing vendor branch, and creates if it doesn't.
+* Checks out the vendor branch (chef-vendor-COOKBOOK).
+* Removes the existing (old) version.
+* Untars the cookbook tarball it downloaded in the first step.
+* Adds the cookbook files to the git index and commits.
+* Creates a tag for the version downloaded.
+* Checks out the master branch again.
+* Merges the cookbook into master.
+* Repeats the above for all the cookbooks dependencies, downloading them from the community site
+
+The last step will ensure that any local changes or modifications you have made to the cookbook are preserved, so you can keep your changes through upstream updates.
+
+If you're not using Git, use the site download subcommand to download the tarball.
+
+    knife cookbook site download COOKBOOK
+
+This creates the COOKBOOK.tar.gz from in the current directory (e.g., `~/chef-repo`). We recommend following a workflow similar to the above for your version control tool.

data/test-repo/cookbooks/testapp/CHANGELOG.md

@@ -0,0 +1,10 @@
+testapp CHANGELOG
+=================
+
+This file is used to list changes made in each version of the testapp cookbook.
+
+0.1.0
+-----
+- Christine Draper - Initial release of testapp
+
+- - -

data/test-repo/cookbooks/testapp/README.md

@@ -0,0 +1,26 @@
+Test Application Cookbook
+=========================
+A simple nodejs application that puts up a welcome page.
+
+Requirements
+------------
+Tested on Ubuntu 12.04 LTS.
+
+#### packages
+- `nodejs` - The test application is a nodejs application
+- ` mongodb` - In the future, the test application will have a connection to a database
+
+Attributes
+----------
+None
+
+
+Recipes
+-------
+#### testapp::default
+
+
+
+License and Authors
+-------------------
+Authors: Christine Draper, ThirdWave Insights, LLC

data/test-repo/cookbooks/testapp/files/default/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+<title>YPO Test Application</title>
+
+</head>
+<body>
+	<p> Welcome ! You can find the knife topo plugin on Github:</p>
+	<a href="https://github.com">https://github.com/thirdwaveinsights/knife-topo</a>
+</body>
+</html>

data/test-repo/cookbooks/testapp/files/default/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "testapp",
+  "description": "A dummy application for testing knife-topo",
+  "author": "ThirdWave Insights LLC <contact@thirdwaveinsights.com>",
+  "version": "0.0.1",
+  "private": true,
+  "main": "server.js",
+  "dependencies": {
+    "express": "3.3.4",
+    "ejs": "0.8.4",
+    "connect": "2.8.4"
+  },
+  "engine": "node 0.10.15"
+}