bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/vm_deleter.rb

@@ -0,0 +1,25 @@
+module Bosh::Director
+  class VmDeleter
+    def initialize(cloud, logger, options={})
+      @cloud = cloud
+      @logger = logger
+
+      force = options.fetch(:force, false)
+      @error_ignorer = ErrorIgnorer.new(force, @logger)
+    end
+
+    def delete_for_instance_plan(instance_plan)
+      instance_model = instance_plan.instance_model
+
+      if instance_model.vm
+        delete_vm(instance_model.vm)
+      end
+    end
+
+    def delete_vm(vm_model)
+      @logger.info('Deleting VM')
+      @error_ignorer.with_force_check { @cloud.delete_vm(vm_model.cid) }
+      vm_model.destroy
+    end
+  end
+end

data/lib/bosh/director/vm_recreator.rb

@@ -0,0 +1,15 @@
+module Bosh::Director
+  class VmRecreator
+
+    def initialize(vm_creator, vm_deleter)
+      @vm_creator = vm_creator
+      @vm_deleter = vm_deleter
+    end
+
+    def recreate_vm(instance_plan, disk_cid)
+      @vm_deleter.delete_for_instance_plan(instance_plan)
+      disks = [instance_plan.instance.model.persistent_disk_cid, disk_cid].compact
+      @vm_creator.create_for_instance_plan(instance_plan, disks)
+    end
+  end
+end

data/lib/cloud/dummy.rb

@@ -1,6 +1,7 @@
 require 'digest/sha1'
 require 'fileutils'
 require 'securerandom'
+require 'membrane'
 
 module Bosh
   module Clouds
@@ -18,127 +19,176 @@ module Bosh
         end
 
         @running_vms_dir = File.join(@base_dir, 'running_vms')
+        @vm_repo = VMRepo.new(@running_vms_dir)
         @tmp_dir = File.join(@base_dir, 'tmp')
         FileUtils.mkdir_p(@tmp_dir)
 
         @logger = Logging::Logger.new('DummyCPI')
         @logger.add_appenders(Logging.appenders.io(
-          'DummyCPIIO',
-          options['log_buffer'] || STDOUT
-        ))
+            'DummyCPIIO',
+            options['log_buffer'] || STDOUT
+          ))
 
         @commands = CommandTransport.new(@base_dir, @logger)
+        @inputs_recorder = InputsRecorder.new(@base_dir, @logger)
 
-        FileUtils.mkdir_p(@base_dir)
+        prepare
       rescue Errno::EACCES
         raise ArgumentError, "cannot create dummy cloud base directory #{@base_dir}"
       end
 
-      def create_stemcell(image, _)
-        stemcell_id = Digest::SHA1.hexdigest(File.read(image))
-        File.write(stemcell_file(stemcell_id), image)
+      CREATE_STEMCELL_SCHEMA = Membrane::SchemaParser.parse { {image_path: String, cloud_properties: Hash} }
+      def create_stemcell(image_path, cloud_properties)
+        validate_and_record_inputs(CREATE_STEMCELL_SCHEMA, __method__, image_path, cloud_properties)
+
+        content = File.read(image_path)
+        data = YAML.load(content)
+        data.merge!('image' => image_path)
+        stemcell_id = Digest::SHA1.hexdigest(content)
+
+        File.write(stemcell_file(stemcell_id), YAML.dump(data))
         stemcell_id
       end
 
-      def delete_stemcell(stemcell_cid)
-        FileUtils.rm(stemcell_file(stemcell_cid))
+      DELETE_STEMCELL_SCHEMA = Membrane::SchemaParser.parse { {stemcell_id: String} }
+      def delete_stemcell(stemcell_id)
+        validate_and_record_inputs(DELETE_STEMCELL_SCHEMA, __method__, stemcell_id)
+        FileUtils.rm(stemcell_file(stemcell_id))
+      end
+
+      CREATE_VM_SCHEMA = Membrane::SchemaParser.parse do
+        {
+          agent_id: String,
+          stemcell_id: String,
+          cloud_properties: Hash,
+          networks: Hash,
+          disk_cids: [String],
+          env: Hash,
+        }
       end
 
       # rubocop:disable ParameterLists
