biosphere 0.2.18 → 0.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4240a0aae37ea32a3009555e90b6fe696c87b3cd
-  data.tar.gz: 63d451c4752617971b87f0044f06353e95d14904
+  metadata.gz: 26bb5b9c83385f48f0fb3039200337e9a38d9c9f
+  data.tar.gz: be31681e9d3442d22e9b6a0f8099e291efff6649
 SHA512:
-  metadata.gz: 032af64c9500c6e7b6ef43fa1451512cf400fd196839d1b6b284f8f4d8d8f1e3b1299ae0b650a5ae84afe1ceede8bbebb84803d4d2342c75861a9537f2e633b2
-  data.tar.gz: bf6187383e49fc4fdc7be8a8c9a511b7dece267a37df6b0c19afe78466423ab1339755554a458affb869ee86d776142f1ac160c1c2f3a50f4cc5bfbc96eb5a3e
+  metadata.gz: 27e7d343a95f38e83d3f4c31515f196a9df41c7f767d8e6d51dfdac580eb332958d54e9cf70c4064b334d53b169765bfea8ccff988ca36d45b4d274a2cd6be64
+  data.tar.gz: 1c52390455f83cc190afdf9de14e1665416dcac88ea45951c37f98169bde96f6ead943bf740b9ad23a3331c33a699ebaf50e520a38f1d6d6b7088af260e6e821

data/bin/biosphere

@@ -89,7 +89,7 @@ if !STDOUT.isatty
 end
 
 update_info = Biosphere::CLI::UpdateManager::check_for_update()
-if !update_info[:up_to_date]
+if update_info && !update_info[:up_to_date]
     STDERR.puts "Notice. There is a new #{update_info[:latest]} biosphere version available. Your current version is #{update_info[:current]}\nUse \"gem install biosphere\" to update".colorize(:yellow)
 end
 
@@ -173,22 +173,7 @@ if options.src
     end
 
     unless state.node[:deployments][""].nil?
-        answer = ""
-        if !options.force
-            while answer.empty? || (answer != "y" && answer != "n")
-                puts "\e[31mDeployment with an empty name, do you want to clean these out now? [y/n]\e[0m"
-                answer = STDIN.gets.chomp
-            end
-
-            if answer == "n"
-                puts "Remember to clean these out later, this state won't work with Kubernetes"
-            elsif answer == "y"
-                state.node[:deployments].delete("")
-                puts "\e[32mRemoved deployment with empty name\e[0m"
-            end
-        else
-            puts "Forcing since --force was set"
-        end
+        puts "State contains deployments with empty names. Remember to clean these out with rename-deployment, this state won't work with Kubernetes".colorize(:red)
     end
 end
 
@@ -426,6 +411,9 @@ elsif ARGV[0] == "destroy" && options.src
 
     s3.release_lock()
 
+elsif ARGV[0] == "rename-deployment"
+    Biosphere::CLI::RenameDeployment::renamedeployment(suite, s3, options.build_dir, ARGV[1], ARGV[2], force: options.force)
+
 elsif ARGV[0] == "lock"
     if localmode
         STDERR.puts "lock not supported in local mode (set in Settings :biosphere[:local] = true"
@@ -446,4 +434,3 @@ else
     STDERR.puts "\nERROR: Unknown command #{ARGV[0]}. Maybe you wanted to do: \"biosphere action #{ARGV[0]}\"?"
     exit -1
 end
-

data/lib/biosphere.rb

@@ -13,6 +13,7 @@ require "biosphere/deployment"
 require "biosphere/terraformproxy"
 require "biosphere/suite"
 require "biosphere/cli/terraformplanning"
+require "biosphere/cli/terraformutils"
 require "biosphere/cli/updatemanager"
+require "biosphere/cli/renamedeployment"
 require "biosphere/s3"
-

data/lib/biosphere/cli/renamedeployment.rb

