twistlock-control 0.0.1

data/lib/twistlock_control/entity.rb

@@ -0,0 +1,63 @@
+require 'virtus'
+
+module TwistlockControl
+	# An entity is basically a struct with typed fields.
+	class Entity
+		include Virtus.model
+
+		def ==(other)
+			return false unless other.respond_to? :attributes
+			attributes == other.attributes
+		end
+
+		def serialize
+			attributes.dup
+		end
+	end
+
+	# A persisted entity is an entity that has its own persistant
+	# storage repository.
+	class PersistedEntity < Entity
+		def self.find_by_id(id)
+			deserialize repository.find_by_id(id)
+		end
+
+		def self.deserialize(attrs)
+			return nil if attrs.nil?
+			new(attrs)
+		end
+
+		def self.find_with_ids(ids)
+			repository.find_with_ids(ids).map { |a| deserialize a }
+		end
+
+		def self.all
+			repository.all.map { |a| deserialize a }
+		end
+
+		def save
+			repository.save(serialize)
+		end
+
+		def remove
+			repository.remove(id)
+		end
+
+		def repository
+			self.class.repository
+		end
+
+		def self.inherited(subclass)
+			subclass.class_exec do
+				def self.repository(repository = nil)
+					return @repository = repository if repository
+					return @repository if @repository
+					return superclass.repository if superclass.respond_to?(:repository)
+
+					fail "#{name} has not defined a repository."
+				end
+			end
+			super(subclass)
+		end
+	end
+end

data/lib/twistlock_control/provisioner_api.rb

@@ -0,0 +1,43 @@
+require 'net/http'
+require 'uri'
+
+module TwistlockControl
+	# The provisioner api provides a direct synchronous interface to a provisioner
+	# at the url it is initialized with.
+	class ProvisionerAPI
+		attr_reader :url
+
+		def initialize(url)
+			@url = url
+		end
+
+		def provision_container(container_configuration)
+			container = container_configuration.container
+			add_container(container.name, container.url)
+			JSON.parse post('containers', name: container.name)
+		end
+
+		def container_description(name)
+			JSON.parse get("templates/#{name}")
+		end
+
+		def add_container(name, url)
+			JSON.parse post('templates', name: name, url: url)
+		end
+
+		private
+
+		def uri(path)
+			URI(url + '/' + path)
+		end
+
+		def get(path)
+			Net::HTTP.get uri(path)
+		end
+
+		def post(path, params)
+			result = Net::HTTP.post_form uri(path), params
+			result.body
+		end
+	end
+end

data/lib/twistlock_control/rethinkdb_repository.rb

@@ -0,0 +1,74 @@
+module TwistlockControl
+	# Some helper functions around access to RethinkDB collections
+	class RethinkDBRepository
+		def self.[](table_name)
+			new(table_name)
+		end
+
+		def initialize(table_name)
+			@table_name = table_name
+		end
+
+		attr_accessor :table_name
+
+		def table
+			TwistlockControl.database.table(table_name)
+		end
+
+		def save(attributes)
+			with_connection do |conn|
+				table.get(attributes[:id]).replace(attributes).run(conn)
+			end
+		end
+
+		def find_by_id(id)
+			with_connection do |conn|
+				table.get(id).run(conn)
+			end
+		end
+
+		def find_by_attributes(attrs)
+			with_connection do |conn|
+				table.filter(attrs).limit(1).run(conn).first
+			end
+		end
+
+		def find_with_ids(ids)
+			with_connection do |conn|
+				table.get_all(*ids).run(conn)
+			end
+		end
+
+		def remove(id)
+			with_connection do |conn|
+				table.get(id).delete.run(conn)
+			end
+		end
+
+		def all
+			with_connection do |conn|
+				table.run(conn)
+			end
+		end
+
+		def with_connection
+			TwistlockControl.with_connection do |conn|
+				yield conn
+			end
+		end
+
+		def create_table
+			with_connection do |conn|
+				TwistlockControl.database.table_create(table_name).run(conn)
+			end
+		rescue RethinkDB::RqlRuntimeError
+			nil
+		end
+
+		def delete_all
+			with_connection do |conn|
+				table.delete.run(conn)
+			end
+		end
+	end
+end