-      def create_vm(agent_id, stemcell, resource_pool, networks, disk_locality = nil, env = nil)
-      # rubocop:enable ParameterLists
+      def create_vm(agent_id, stemcell_id, cloud_properties, networks, disk_cids, env)
+        # rubocop:enable ParameterLists
         @logger.info('Dummy: create_vm')
+        validate_and_record_inputs(CREATE_VM_SCHEMA, __method__, agent_id, stemcell_id, cloud_properties, networks, disk_cids, env)
 
         ips = []
         cmd = commands.next_create_vm_cmd
 
-        if cmd.ip_address
-          # special case used by dynamic IP assignment tests: CPI always chooses its own IP
-          write_agent_default_network(agent_id, cmd.ip_address)
-          ips << { 'network' => 'cloud', 'ip' => cmd.ip_address }
-        else
-          networks.each do |network_name, network|
-            ips << { 'network' => network_name, 'ip' => network['ip'] }
+        if cmd.failed?
+          raise Bosh::Clouds::CloudError.new("Creating vm failed")
+        end
+
+        networks.each do |network_name, network|
+          if network['type'] != 'dynamic'
+            ips << { 'network' => network_name, 'ip' => network.fetch('ip') }
+          else
+            if cmd.ip_address
+              ip_address = cmd.ip_address
+            elsif cloud_properties['az_name']
+              ip_address = cmd.ip_address_for_az(cloud_properties['az_name'])
+            else
+              ip_address =  NetAddr::CIDRv4.new(rand(0..4294967295)).ip #collisions?
+            end
+
+            if ip_address
+              ips << { 'network' => network_name, 'ip' => ip_address }
+              write_agent_default_network(agent_id, ip_address)
+            end
           end
         end
 
         allocate_ips(ips)
 
         write_agent_settings(agent_id, {
-          agent_id: agent_id,
-          blobstore: @options['agent']['blobstore'],
-          ntp: [],
-          disks: { persistent: {} },
-          networks: networks,
-          vm: { name: "vm-#{agent_id}" },
-          cert: '',
-          mbus: @options['nats'],
-        })
+            agent_id: agent_id,
+            blobstore: @options['agent']['blobstore'],
+            ntp: [],
+            disks: { persistent: {} },
+            networks: networks,
+            vm: { name: "vm-#{agent_id}" },
+            cert: '',
+            mbus: @options['nats'],
+          })
 
         agent_pid = spawn_agent_process(agent_id)
+        vm = VM.new(agent_pid.to_s, agent_id, cloud_properties, ips)
 
-        FileUtils.mkdir_p(@running_vms_dir)
-        File.write(vm_file(agent_pid), JSON.dump("agent_id" => agent_id, "ips" => ips))
+        @vm_repo.save(vm)
 
-        agent_pid.to_s
+        vm.id
       end
 
-      def delete_vm(vm_name)
-        agent_pid = vm_name.to_i
+      DELETE_VM_SCHEMA = Membrane::SchemaParser.parse { {vm_cid: String} }
+      def delete_vm(vm_cid)
+        validate_and_record_inputs(DELETE_VM_SCHEMA, __method__, vm_cid)
+        commands.wait_for_unpause_delete_vms
+        detach_disks_attached_to_vm(vm_cid)
+        agent_pid = vm_cid.to_i
         Process.kill('KILL', agent_pid)
-        # rubocop:disable HandleExceptions
-      rescue Errno::EINVAL, Errno::ESRCH, Errno::EPERM => e
+
+          # rubocop:disable HandleExceptions
+      rescue Errno::ESRCH
         # rubocop:enable HandleExceptions