@@ -0,0 +1,82 @@
+require 'biosphere'
+require 'pp'
+require "awesome_print"
+require 'colorize'
+require 'biosphere/s3.rb'
+require 'pty'
+
+class Biosphere
+    class CLI
+        class RenameDeployment
+            def self.renamedeployment(suite, s3, build_dir, deployment, new_name, terraform: Biosphere::CLI::TerraformUtils.new(), localmode: false, force: false)
+
+                if !suite.kind_of?(::Biosphere::Suite)
+                    raise ArgumentError, "RenameDeployment needs a proper suite as the first argument"
+                end
+
+                if !s3.kind_of?(S3)
+                    raise ArgumentError, "RenameDeployment requires an s3 client as the second argument"
+                end
+
+                localmode = suite.biosphere_settings[:local] || localmode
+
+                if !deployment
+                    puts "Please specify deployment name as the second parameter."
+                    puts "Available deployments:"
+                    suite.deployments.each do |name, deployment|
+                        puts "\t#{name}"
+                    end
+                    exit(-1)
+                end
+
+                if !new_name
+                    puts "Please specify the new name as the third parameter."
+                    exit(-1)
+                end
+
+                if !suite.deployments[deployment]
+                    puts "Deployment #{deployment} doesn't exist in the current suite".colorize(:red)
+                    exit(-1)
+                elsif suite.deployments[new_name]
+                    puts "The current suite already contains a deployment called #{new_name}".colorize(:red)
+                    exit(-1)
+                end
+
+                puts "Renaming #{deployment} to #{new_name}"
+
+                suite.deployments[deployment].all_resources.each do |r|
+                    r[:new_name] = r[:name].sub(deployment,new_name)
+                end
+
+                state_file = "#{build_dir}/#{deployment}.tfstate"
+                suite.deployments[deployment].all_resources.each do |r|
+                    terraform.move(state_file, r[:type], r[:name], r[:new_name])
+                    r[:name] = r[:new_name]
+                    r.delete(:new_name)
+                end
+                suite.state.node[:deployments][new_name] = suite.state.node[:deployments].delete(deployment)
+
+                puts "State renaming done!".colorize(:green)
+                puts "Remember to change the deployment name in the deployment specifications too!".colorize(:yellow)
+
+                count = 0
+                suite.write_json_to(build_dir) do |file_name, destination, str, suite_deployment|
+                    puts "Wrote #{str.length} bytes from #{file_name} to #{destination} (#{suite_deployment.export["resource"].length} resources)"
+                    count = count + 1
+                end
+
+                puts "Wrote #{count} files under #{build_dir}"
+
+                unless suite.state.node[:biosphere].nil?
+                    suite.state.node[:biosphere][:last_build_time] = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+                end
+
+                FileUtils.mv("#{build_dir}/#{deployment}.tfstate", "#{build_dir}/#{new_name}.tfstate")
+                suite.state.save()
+                s3.save("#{build_dir}/state.node") unless localmode
+                s3.delete_object("#{build_dir}/#{deployment}.tfstate") unless localmode
+                s3.save("#{build_dir}/#{new_name}.tfstate") unless localmode
+            end
+        end
+    end
+end

data/lib/biosphere/cli/terraformutils.rb

@@ -0,0 +1,34 @@
+require 'biosphere'
+require 'colorize'
+
+class Biosphere
+    class CLI
+        class TerraformUtils
+            def initialize()
+              
+            end
+            
+            def move(tfstate_file, resource_type, old_name, new_name)
+                if tfstate_file.nil? || resource_type.nil? || old_name.nil? || new_name.nil? 
+                    puts "Can't run terraform mv without a tfstate_file, resource_type, old_resource_name and a new_resource_name"
+                    puts "tfstate_file: #{tfstate_file}"
+                    puts "resource_type: #{resource_type}"
+                    puts "old_name: #{old_name}"
+                    puts "new_name: #{new_name}"
+                    exit(-1)
+                end
+              
+                begin
+                    PTY.spawn("terraform state mv -state=#{tfstate_file} #{resource_type}.#{old_name} #{resource_type}.#{new_name}") do |stdout, stdin, pid|
+                        begin
+                            stdout.each { |line| puts line }
+                        rescue Errno::EIO
+                        end
+                    end
+                rescue PTY::ChildExited
+                    puts "The child process exited!"
+                end
+            end
+        end
+    end
+end

data/lib/biosphere/kube.rb

@@ -3,6 +3,8 @@ require 'kubeclient'
 require 'erb'
 require 'hashdiff'
 require 'ostruct'
+require 'jsonpath'
+require 'deep_dup'
 
 class String
     # Converts "CamelCase"" into "camel_case"
@@ -26,6 +28,83 @@ end
 class Biosphere
     module Kube
 