data/lib/twistlock_control/version.rb

@@ -0,0 +1,4 @@
+# Update this for releases
+module TwistlockControl
+	VERSION = '0.0.1'
+end

data/spec/actions/container_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+include TwistlockControl
+
+describe Actions::Container do
+	attr_reader :container
+
+	describe 'adding a container' do
+		it 'should persist the container and synchronize its description' do
+			dir = Dir.pwd + '/../redis-container'
+			container = Actions::Container.add(name: 'redis', url: dir)
+
+			container = Entities::Container.find_by_id(container.id)
+			expect(container.url).to eq(dir)
+			expect(container.description).to be_a(ContainerDescription)
+			expect(container.description.name).to eq('redis')
+		end
+	end
+end

data/spec/actions/provisioner_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+include TwistlockControl
+
+describe Actions::Provisioner do
+	describe '.add' do
+		it 'can be initialized from its attributes' do
+			prov = Actions::Provisioner.add(name: 'MyName', url: 'url')
+			expect(prov).to_not be_nil
+			expect(prov.name).to eq('MyName')
+		end
+
+		it 'can be persisted and retrieved from the database' do
+			prov = Actions::Provisioner.add(name: 'MyName', url: 'url')
+			retrieved = Entities::Provisioner.find_by_id(prov.id)
+			expect(retrieved).to eq(prov)
+		end
+	end
+
+	describe '.update' do
+		it 'updates a provisioner and persists it' do
+			prov = Actions::Provisioner.add(name: 'MyName', url: 'url')
+			Actions::Provisioner.update(prov.id, name: 'MyNewName')
+			prov = Entities::Provisioner.find_by_id(prov.id)
+			expect(prov.name).to eq('MyNewName')
+		end
+	end
+
+	describe '.remove' do
+		it 'removes provisioners' do
+			prov = Actions::Provisioner.add(name: 'MyName', url: 'url')
+			prov.remove
+			prov = Entities::Provisioner.find_by_id(prov.id)
+			expect(prov).to be_nil
+		end
+	end
+end

data/spec/actions/service_instance_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+include TwistlockControl
+
+describe Actions::ServiceInstance do
+	def make_service
+		service = Entities::CompositeService.new(name: 'MyService')
+		@container = Entities::Container.new(name: 'MyContainer', url: 'someUrl')
+		@container.save
+		service.service_relations[@container.name] = @container.id
+		service.save
+		service
+	end
+
+	# The user creates a service instance to prepare for provisioning
+	# a service
+	describe 'Creating a service instance' do
+		def verify_service_instance(service, instance)
+			expect(instance.configuration).to be_a(Entities::CompositeConfiguration)
+			expect(instance.configuration.service_id).to eq(service.id)
+			verify_configurations(instance.configuration.configurations)
+			true
+		end
+
+		def verify_configurations(configurations)
+			expect(configurations.length).to eq(1)
+			expect(configurations[0]).to be_a(Entities::ContainerConfiguration)
+			expect(configurations[0].service_id).to eq(@container.id)
+		end
+
+		it 'should create a service instance that has container descriptions
+		    for each container of the service template' do
+			service = make_service
+			instance = Actions::ServiceInstance.add('my-instance', service)
+			expect(verify_service_instance(service, instance)).to be(true)
+		end
+
+		it 'should be possible to retrieve a service instance from persistent storage' do
+			service = make_service
+			instance = Actions::ServiceInstance.add('my-instance', service)
+
+			instance = Entities::ServiceInstance.find_by_id(instance.id)
+			expect(instance).to_not be(nil)
+			expect(verify_service_instance(service, instance)).to be(true)
+		end
+	end
+end

data/spec/collections_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+include TwistlockControl
+
+describe Collections do
+	describe 'provisioners' do
+		it 'should be possible to listen for changes' do
+			expect(Collections.provisioners).to respond_to(:changes)
+			expect(Collections.services).to respond_to(:changes)
+			expect(Collections.service_instances).to respond_to(:changes)
+			expect(Collections.container_instances).to respond_to(:changes)
+		end
+	end
+end