-        @logger.info("Dummy CPI delete_vm failed for agent pid #{vm_name}. #{e}")
       ensure
-        free_ips(ips_for_vm_id(vm_name)) if has_vm?(vm_name)
-        FileUtils.rm_rf(File.join(@base_dir, 'running_vms', vm_name))
+        free_ips(vm_cid)
+        FileUtils.rm_rf(File.join(@base_dir, 'running_vms', vm_cid))
       end
 
-      def reboot_vm(vm_id)
+      REBOOT_VM_SCHEMA = Membrane::SchemaParser.parse { {vm_cid: String} }
+      def reboot_vm(vm_cid)
+        validate_and_record_inputs(__method__, vm_cid)
         raise NotImplemented, 'Dummy CPI does not implement reboot_vm'
       end
 
-      def has_vm?(vm_id)
-        File.exists?(vm_file(vm_id))
+      HAS_VM_SCHEMA = Membrane::SchemaParser.parse { {vm_cid: String} }
+      def has_vm?(vm_cid)
+        validate_and_record_inputs(HAS_VM_SCHEMA, __method__, vm_cid)
+        @vm_repo.exists?(vm_cid)
       end
 
+      HAS_DISK_SCHEMA = Membrane::SchemaParser.parse { {disk_id: String} }
       def has_disk?(disk_id)
+        validate_and_record_inputs(HAS_DISK_SCHEMA, __method__, disk_id)
         File.exists?(disk_file(disk_id))
       end
 
-      def configure_networks(vm_id, networks)
-        cmd = commands.next_configure_networks_cmd(vm_id)
-
-        # The only configure_networks test so far only tests the negative case.
-        # If a positive case is added, the agent will need to be re-started.
-        # Normally runit would handle that.
-        if cmd.not_supported || true
-          raise NotSupported, 'Dummy CPI was configured to return NotSupported'
+      ATTACH_DISK_SCHEMA = Membrane::SchemaParser.parse { {vm_cid: String, disk_id: String} }
+      def attach_disk(vm_cid, disk_id)
+        validate_and_record_inputs(ATTACH_DISK_SCHEMA, __method__, vm_cid, disk_id)
+        if disk_attached?(disk_id)
+          raise "#{disk_id} is already attached to an instance"
         end
-      end
-
-      def attach_disk(vm_id, disk_id)
-        file = attachment_file(vm_id, disk_id)
+        file = attachment_file(vm_cid, disk_id)
         FileUtils.mkdir_p(File.dirname(file))
         FileUtils.touch(file)
 
-        agent_id = agent_id_for_vm_id(vm_id)
+        @logger.info("Attached disk: '#{disk_id}' to vm: '#{vm_cid}' at attachment file: #{file}")
+
+        agent_id = agent_id_for_vm_id(vm_cid)
         settings = read_agent_settings(agent_id)
         settings['disks']['persistent'][disk_id] = 'attached'
         write_agent_settings(agent_id, settings)
       end
 
-      def detach_disk(vm_id, disk_id)
-        FileUtils.rm(attachment_file(vm_id, disk_id))
+      DETACH_DISK_SCHEMA = Membrane::SchemaParser.parse { {vm_cid: String, disk_id: String} }
+      def detach_disk(vm_cid, disk_id)
+        validate_and_record_inputs(DETACH_DISK_SCHEMA, __method__, vm_cid, disk_id)
+        unless disk_attached_to_vm?(vm_cid, disk_id)
+          raise Bosh::Clouds::DiskNotAttached, "#{disk_id} is not attached to instance #{vm_cid}"
+        end
+        FileUtils.rm(attachment_file(vm_cid, disk_id))
 
-        agent_id = agent_id_for_vm_id(vm_id)
+        agent_id = agent_id_for_vm_id(vm_cid)
         settings = read_agent_settings(agent_id)
         settings['disks']['persistent'].delete(disk_id)
         write_agent_settings(agent_id, settings)
       end
 