+        #
+        # Encapsulates a single resource inside kube apiserver (eg. a Deployment or a DaemonSet).
+        # A KubeResource comes from a manifest which has one or more resources (yaml allows separating
+        # multiple documents with --- inside a single file).
+        #
+        #
+        class KubeResource
+            attr_accessor :resource, :document, :source_file, :preserve_current_values
+            def initialize(document, source_file)
+                @document = document
+                @source_file = source_file
+                @preserve_current_values = []
+            end
+
+            # Merges the resource with the current resource version in the api server, which
+            # has important properties such as:
+            #  - metadata.selfLink
+            #  - metadata.uid
+            #  - metadata.resourceVersion
+            #
+            # A document can't be updated (PUT verb) unless these are carried over
+            #
+            def merge_for_put(current)
+                new_version = DeepDup.deep_dup(@document)
+
+                if current["metadata"]
+                    new_version["metadata"]["selfLink"] = current["metadata"]["selfLink"] if current["metadata"]["selfLink"]
+                    new_version["metadata"]["uid"] = current["metadata"]["uid"] if current["metadata"]["uid"]
+                    new_version["metadata"]["resourceVersion"] = current["metadata"]["resourceVersion"] if current["metadata"]["resourceVersion"]
+                end
+
+                if current["spec"]
+                    new_version["spec"] = {} if !new_version["spec"]
+
+                    # handle spec.clusterIP
+                    if new_version["spec"]["clusterIP"] && new_version["spec"]["clusterIP"] != current["spec"]["clusterIP"]
+                        raise ArgumentError, "#{@source_file}: Tried to modify spec.clusterIP from #{current["spec"]["clusterIP"]} to #{new_version["spec"]["clusterIP"]} but the field is immutable"
+                    end
+                    new_version["spec"]["clusterIP"] = current["spec"]["clusterIP"] if current["spec"]["clusterIP"]
+
+                end
+
+                @preserve_current_values.each do |jsonpath_query|
+                    jp = JsonPath.new(jsonpath_query)
+                    current_value = jp.on(current)
+                    if current_value.length > 1
+                        raise ArgumentError, "#{@source_file}: A JSONPath query \"#{jsonpath_query}\" matched more than one element: #{current_value}. This is not allowed because it should be used to preserve the current value in the Kubernets API server for the property."
+                    end
+
+                    new_value = jp.on(new_version)
+                    if new_value.length > 1
+                        raise ArgumentError, "#{@source_file}: A JSONPath query \"#{jsonpath_query}\" matched more than one element: #{new_value}. This is not allowed because it should be used to preserve the current value in the Kubernets API server for the property."
+                    end
+
+                    if current_value.first != new_value.first
+                        new_version = JsonPath.for(new_version).gsub(jsonpath_query) { |proposed_value| current_value.first }.to_hash
+                    end
+                end
+
+                return new_version
+            end
+        end
+
+        class KubeResourceERBBinding < OpenStruct
+            attr_accessor :preserve_current_values
+
+            def initialize(object)
+                @preserve_current_values = []
+                super(object)
+            end
+
+            def preserve_current_value(jsonpathquery)
+                @preserve_current_values << jsonpathquery
+            end
+
+        end
+
         class Client
             def initialize(hostname, ssl_options)
                 @clients = []
@@ -48,7 +127,7 @@ class Biosphere
 
             def get_resource_name(resource)
                 resource_name = nil
-                kind = resource[:kind].underscore_case
+                kind = resource["kind"].underscore_case
                 @clients.each do |c|
                     if c.instance_variable_get("@entities")[kind]
                         return c.instance_variable_get("@entities")[kind].resource_name
@@ -58,9 +137,9 @@ class Biosphere
             end
 
             def get_client(resource)
-                kind = resource[:kind].underscore_case
+                kind = resource["kind"].underscore_case
                 @clients.each do |c|
-                    if c.instance_variable_get("@api_group") + c.instance_variable_get("@api_version") == resource[:apiVersion]
+                    if c.instance_variable_get("@api_group") + c.instance_variable_get("@api_version") == resource["apiVersion"]
                         return c
                     end
                 end
@@ -68,7 +147,7 @@ class Biosphere
             end
 
             def post(resource)
-                name = resource[:metadata][:name]
+                name = resource["metadata"]["name"]
                 client = get_client(resource)
                 resource_name = get_resource_name(resource)
 