data/spec/entities/composite_service_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+require 'entities/shared_service_specs'
+
+include TwistlockControl::Entities
+
+describe CompositeService do
+	it_should_behave_like 'a service'
+
+	it 'can be created and added to an service' do
+		service = CompositeService.new(name: 'MyService')
+		service.save
+		app = CompositeService.new(name: 'MyName')
+		app.service_relations[service.name] = service.id
+		app.save
+		expect(app.services).to include(service)
+		app = CompositeService.find_by_id(app.id)
+		expect(app.services).to include(service)
+	end
+
+	it 'can have containers added to it' do
+		container = Container.new(name: 'MyContainer', url: 'someUrl')
+		container.save
+		app = CompositeService.new(name: 'MyName')
+		app.service_relations[container.name] = container.id
+		app.save
+		app = CompositeService.find_by_id(app.id)
+		expect(app.services).to include(container)
+	end
+
+	it 'can link two containers together' do
+		container = Container.new(name: 'redis', url: 'git@github.com:d-snp/redis-container.git')
+		container.save
+		container2 = Container.new(name: 'rails', url: 'git@github.com:d-snp/rails-container.git')
+		container2.save
+		app = CompositeService.new(name: 'WebApp')
+		app.save
+		app.service_relations[container.name] = container.id
+		app.service_relations[container2.name] = container2.id
+
+		app.links.push(ServiceLink.new(
+			provider_name: container.name,
+			provider_port_name: 'redis',
+			consumer_name: container2.name,
+			consumer_port_name: 'redis'
+		))
+		app.save
+		app = CompositeService.find_by_id(app.id)
+
+		link = app.links[0]
+		expect(link).to_not be_nil
+		expect(link.provider_name).to eq(container.name)
+		expect(link.consumer_name).to eq(container2.name)
+	end
+
+	it 'can find a bunch of services by ids' do
+		ids = []
+		(1..3).each do |i|
+			service = CompositeService.new(name: "Service#{i}")
+			ids << service.id
+			service.save
+		end
+		services = CompositeService.find_with_ids(ids)
+		expect(services.length).to be(3)
+	end
+
+	it 'can be initialized from its attributes' do
+		app = CompositeService.new(name: 'MyName')
+		expect(app.respond_to? :name).to be(true)
+		expect(app.name).to eq('MyName')
+	end
+
+	it 'can be persisted and retrieved from the database' do
+		app = CompositeService.new(name: 'MyName')
+		app.save
+		retrieved = CompositeService.find_by_id(app.id)
+		expect(retrieved).to eq(app)
+	end
+
+	it 'can get a list of services' do
+		(1..3).each do |i|
+			app = CompositeService.new(name: "App#{i}")
+			app.save
+		end
+		retrieved = CompositeService.all
+		expect(retrieved.length).to eq(3)
+	end
+
+	it 'can remove services' do
+		app = CompositeService.new(name: 'MyName')
+		app.save
+		app.remove
+		app = CompositeService.find_by_id(app.id)
+		expect(app).to be_nil
+	end
+
+	it 'should not somehow get confused with other tables' do
+		app = CompositeService.new(name: 'MyName')
+		app.save
+		prov = Provisioner.new(name: 'MyName', url: 'someUrl')
+		prov.save
+		expect(CompositeService.all.length).to be(1)
+		expect(Provisioner.all.length).to be(1)
+	end
+
+	describe 'instances' do
+		before :each do
+			@container = Container.new(name: 'redis', url: 'git@github.com:d-snp/redis-container.git')
+			@container.save
+			@container2 = Container.new(name: 'rails', url: 'git@github.com:d-snp/rails-container.git')
+			@container2.save
+			@app = CompositeService.new(name: 'WebApp')
+			@app.save
+			@app.service_relations[@container.name] = @container.name
+		end
+
+		it 'can expose a port exposed by a service' do
+			# expose the redis provided service of the the redis container as 'redis'
+			@app.provided_services['redis'] = { 'redis' => 'redis' }
+			@app.save
+			app = CompositeService.find_by_id(@app.id)
+			exposed = app.provided_services['redis']
+			expect(exposed).to_not be_nil
+			expect(exposed).to eq('redis' => 'redis')
+		end
+	end
+end

data/spec/entities/container_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'entities/shared_service_specs'
+
+include TwistlockControl
+
+describe Entities::Container do
+	it_should_behave_like 'a service'
+end