-      def create_disk(size, cloud_properties, vm_locality = nil)
+      CREATE_DISK_SCHEMA = Membrane::SchemaParser.parse { {size: Integer, cloud_properties: Hash, vm_locality: String} }
+      def create_disk(size, cloud_properties, vm_locality)
+        validate_and_record_inputs(CREATE_DISK_SCHEMA, __method__, size, cloud_properties, vm_locality)
         disk_id = SecureRandom.hex
         file = disk_file(disk_id)
         FileUtils.mkdir_p(File.dirname(file))
@@ -146,11 +196,15 @@ module Bosh
         disk_id
       end
 
+      DELTE_DISK_SCHEMA = Membrane::SchemaParser.parse { {disk_id: String} }
       def delete_disk(disk_id)
+        validate_and_record_inputs(DELTE_DISK_SCHEMA, __method__, disk_id)
         FileUtils.rm(disk_file(disk_id))
       end
 
-      def snapshot_disk(_, metadata)
+      SNAPSHOT_DISK_SCHEMA = Membrane::SchemaParser.parse { {disk_id: String, metadata: Hash} }
+      def snapshot_disk(disk_id, metadata)
+        validate_and_record_inputs(SNAPSHOT_DISK_SCHEMA, __method__, disk_id, metadata)
         snapshot_id = SecureRandom.hex
         file = snapshot_file(snapshot_id)
         FileUtils.mkdir_p(File.dirname(file))
@@ -158,12 +212,28 @@ module Bosh
         snapshot_id
       end
 
+      DELETE_SNAPSHOT_SCHEMA = Membrane::SchemaParser.parse { {snapshot_id: String} }
       def delete_snapshot(snapshot_id)
+        validate_and_record_inputs(DELETE_SNAPSHOT_SCHEMA, __method__, snapshot_id)
         FileUtils.rm(snapshot_file(snapshot_id))
       end
 
+      SET_VM_METADATA_SCHEMA = Membrane::SchemaParser.parse { {vm_cid: String, metadata: Hash} }
+      def set_vm_metadata(vm_cid, metadata)
+        validate_and_record_inputs(SET_VM_METADATA_SCHEMA, __method__, vm_cid, metadata)
+      end
+
       # Additional Dummy test helpers
 
+      def prepare
+        FileUtils.mkdir_p(@base_dir)
+      end
+
+      def reset
+        FileUtils.rm_rf(@base_dir)
+        prepare
+      end
+
       def vm_cids
         # Shuffle so that no one relies on the order of VMs
         Dir.glob(File.join(@running_vms_dir, '*')).map { |vm| File.basename(vm) }.shuffle
@@ -178,9 +248,9 @@ module Bosh
         vm_cids.each do |agent_pid|
           begin
             Process.kill('KILL', agent_pid.to_i)
-          # rubocop:disable HandleExceptions
+              # rubocop:disable HandleExceptions
           rescue Errno::ESRCH
-          # rubocop:enable HandleExceptions
+            # rubocop:enable HandleExceptions
           end
         end
       end
@@ -189,7 +259,54 @@ module Bosh
         "#{@base_dir}/agent.#{agent_id}.log"
       end
 