@@ -76,9 +155,10 @@ class Biosphere
                     raise ArgumentError, "Unknown resource #{resource[:kind]} of #{name} for kubernetes. Maybe this is in a new extension api?"
                 end
 
-                ns_prefix = client.build_namespace_prefix(resource[:metadata][:namespace])
+                ns_prefix = client.build_namespace_prefix(resource["metadata"]["namespace"])
+                body = JSON.pretty_generate(resource.to_h)
                 begin
-                    ret =  client.rest_client[ns_prefix + resource_name].post(resource.to_h.to_json, { 'Content-Type' => 'application/json' }.merge(client.instance_variable_get("@headers")))
+                    ret =  client.rest_client[ns_prefix + resource_name].post(body, { 'Content-Type' => 'application/json' }.merge(client.instance_variable_get("@headers")))
                 rescue RestClient::MethodNotAllowed => e
                     if !resource[:metadata][:namespace]
                         puts "Error doing api call: #{e}".colorize(:red)
@@ -88,7 +168,11 @@ class Biosphere
                     end
                     puts "rest_client: #{ns_prefix + resource_name}, client: #{client.rest_client[ns_prefix + resource_name]}"
                     puts "Dumpin resource request:"
-                    pp resource.to_h.to_json
+                    pp body
+                    raise e
+
+                rescue RestClient::BadRequest => e
+                    handle_bad_request(client, e, body, ns_prefix, resource_name)
                     raise e
 
                 rescue RestClient::Exception => e
@@ -101,51 +185,59 @@ class Biosphere
                 return {
                     action: :post,
                     resource: ns_prefix + resource_name + "/#{name}",
-                    body: JSON.parse(ret.body, :symbolize_names => true)
+                    body: JSON.parse(ret.body)
                 }
             end
 
             def get(resource)
-                name = resource[:metadata][:name]
+                name = resource["metadata"]["name"]
                 client = get_client(resource)
                 resource_name = get_resource_name(resource)
 
                 if !client
-                    raise ArgumentError, "Unknown resource #{resource[:kind]} of #{name} for kubernetes. Maybe this is in a new extension api?"
+                    raise ArgumentError, "Unknown resource #{resource["kind"]} of #{name} for kubernetes. Maybe this is in a new extension api?"
                 end
 
-                ns_prefix = client.build_namespace_prefix(resource[:metadata][:namespace])
+                ns_prefix = client.build_namespace_prefix(resource["metadata"]["namespace"])
                 key = ns_prefix + resource_name + "/#{name}"
                 ret = client.rest_client[key].get(client.instance_variable_get("@headers"))
                 return {
                     action: :get,
                     resource: key,
-                    body: JSON.parse(ret.body, :symbolize_names => true)
+                    body: JSON.parse(ret.body)
                 }
             end
 
             def put(resource)
-                name = resource[:metadata][:name]
+                name = resource["metadata"]["name"]
                 client = get_client(resource)
                 resource_name = get_resource_name(resource)
 
                 if !client
-                    raise ArgumentError, "Unknown resource #{resource[:kind]} of #{name} for kubernetes. Maybe this is in a new extension api?"
+                    raise ArgumentError, "Unknown resource #{resource["kind"]} of #{name} for kubernetes. Maybe this is in a new extension api?"
                 end
 
-                ns_prefix = client.build_namespace_prefix(resource[:metadata][:namespace])
+                ns_prefix = client.build_namespace_prefix(resource["metadata"]["namespace"])
                 key = ns_prefix + resource_name + "/#{name}"
                 ret = client.rest_client[key].put(resource.to_h.to_json, { 'Content-Type' => 'application/json' }.merge(client.instance_variable_get("@headers")))
                 return {
                     action: :put,
                     resource: key,
-                    body: JSON.parse(ret.body, :symbolize_names => true)
+                    body: JSON.parse(ret.body)
                 }
 
             end
 
-            def apply_resource(resource)
-                name = resource[:metadata][:name]
+            # Applies the KubeResource into the api server
+            #
+            # The update process has the following sequence:
+            #
+            #  1) Try to fetch the resource to check if the resource is already there
+            #  2.1) If a new resource: issue a POST
+            #  2.2) If resource exists: merge existing resource with the KubeResource and issue a PUT (update)
+            def apply_resource(kuberesource)
+                resource = kuberesource.document
+                name = resource["metadata"]["name"]
                 responses = []
                 not_found = false
                 begin