-      def set_vm_metadata(vm, metadata); end
+      def read_cloud_properties(vm_cid)
+        @vm_repo.load(vm_cid).cloud_properties
+      end
+
+      def invocations
+        @inputs_recorder.read_all
+      end
+
+      def invocations_for_method(method)
+        @inputs_recorder.read(method)
+      end
+
+      def all_stemcells
+        files = Dir.entries(@base_dir).select { |file| file.match /stemcell_./ }
+
+        Dir.chdir(@base_dir) do
+          [].tap do |results|
+            files.each do |file|
+              # data --> [{ 'name' => 'ubuntu-stemcell', 'version': '1', 'image' => <image path> }]
+              data = YAML.load(File.read(file))
+              results << { 'id' => file.sub(/^stemcell_/, '') }.merge(data)
+            end
+          end.sort { |a, b| a[:version].to_i <=> b[:version].to_i }
+        end
+      end
+
+      def latest_stemcell
+        all_stemcells.last
+      end
+
+      def all_snapshots
+        if File.exists?(snapshot_file(''))
+          Dir.glob(snapshot_file('*'))
+        else
+          []
+        end
+      end
+
+      def all_ips
+        Dir.glob(File.join(@base_dir, 'dummy_cpi_networks', '*'))
+          .reject { |path| File.directory?(path) }
+          .map { |path| File.basename(path) }
+      end
+
+      def agent_dir_for_vm_cid(vm_cid)
+        agent_id = agent_id_for_vm_id(vm_cid)
+        agent_base_dir(agent_id)
+      end
 
       private
 
@@ -218,7 +335,7 @@ module Bosh
       def allocate_ips(ips)
         ips.each do |ip|
           begin
-            network_dir = File.join(@base_dir, 'dummy_cpi_networks', ip['network'])
+            network_dir = File.join(@base_dir, 'dummy_cpi_networks')
             FileUtils.makedirs(network_dir)
             open(File.join(network_dir, ip['ip']), File::WRONLY|File::CREAT|File::EXCL).close
           rescue Errno::EEXIST
@@ -229,18 +346,16 @@ module Bosh
         end
       end
 
-      def free_ips(ips)
-        ips.each do |ip|
-          FileUtils.rm_rf(File.join(@base_dir, 'dummy_cpi_networks', ip['network'], ip['ip']))
+      def free_ips(vm_cid)
+        return unless @vm_repo.exists?(vm_cid)
+        vm = @vm_repo.load(vm_cid)
+        vm.ips.each do |ip|
+          FileUtils.rm_rf(File.join(@base_dir, 'dummy_cpi_networks', ip['ip']))
         end
       end
 
-      def ips_for_vm_id(vm_id)
-        JSON.parse(File.read(vm_file(vm_id)))['ips']
-      end
-
-      def agent_id_for_vm_id(vm_id)
-        JSON.parse(File.read(vm_file(vm_id)))['agent_id']
+      def agent_id_for_vm_id(vm_cid)
+        @vm_repo.load(vm_cid).agent_id
       end
 
       def agent_settings_file(agent_id)
@@ -273,9 +388,9 @@ module Bosh
           'Infrastructure' => {
             'Settings' => {
               'Sources' => [{
-                'Type' => 'File',
-                'SettingsPath' => agent_settings_file(agent_id)
-              }],
+                  'Type' => 'File',
+                  'SettingsPath' => agent_settings_file(agent_id)
+                }],
               'UseRegistry' => true
             }
           }
@@ -296,64 +411,236 @@ module Bosh
         File.join(@base_dir, "stemcell_#{stemcell_id}")
       end
 
-      def vm_file(vm_id)
-        File.join(@running_vms_dir, vm_id.to_s)
-      end
-
       def disk_file(disk_id)
         File.join(@base_dir, 'disks', disk_id)
       end
 
-      def attachment_file(vm_id, disk_id)
-        File.join(@base_dir, 'attachments', vm_id, disk_id)
+      def disk_attached?(disk_id)
+        File.exist?(attachment_path(disk_id))
+      end
+
+      def disk_attached_to_vm?(vm_cid, disk_id)
+        File.exist?(attachment_file(vm_cid, disk_id))
+      end
+
+      def detach_disks_attached_to_vm(vm_cid)
+        @logger.info("Detaching disks for vm #{vm_cid}")
+        Dir.glob(attachment_file(vm_cid, '*')) do |file_path|
+          @logger.info("Detaching found attachment #{file_path}")
+          FileUtils.rm_rf(File.dirname(file_path))
+        end
+      end
+
+      def attachment_file(vm_cid, disk_id)
+        File.join(attachment_path(disk_id), vm_cid)
+      end
+
+      def attachment_path(disk_id)
+        File.join(@base_dir, 'attachments', disk_id)
       end
 
       def snapshot_file(snapshot_id)
         File.join(@base_dir, 'snapshots', snapshot_id)
       end
 
+      def validate_and_record_inputs(schema, the_method, *args)
+        parameter_names_to_values = parameter_names_to_values(the_method, *args)
+        begin
+          schema.validate(parameter_names_to_values)
+        rescue Membrane::SchemaValidationError => err
+          raise ArgumentError, "Invalid arguments sent to #{the_method}: #{err.message}"
+        end
+        record_inputs(the_method, parameter_names_to_values)
+      end
+
+      def record_inputs(method, args)
+        @inputs_recorder.record(method, args)
+      end
+
+      def parameter_names_to_values(the_method, *the_method_args)
+        hash = {}
+        method(the_method).parameters.each_with_index do |param, index|
+          hash[param[1]] = the_method_args[index]
+        end
+        hash
+      end
+
       # Example file system layout for arranging commands information.
       # Currently uses file system as transport but could be switch to use NATS.
       #   base_dir/cpi/create_vm/next -> {"something": true}
-      #   base_dir/cpi/configure_networks/<vm_id> -> (presence)
       class CommandTransport
         def initialize(base_dir, logger)
           @cpi_commands = File.join(base_dir, 'cpi_commands')
           @logger = logger
         end
 
-        def make_configure_networks_not_supported(vm_id)
-          @logger.info("Making configure_networks for #{vm_id} raise NotSupported")
-          path = File.join(@cpi_commands, 'configure_networks', vm_id)
+        def pause_delete_vms
+          @logger.info("Pausing delete_vms")
+          path = File.join(@cpi_commands, 'pause_delete_vms')
           FileUtils.mkdir_p(File.dirname(path))
           File.write(path, 'marker')
         end
 
-        def next_configure_networks_cmd(vm_id)
-          @logger.info("Reading configure_networks configuration for #{vm_id}")
-          vm_path = File.join(@cpi_commands, 'configure_networks', vm_id)
-          vm_supported = File.exists?(vm_path)
-          FileUtils.rm_rf(vm_path)
-          ConfigureNetworksCommand.new(vm_supported)
+        def unpause_delete_vms
+          @logger.info("Unpausing delete_vms")
+          FileUtils.rm_rf File.join(@cpi_commands, 'pause_delete_vms')
+          FileUtils.rm_rf File.join(@cpi_commands, 'wait_for_unpause_delete_vms')
+        end
+
+        def wait_for_delete_vms
+          @logger.info("Wait for delete_vms")
+          path = File.join(@cpi_commands, 'wait_for_unpause_delete_vms')
+          sleep(0.1) until File.exists?(path)
+        end
+
+        def wait_for_unpause_delete_vms
+          path = File.join(@cpi_commands, 'wait_for_unpause_delete_vms')
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, 'marker')
+
+          path = File.join(@cpi_commands, 'pause_delete_vms')
+          if File.exists?(path)
+            @logger.info("Wait for unpausing delete_vms")
+          end
+          sleep(0.1) while File.exists?(path)
         end
 
         def make_create_vm_always_use_dynamic_ip(ip_address)
           @logger.info("Making create_vm method to set ip address #{ip_address}")
-          always_path = File.join(@cpi_commands, 'create_vm', 'always')
           FileUtils.mkdir_p(File.dirname(always_path))
           File.write(always_path, ip_address)
         end
 
+        def set_dynamic_ips_for_azs(az_to_ips)
+          @logger.info("Making create_vm method to set #{az_to_ips.inspect}")
+          FileUtils.mkdir_p(File.dirname(azs_path))
+          File.write(azs_path, JSON.generate(az_to_ips))
+        end
+
+        def make_create_vm_always_fail
+          @logger.info("Making create_vm method always fail")
+          FileUtils.mkdir_p(File.dirname(failed_path))
+          File.write(failed_path, "")
+        end
+
+        def allow_create_vm_to_succeed
+          @logger.info("Allowing create_vm method to succeed (removing any mandatory failures)")
+          FileUtils.rm(failed_path)
+        end
+
         def next_create_vm_cmd
           @logger.info('Reading create_vm configuration')