@@ -175,21 +267,65 @@ class Biosphere
                     # Get the current full resource from apiserver
                     current_resource = response[:body]
 
-                    update_resource = Kube.kube_merge_resource_for_put!(current_resource, resource)
+                    update_resource = kuberesource.merge_for_put(current_resource)
 
                     begin
                         responses << put(update_resource)
+                    rescue RestClient::BadRequest => e
+                        handle_bad_request(client, e, body, ns_prefix, resource_name)
+                        raise e
                     rescue RestClient::Exception => e
                         puts "Error updating resource: #{e} #{e.class}"
                         pp JSON.parse(e.response)
-                    rescue RestClient::Exception => e
-                        puts "Misc exception: #{e}, #{e.class}, #{e.response}"
                     end
                     
                     return responses
                 end
             end
 
+            def print_error_location(lines, linenumber)
+                start_line = [0, linenumber - 3].max
+                end_line = [lines.length - 1, linenumber + 3].min
+                lines[start_line..end_line].each_with_index do |line, num|
+                    num += start_line
+                    if num == linenumber
+                        STDERR.printf("%04d>  %s\n".red, num, line)
+                    else
+                        STDERR.printf("%04d|  %s\n", num, line)
+                    end
+                end
+            end
+
+            def handle_bad_request(client, e, body, ns_prefix, resource_name)
+                puts "Error calling API (on RestClient::BadRequest rescue): #{e}"
+                puts "rest_client: #{ns_prefix + resource_name}, client: #{client.rest_client[ns_prefix + resource_name]}"
+
+                begin
+                    msg = JSON.parse(e.http_body)
+                    if msg["message"]
+                        m = msg["message"].match(/\[pos ([0-9]+?)\]:\s?(.+)/)
+                        if m
+                            error_pos = m[1].to_i
+                            if error_pos < body.length
+                                # Find the line number where the error is
+                                line_number = 0
+                                for pos in 0..body.length - 1
+                                    if body[pos] == "\n"
+                                        line_number += 1
+                                    end
+                                    if pos >= m[1].to_i
+                                        break
+                                    end
+                                end
+                                print_error_location(body.split("\n"), line_number)
+                            end
+                        end
+                    end
+                rescue
+                    puts "Error message from body #{e.http_body}"
+                end
+            end
+
         end # end of class Client
 
         def kube_test(str)
@@ -211,23 +347,45 @@ class Biosphere
         def self.load_resources(file, context={})
             resources = []
             puts "Loading file #{File.absolute_path(file)}"
+
+            # Let's wrap the context into an OpenStruct based class so that context["foo"]
+            # can be accessed as contextstruct.foo
+            #
+            # This is required for two reasons:
+            #  1) The ERB template evaluation requires a binding object so that
+            #     we can pass variables to the template (from the context object)
+            #  2) We want to push some metadata from the ERB template to back here
+            #     such as the preserve_current_value
+            contextstruct = KubeResourceERBBinding.new(context)
+
+            # Read the file in. A single .yaml can contain multiple documents
             data = IO.read(file)
+
+            # First phase: Evaluate ERB templating. We'll use the context to pass
+            # all the template variables into the erb.
+            # Handle all ERB error reporting with the rescue clauses,
+            # so that user gets as good error message as possible.
             begin
-                str = ERB.new(data).result(OpenStruct.new(context).instance_eval { binding })
+                str = ERB.new(data).result(contextstruct.instance_eval { binding })
             rescue NoMethodError => e
                 puts "Error evaluating erb templating for #{file}. Error: #{e}"
                 m = /\(erb\):([0-9]+):/.match(e.backtrace.first)
                 if m
                     puts "Error at line #{m[1]}. This is before ERB templating. Remember to run biosphere build if you changed settings."
                     linenumber = m[1].to_i
-                    if linenumber > 0 # Linenumbers seems to be off with 1 as the array is starting at zero
-                        linenumber = linenumber - 1
-                    end
                     lines = data.split("\n")
-                    start_line = [0, linenumber - 3].max
-                    end_line = [lines.length - 1, linenumber + 3].min
+                    start_line = [0, linenumber - 4].max
+                    end_line = [lines.length - 1, linenumber + 2].min
+
+                    # Lines is the full .yaml file, one line in each index
+                    # the [start_line..end_line] slices the subset of the lines
+                    # which we want to display
                     lines[start_line..end_line].each_with_index do |line, num|