-          always_path = File.join(@cpi_commands, 'create_vm', 'always')
           ip_address = File.read(always_path) if File.exists?(always_path)
-          CreateVmCommand.new(ip_address)
+          azs_to_ip = File.exists?(azs_path) ? JSON.load(File.read(azs_path)) : {}
+          failed = File.exists?(failed_path)
+          CreateVmCommand.new(ip_address, azs_to_ip, failed)
+        end
+
+        private
+
+        def azs_path
+          File.join(@cpi_commands, 'create_vm', 'az_ips')
+        end
+
+        def always_path
+          File.join(@cpi_commands, 'create_vm', 'always')
+        end
+
+        def failed_path
+          File.join(@cpi_commands, 'create_vm', 'fail')
         end
       end
 
       class ConfigureNetworksCommand < Struct.new(:not_supported); end
-      class CreateVmCommand < Struct.new(:ip_address); end
+      class CreateVmCommand
+        attr_reader :ip_address, :failed
+
+        def initialize(ip_address, azs_to_ip, failed)
+          @ip_address = ip_address
+          @azs_to_ip = azs_to_ip
+          @failed = failed
+        end
+
+        def ip_address_for_az(az_name)
+          @azs_to_ip[az_name]
+        end
+
+        def failed?
+          failed
+        end
+      end
+
+      class InputsRecorder
+        def initialize(base_dir, logger)
+          @cpi_inputs_dir = File.join(base_dir, 'cpi_inputs')
+          @logger = logger
+        end
+
+        def record(method, args)
+          FileUtils.mkdir_p(@cpi_inputs_dir)
+          data = {method_name: method, inputs: args}
+          @logger.info("Saving input for #{method} #{data} #{ordered_file_path}")
+          File.open(ordered_file_path, 'a') { |f| f.puts(JSON.dump(data)) }
+        end
+
+        def read(method_name)
+          @logger.info("Reading input for #{method_name}")
+          read_all.select do |invocation|
+            invocation.method_name == method_name
+          end
+        end
+
+        def read_all
+          @logger.info("Reading all inputs: #{File.read(ordered_file_path)}")
+          result = []
+          File.read(ordered_file_path).split("\n").each do |request|
+            data = JSON.parse(request)
+            result << CpiInvocation.new(data['method_name'], data['inputs'])
+          end
+          result
+        end
+
+        def ordered_file_path
+          File.join(@cpi_inputs_dir, 'all_requests')
+        end
+      end
+
+      class VM < Struct.new(:id, :agent_id, :cloud_properties, :ips)
+      end
+
+      class VMRepo
+        def initialize(running_vms_dir)
+          @running_vms_dir = running_vms_dir
+          FileUtils.mkdir_p(@running_vms_dir)
+        end
+
+        def load(id)
+          attrs = JSON.parse(File.read(vm_file(id)))
+          VM.new(id, attrs.fetch('agent_id'), attrs.fetch('cloud_properties'), attrs.fetch('ips'))
+        end
+
+        def exists?(id)
+          File.exists?(vm_file(id))
+        end
+
+        def save(vm)
+          serialized_vm = JSON.dump({
+              'agent_id' => vm.agent_id,
+              'cloud_properties' => vm.cloud_properties,
+              'ips' => vm.ips,
+            })
+
+          File.write(vm_file(vm.id), serialized_vm)
+        end
+
+        private
+
+        def vm_file(vm_cid)
+          File.join(@running_vms_dir, vm_cid)
+        end
+      end
+
+      class CpiInvocation < Struct.new(:method_name, :inputs); end
     end
   end
 end