-                        num += start_line
+
+                        # num is the current line number from the subset of the lines
+                        # We need to add start_line + 1 to it so that it shows
+                        # the current line number when we print it out
+                        num += start_line + 1
                         if num == linenumber
                             STDERR.printf("%04d>  %s\n".red, num, line)
                         else
@@ -238,10 +396,17 @@ class Biosphere
                 raise e
             end
 
+            # Second phase: Parse YAML into an array of KubeResource.
+            # Again handle error reporting on the rescue clause.
             begin
                 Psych.load_stream(str) do |document|
                     kind = document["kind"]
-                    resource = ::Kubeclient::Resource.new(document)
+                    resource = KubeResource.new(document, file)
+
+                    # The preserve_current_values is a metadata field which is used later
+                    # when merging the updated resource with the current object from apiserver.
+                    resource.preserve_current_values = contextstruct.preserve_current_values
+
                     resources << resource
                 end
             rescue Psych::SyntaxError => e
@@ -251,14 +416,13 @@ class Biosphere
                 STDERR.puts "Notice that yaml is very picky about indentation when you have arrays and maps. Check those first."
                 lines = str.split("\n")
                 linenumber = e.line
-                if linenumber > 0 # Linenumbers seems to be off with 1 as the array is starting at zero
-                    linenumber = linenumber - 1
-                end
-                
-                start_line = [0, linenumber - 3].max
-                end_line = [lines.length - 1, linenumber + 3].min
+                start_line = [0, linenumber - 4].max
+                end_line = [lines.length - 1, linenumber + 2].min
                 lines[start_line..end_line].each_with_index do |line, num|
-                    num += start_line
+                    # num is the current line number from the subset of the lines
+                    # We need to add start_line + 1 to it so that it shows
+                    # the current line number when we print it out
+                    num += start_line + 1
                     if num == linenumber
                         STDERR.printf("%04d>  %s\n".red, num, line)
                     else
@@ -282,30 +446,5 @@ class Biosphere
             end
         end
 
-        #
-        # Applies seleted properties from the current resource (as fetched from apiserver) to the new_version (as read from manifest file)
-        #
-        #
-        def self.kube_merge_resource_for_put!(current, new_version)
-            if current[:metadata]
-                new_version[:metadata][:selfLink] = current[:metadata][:selfLink] if current[:metadata][:selfLink]
-                new_version[:metadata][:uid] = current[:metadata][:uid] if current[:metadata][:uid]
-                new_version[:metadata][:resourceVersion] = current[:metadata][:resourceVersion] if current[:metadata][:resourceVersion]
-            end
-
-            if current[:spec]
-                new_version[:spec] = {} if !new_version[:spec]
-
-                # handle spec.clusterIP
-                if new_version[:spec][:clusterIP] && new_version[:spec][:clusterIP] != current[:spec][:clusterIP]
-                    raise ArgumentError, "Tried to modify spec.clusterIP from #{current[:spec][:clusterIP]} to #{new_version[:spec][:clusterIP]} but the field is immutable"
-                end
-                new_version[:spec][:clusterIP] = current[:spec][:clusterIP] if current[:spec][:clusterIP]
-
-            end
-            return new_version
-        end
-
-
     end
 end

data/lib/biosphere/version.rb

@@ -1,3 +1,3 @@
 class Biosphere
-  Version = "0.2.18"
+  Version = "0.2.19"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: biosphere
 version: !ruby/object:Gem::Version
-  version: 0.2.18
+  version: 0.2.19
 platform: ruby
 authors:
 - Juho Mäkinen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-07 00:00:00.000000000 Z
+date: 2017-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -164,6 +164,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: jsonpath
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.5
 description: "Terraform's HCL lacks quite many programming features like iterators,
   true variables, advanced string manipulation, functions etc.\n\n  This Ruby tool
   provides an easy-to-use DSL to define Terraform compatible .json files which can
@@ -177,7 +191,9 @@ files:
 - bin/biosphere
 - examples/example.rb
 - lib/biosphere.rb
+- lib/biosphere/cli/renamedeployment.rb
 - lib/biosphere/cli/terraformplanning.rb
+- lib/biosphere/cli/terraformutils.rb
 - lib/biosphere/cli/updatemanager.rb
 - lib/biosphere/deployment.rb
 - lib/biosphere/exceptions.rb