bebox 0.0.1

data/lib/bebox/node.rb

@@ -0,0 +1,308 @@
+require 'tilt'
+require 'bebox/logger'
+
+module Bebox
+  class Node
+
+    include Bebox::Logger
+
+    attr_accessor :environment, :project_root, :hostname, :ip, :created_at, :started_at, :finished_at
+
+    def initialize(environment, project_root, hostname, ip)
+      self.environment = environment
+      self.project_root = project_root
+      self.hostname = hostname
+      self.ip = ip
+    end
+
+    # Create all files and directories related to an node
+    def create
+      create_hiera_template
+      create_manifests_node
+      create_node_checkpoint
+    end
+
+    # Delete all files and directories related to an node
+    def remove
+      remove_vagrant_box if self.environment == 'vagrant' && prepared_nodes_count > 0
+      remove_checkpoints
+      remove_hiera_template
+      remove_manifests_node
+    end
+
+    # List existing nodes for environment and type (nodes, prepared_nodes)
+    def self.list(project_root, environment, node_type)
+      Dir["#{environments_path(project_root)}/#{environment}/#{node_type}/*"].map { |f| File.basename(f, ".*") }
+    end
+
+    # Get node checkpoint parameter from the yml file
+    def checkpoint_parameter_from_file(node_type, parameter)
+      Bebox::Node.checkpoint_parameter_from_file(self.project_root, self.environment, self.hostname, node_type, parameter)
+    end
+
+    # Get node checkpoint parameter from the yml file
+    def self.checkpoint_parameter_from_file(project_root, environment, hostname, node_type, parameter)
+      node_config = YAML.load_file("#{environments_path(project_root)}/#{environment}/#{node_type}/#{hostname}.yml")
+      node_config[parameter]
+    end
+
+    # Prepare the configured nodes
+    def prepare
+      started_at = DateTime.now.to_s
+      prepare_deploy
+      prepare_common_installation
+      puppet_installation
+      create_prepare_checkpoint(started_at)
+    end
+
+    # Deploy the puppet prepare directory
+    def prepare_deploy
+      `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy:setup -S phase=node_prepare HOSTS=#{self.hostname}`
+      `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy -S phase=node_prepare HOSTS=#{self.hostname}`
+    end
+
+    # Execute through capistrano the common development installation packages
+    def prepare_common_installation
+      `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy:prepare_installation:common -S phase=node_prepare HOSTS=#{self.hostname}`
+    end
+
+    # Execute through capistrano the puppet installation
+    def puppet_installation
+      `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy:prepare_installation:puppet -S phase=node_prepare HOSTS=#{self.hostname}`
+    end
+
+    # Create the checkpoints for the prepared nodes
+    def create_prepare_checkpoint(started_at)
+      self.started_at = started_at
+      self.finished_at = DateTime.now.to_s
+      node_template = Tilt::ERBTemplate.new("#{Bebox::Node::templates_path}/node/prepared_node.yml.erb")
+      File.open("#{self.project_root}/.checkpoints/environments/#{self.environment}/prepared_nodes/#{self.hostname}.yml", 'w') do |f|
+        f.write node_template.render(nil, :node => self)
+      end
+    end
+
+    # Create the puppet hiera template file
+    def create_hiera_template
+      options = {}
+      options[:ssh_key] = Bebox::Project.public_ssh_key_from_file(self.project_root, self.environment)
+      options[:project_name] = Bebox::Project.shortname_from_file(self.project_root)
+      Bebox::Provision.generate_hiera_for_steps(self.project_root, "node.yaml.erb", self.hostname, options)
+    end
+
+    # Create the node in the puppet manifests file
+    def create_manifests_node
+      Bebox::Provision.add_node_to_step_manifests(self.project_root, self)
+    end
+
+    # Prepare the vagrant nodes
+    def prepare_vagrant
+      project_name = Bebox::Project.name_from_file(self.project_root)
+      vagrant_box_base = Bebox::Project.vagrant_box_base_from_file(self.project_root)
+      configure_local_hosts(project_name)
+      add_vagrant_node(project_name, vagrant_box_base)
+    end
+
+    # Add the boxes to vagrant for each node
+    def add_vagrant_node(project_name, vagrant_box_base)
+      already_installed_boxes = installed_vagrant_box_names
+      box_name = "#{project_name}-#{self.hostname}"
+      info "Adding server to vagrant: #{self.hostname}..."
+      `cd #{self.project_root} && vagrant box add #{box_name} #{vagrant_box_base}` unless already_installed_boxes.include? box_name
+    end
+
+    # Up the vagrant boxes in Vagrantfile
+    def self.up_vagrant_nodes(project_root)
+      `cd #{project_root} && vagrant up --provision`
+    end
+
+    # Halt the vagrant boxes running
+    def self.halt_vagrant_nodes(project_root)
+      `cd #{project_root} && vagrant halt`
+    end
+
+    # return an Array with the names of the currently installed vagrant boxes
+    # @returns Array
+    def installed_vagrant_box_names
+      (`cd #{self.project_root} && vagrant box list`).split("\n").map{|vagrant_box| vagrant_box.split(' ').first}
+    end
+
+    # returns an Array of the Node objects for an environment
+    # @returns Array
+    def self.nodes_in_environment(project_root, environment, node_type)
+      node_objects = []
+      nodes = Bebox::Node.list(project_root, environment, node_type)
+      nodes.each do |hostname|
+        ip = Bebox::Node.checkpoint_parameter_from_file(project_root, environment, hostname, node_type, 'ip')
+        node_objects << Bebox::Node.new(environment, project_root, hostname, ip)
+      end
+      node_objects
+    end
+
+    # Generate the Vagrantfile
+    def self.generate_vagrantfile(project_root, nodes)
+      template = Tilt::ERBTemplate.new("#{templates_path}/node/Vagrantfile.erb")
+      network_interface = RUBY_PLATFORM =~ /darwin/ ? 'en0' : 'eth0'
+      project_name = Bebox::Project.name_from_file(project_root)
+      vagrant_box_provider = Bebox::Project.vagrant_box_provider_from_file(project_root)
+      File.open("#{project_root}/Vagrantfile", 'w') do |f|
+        f.write template.render(nil, :nodes => nodes, :project_name => project_name,
+          :vagrant_box_provider => vagrant_box_provider, :network_interface => network_interface)
+      end
+    end
+
+    # Backup and add the vagrant hosts to local hosts file
+    def configure_local_hosts(project_name)
+      info "\nPlease provide your account password, if ask you, to configure the local hosts file."
+      backup_local_hosts(project_name)
+      add_to_local_hosts
+    end
+
+    # Add the vagrant hosts to the local hosts file
+    def add_to_local_hosts
+      # Get the content of the hosts file
+      hosts_content = File.read("#{local_hosts_path}/hosts").gsub(/\s+/, ' ').strip
+      # Put the node lines in hosts file if not exist
+      line = "#{self.ip} #{self.hostname}"
+      node_present = (hosts_content =~ /#{self.ip}\s+#{self.hostname}/) ? true : false
+      `echo '#{line}     # Added by bebox' >> #{local_hosts_path}/hosts` unless node_present
+    end
+
+    # Backup the local hosts file
+    def backup_local_hosts(project_name)
+      # Make a backup of hosts file
+      hosts_backup_file = "#{local_hosts_path}/hosts_before_#{project_name}"
+      `sudo cp #{local_hosts_path}/hosts #{hosts_backup_file}` unless File.exist?(hosts_backup_file)
+    end
+
+    # Obtain the local hosts file for the OS
+    def local_hosts_path
+      RUBY_PLATFORM =~ /darwin/ ? '/private/etc' : '/etc'
+    end
+
+    # Create checkpoint for node
+    def create_node_checkpoint
+      # Set the creation time for the node
+      self.created_at = DateTime.now.to_s
+      # Create the checkpoint file from template
+      node_template = Tilt::ERBTemplate.new("#{Bebox::Node::templates_path}/node/node.yml.erb")
+      File.open("#{self.project_root}/.checkpoints/environments/#{self.environment}/nodes/#{self.hostname}.yml", 'w') do |f|
+        f.write node_template.render(nil, :node => self)
+      end
+    end
+
+    # Remove checkpoints for node
+    def remove_checkpoints
+      `cd #{self.project_root} && rm -rf .checkpoints/environments/#{self.environment}/{nodes,prepared_nodes,steps/step-{0..3}}/#{self.hostname}.yml`
+    end
+
+    # Remove puppet hiera template file
+    def remove_hiera_template
+      Bebox::Provision.remove_hiera_for_steps(self.project_root, self.hostname)
+    end
+
+    # Remove node from puppet manifests
+    def remove_manifests_node
+      Bebox::Provision.remove_node_for_steps(self.project_root, self.hostname)
+    end
+
+    # Remove the specified boxes from vagrant
+    def remove_vagrant_box
+      project_name = Bebox::Project.name_from_file(self.project_root)
+      vagrant_box_provider = Bebox::Project.vagrant_box_provider_from_file(self.project_root)
+      `cd #{self.project_root} && vagrant destroy -f #{self.hostname}`
+      `cd #{self.project_root} && vagrant box remove #{project_name}-#{self.hostname} --provider #{vagrant_box_provider}`
+    end
+
+    # Get the templates path inside the gem
+    def self.templates_path
+      File.join((File.expand_path '..', File.dirname(__FILE__)), 'templates')
+    end
+
+    # Get the environments path for project
+    def self.environments_path(project_root)
+      "#{project_root}/.checkpoints/environments"
+    end
+
+    # Regenerate the deploy file for the environment
+    def self.regenerate_deploy_file(project_root, environment, nodes)
+      template_name = (environment == 'vagrant') ? 'vagrant' : "environment"
+      config_deploy_template = Tilt::ERBTemplate.new("#{templates_path}/project/config/deploy/#{template_name}.erb")
+      File.open("#{project_root}/config/deploy/#{environment}.rb", 'w') do |f|
+        f.write config_deploy_template.render(nil, :nodes => nodes, :environment => environment)
+      end
+    end
+
+    # Return the running status of vagrant node
+    def vagrant_box_running?
+      status = `cd #{self.project_root} && vagrant status`
+      (status =~ /#{self.hostname}\s+running/) ? true : false
+    end
+
+    # Return the existence status of vagrant node
+    def vagrant_box_exist?
+      vagrant_boxes = `cd #{project_root} && vagrant box list`
+      project_name = Bebox::Project.name_from_file(self.project_root)
+      vagrant_box_provider = Bebox::Project.vagrant_box_provider_from_file(self.project_root)
+      (vagrant_boxes =~ /#{project_name}-#{self.hostname}\s+\(#{vagrant_box_provider}/) ? true : false
+    end
+
+    # Count the number of prepared nodes
+    def prepared_nodes_count
+      Bebox::Node.list(self.project_root, self.environment, 'prepared_nodes').count
+    end
+
+    # Return a description string for the node provision state
+    def self.node_provision_state(project_root, environment, node)
+      provision_state = ''
+      checkpoint_directories = %w{nodes prepared_nodes steps/step-0 steps/step-1 steps/step-2 steps/step-3}
+      checkpoint_directories.each do |checkpoint_directory|
+        checkpoint_directory_path = "#{project_root}/.checkpoints/environments/#{environment}/#{checkpoint_directory}/#{node}.yml"
+        if File.exist?(checkpoint_directory_path)
+          creation_date = Bebox::Node.node_creation_date(project_root, environment, checkpoint_directory, node)
+          provision_state = "#{state_from_checkpoint(checkpoint_directory)} at #{creation_date}"
+        end
+      end
+      provision_state
+    end
+
+    # Get the corresponding state from checkpoint directory
+    def self.state_from_checkpoint(checkpoint)
+      case checkpoint
+        when 'nodes'
+          'Allocated'
+        when 'prepared_nodes'
+          'Prepared'
+        when 'steps/step-0'
+          'Provisioned Fundamental step-0'
+        when 'steps/step-1'
+          'Provisioned Users layer step-1'
+        when 'steps/step-2'
+          'Provisioned Services layer step-2'
+        when 'steps/step-3'
+          'Provisioned Security layer step-3'
+      end
+    end
+
+    # Obtain the node creation_at of finished_at parameter of a node
+    def self.node_creation_date(project_root, environment, node_type, node)
+      node_config = YAML.load_file("#{project_root}/.checkpoints/environments/#{environment}/#{node_type}/#{node}.yml")
+      (node_type == 'nodes') ? node_config['created_at'] : node_config['finished_at']
+    end
+
+    # Count the number of nodes in all environments
+    def self.count_all_nodes_by_type(project_root, node_type)
+      nodes_count = 0
+      environments = Bebox::Environment.list(project_root)
+      environments.each do |environment|
+        nodes_count += Bebox::Node.list(project_root, environment, node_type).count
+      end
+      nodes_count
+    end
+
+    # Restore the previous local hosts file
+    def restore_local_hosts(project_name)
+      `sudo cp #{local_hosts_path}/hosts_before_#{project_name} #{local_hosts_path}/hosts`
+      `sudo rm #{local_hosts_path}/hosts_before_#{project_name}`
+    end
+  end
+end

data/lib/bebox/profile.rb

@@ -0,0 +1,102 @@
+require 'tilt'
+
+module Bebox
+  class Profile
+
+    attr_accessor :project_root, :name, :path
+
+    def initialize(name, project_root, path)
+      self.project_root = project_root
+      self.name = name
+      self.path = path
+    end
+
+    # Create all files and directories related to a profile
+    def create
+      create_profile_directory
+      generate_manifests_file
+      generate_puppetfile
+    end
+
+    # Delete all files and directories related to a profile
+    def remove
+      `cd #{self.project_root} && rm -r puppet/profiles/#{relative_path}`
+    end
+
+    # Lists existing profiles
+    def self.list(project_root)
+      Dir.chdir("#{project_root}/puppet/profiles") { Dir.glob("**/manifests").map{ |f| File.dirname(f) } }
+      # Dir["#{project_root}/puppet/profiles/*"].map { |f| File.basename(f) }
+    end
+
+    # Create the directories for the profile
+    def create_profile_directory
+      `cd #{self.project_root} && mkdir -p puppet/profiles/#{relative_path}/manifests`
+    end
+
+    # Generate the manifests init.pp file
+    def generate_manifests_file
+      manifests_template = Tilt::ERBTemplate.new("#{templates_path}/puppet/profiles/manifests/init.pp.erb")
+      File.open("#{absolute_path}/manifests/init.pp", 'w') do |f|
+        f.write manifests_template.render(nil, :profile => self)
+      end
+    end
+
+    # Generate the Puppetfile
+    def generate_puppetfile
+      puppetfile_template = Tilt::ERBTemplate.new("#{templates_path}/puppet/profiles/Puppetfile.erb")
+      File.open("#{absolute_path}/Puppetfile", 'w') do |f|
+        f.write puppetfile_template.render(nil)
+      end
+    end
+
+    # Path to the templates directory in the gem
+    def templates_path
+      File.join((File.expand_path '..', File.dirname(__FILE__)), 'templates')
+    end
+
+    # Path to the profile directory in the project
+    def absolute_path
+      "#{self.project_root}/puppet/profiles/#{relative_path}"
+    end
+
+    # Counts existing profiles
+    def self.profiles_count(project_root)
+      Bebox::Profile.list(project_root).count
+    end
+
+    # Check if the profile has a valid name
+    def self.valid_name?(name)
+      valid_name = (name =~ /\A[a-z][a-z0-9_]*\Z/).nil? ? false : true
+      valid_name && !Bebox::RESERVED_WORDS.include?(name)
+    end
+
+    # Check if the profile has a valid path name
+    def self.valid_pathname?(pathname)
+      #Split the name and validate each path part
+      pathname.split('/').each do |path_child|
+        valid_name = (path_child =~ /\A[a-z][a-z0-9_]*\Z/).nil? ? false : true
+        valid_name && !Bebox::RESERVED_WORDS.include?(path_child)
+        return false unless valid_name
+      end
+      # Return true if all parts are valid
+      true
+    end
+
+    # Clean a path to make it valid
+    def self.cleanpath(path_name)
+      valid_path = Pathname.new(path_name).cleanpath.to_path.split('/').reject{|c| c.empty? }
+      return valid_path.nil? ? '' : valid_path.join('/')
+    end
+
+    # Create the profile path relative to the project
+    def relative_path
+      File.join("#{self.path}", "#{self.name}")
+    end
+
+    # Generate the namespace name from the profile relative path
+    def namespace_name
+      relative_path.gsub('/','::')
+    end
+  end
+end

data/lib/bebox/project.rb

@@ -0,0 +1,259 @@
+require 'tilt'
+require 'bebox/environment'
+require 'bebox/provision'
+require 'bebox/logger'
+
+module Bebox
+  class Project
+
+    include Bebox::Logger
+
+    attr_accessor :name, :vagrant_box_base, :parent_path, :vagrant_box_provider, :environments, :path, :created_at
+
+    def initialize(name, vagrant_box_base, parent_path, vagrant_box_provider, default_environments = [])
+      self.name = name
+      self.vagrant_box_base = vagrant_box_base
+      self.parent_path = parent_path
+      self.vagrant_box_provider = vagrant_box_provider
+      self.environments = []
+      self.path = "#{self.parent_path}/#{self.name}"
+      default_environments.each do |env|
+        self.environments << Bebox::Environment.new(env, self.path)
+      end
+    end
+
+		# Project creation phase
+    def create
+    	create_project_directory
+      create_puppet_base
+      create_project_config
+      create_checkpoints
+      info "Bundle project ..."
+      bundle_project
+    end
+
+    # Obtain the project name without 'bebox-' prefix
+    def shortname
+      self.name.gsub("bebox-", "")
+    end
+
+    # Create project directory
+    def create_project_directory
+      `mkdir -p #{self.parent_path}/#{self.name}`
+    end
+
+    # Generate project config files
+    def create_project_config
+      # Create deploy directories
+      create_config_deploy_directories
+      # Generate dot files
+      generate_dot_bebox_file
+      generate_gitignore_file
+      # Generate ruby version file
+      generate_ruby_version
+      # Generate Capfile and deploy files
+      create_capfile
+      generate_deploy_file
+      # Generate Gemfile
+      create_gemfile
+      # Create the default environments
+      create_default_environments
+    end
+
+    # Get Project vagrant box provider from the .bebox file
+    def self.vagrant_box_provider_from_file(project_root)
+      project_config = YAML.load_file("#{project_root}/.bebox")
+      project_config['vagrant_box_provider']
+    end
+
+    # Get Project vagrant box base from the .bebox file
+    def self.vagrant_box_base_from_file(project_root)
+      project_config = YAML.load_file("#{project_root}/.bebox")
+      project_config['vagrant_box_base']
+    end
+
+    # Get short project name from the .bebox file
+    def self.shortname_from_file(project_root)
+      project_name = self.name_from_file(project_root)
+      project_name.gsub("bebox-", "")
+    end
+
+    # Get Project name from the .bebox file
+    def self.name_from_file(project_root)
+      project_config = YAML.load_file("#{project_root}/.bebox")
+      project_config['project']
+    end
+
+    # Create rbenv local
+    def generate_ruby_version
+      File.open("#{self.path}/.ruby-version", 'w') do |f|
+        f.write RUBY_VERSION
+      end
+    end
+
+    # Generate .bebox file
+    def generate_dot_bebox_file
+      # Set the creation time for the project
+      self.created_at = DateTime.now.to_s
+      # Create the .bebox file from template
+      dotbebox_template = Tilt::ERBTemplate.new("#{Bebox::Project.templates_path}/project/dot_bebox.erb")
+      File.open("#{self.path}/.bebox", 'w') do |f|
+        f.write dotbebox_template.render(nil, project: self)
+      end
+    end
+
+    # Generate .gitignore file
+    def generate_gitignore_file
+      gitignore_template = Tilt::ERBTemplate.new("#{Bebox::Project.templates_path}/project/gitignore.erb")
+      File.open("#{self.path}/.gitignore", 'w') do |f|
+        f.write gitignore_template.render(nil, steps: Bebox::PROVISION_STEP_NAMES)
+      end
+    end
+
+    # Create templates directories
+    def create_templates_directories
+      `cd #{self.path} && mkdir -p templates/{roles,profiles}`
+    end
+
+    # Create the default base roles and profiles in the project
+    def copy_default_roles_profiles
+      # Copy default roles and profiles to project templates directory
+      `cp -R #{Bebox::Project.templates_path}/puppet/default_roles/* #{self.path}/templates/roles/`
+      `cp -R #{Bebox::Project.templates_path}/puppet/default_profiles/* #{self.path}/templates/profiles/`
+      # Copy default roles and profiles to project roles and profiles available
+      `cp -R #{Bebox::Project.templates_path}/puppet/default_roles/* #{self.path}/puppet/roles/`
+      `cp -R #{Bebox::Project.templates_path}/puppet/default_profiles/* #{self.path}/puppet/profiles/`
+    end
+
+    # Create config deploy and keys directories
+    def create_config_deploy_directories
+      `cd #{self.path} && mkdir -p config/{deploy,keys/environments}`
+    end
+
+    # Create the default environments
+    def create_default_environments
+      self.environments.map{|environment| environment.create}
+    end
+
+    # Create Capfile for the project
+    def create_capfile
+      capfile_content = File.read("#{Bebox::Project.templates_path}/project/Capfile.erb")
+      File::open("#{self.path}/Capfile", "w")do |f|
+        f.write(capfile_content)
+      end
+    end
+
+    # Create Gemfile for the project
+    def create_gemfile
+      gemfile_content = File.read("#{Bebox::Project.templates_path}/project/Gemfile.erb")
+      File::open("#{self.path}/Gemfile", "w")do |f|
+        f.write(gemfile_content)
+      end
+    end
+
+    # Create puppet base directories and files
+    def create_puppet_base
+      # Create templates directories
+      create_templates_directories
+      # Generate SO dependencies files
+      generate_so_dependencies_files
+      # Copy puppet install files
+      copy_puppet_install_files
+      # Generate steps directories
+      generate_steps_directories
+      # Generate steps templates
+      generate_steps_templates
+      # Copy the default_roles and default_profiles to project
+      copy_default_roles_profiles
+    end
+
+    # Generate steps directories
+    def generate_steps_directories
+      Bebox::PROVISION_STEP_NAMES.each{|step| `cd #{self.path} && mkdir -p puppet/steps/#{step}/{hiera/data,manifests,modules}`}
+      `cd #{self.path} && mkdir -p puppet/{roles,profiles}`
+    end
+
+    # Generate steps templates for hiera and manifests files
+    def generate_steps_templates
+      Bebox::PROVISION_STEPS.each do |step|
+        ssh_key = ''
+        step_dir = Bebox::Provision.step_name(step)
+        templates_path = Bebox::Project::templates_path
+        # Generate site.pp template
+        manifest_template = Tilt::ERBTemplate.new("#{templates_path}/puppet/#{step}/manifests/site.pp.erb")
+        File.open("#{self.path}/puppet/steps/#{step_dir}/manifests/site.pp", 'w') do |f|
+          f.write manifest_template.render(nil, :nodes => [])
+        end
+        # Generate hiera.yaml template
+        hiera_template = Tilt::ERBTemplate.new("#{templates_path}/puppet/#{step}/hiera/hiera.yaml.erb")
+        File.open("#{self.path}/puppet/steps/#{step_dir}/hiera/hiera.yaml", 'w') do |f|
+          f.write hiera_template.render(nil, :step_dir => step_dir)
+        end
+        # Generate common.yaml template
+        hiera_template = Tilt::ERBTemplate.new("#{templates_path}/puppet/#{step}/hiera/data/common.yaml.erb")
+        File.open("#{self.path}/puppet/steps/#{step_dir}/hiera/data/common.yaml", 'w') do |f|
+          f.write hiera_template.render(nil, :step_dir => step_dir, :ssh_key => ssh_key, :project_name => self.shortname)
+        end
+      end
+    end
+
+    # Copy puppet install files
+    def copy_puppet_install_files
+      `cd #{self.path} && mkdir -p puppet/lib/deb`
+      `cp -R #{lib_path}/deb/* #{self.path}/puppet/lib/deb/`
+    end
+
+    # Generate SO dependencies files
+    def generate_so_dependencies_files
+      `cd #{self.path} && mkdir -p puppet/prepare/dependencies/ubuntu`
+      ubuntu_dependencies_content = File.read("#{Bebox::Project.templates_path}/project/ubuntu_dependencies")
+      File::open("#{self.path}/puppet/prepare/dependencies/ubuntu/packages", "w")do |f|
+        f.write(ubuntu_dependencies_content)
+      end
+    end
+
+    def self.so_dependencies
+      File.read("#{Bebox::Project.templates_path}/project/ubuntu_dependencies").gsub(/\s+/, ' ')
+    end
+
+    # Create checkpoints base directories
+    def create_checkpoints
+      `cd #{self.path} && mkdir -p .checkpoints/environments`
+    end
+
+    # Bundle install packages for project
+    def bundle_project
+      system("cd #{self.path} && BUNDLE_GEMFILE=Gemfile bundle install")
+    end
+
+    # Generate the deploy file for the project
+    def generate_deploy_file
+      config_deploy_template = Tilt::ERBTemplate.new("#{Bebox::Project.templates_path}/project/config/deploy.erb")
+      File.open("#{self.path}/config/deploy.rb", 'w') do |f|
+        f.write config_deploy_template.render(nil, project: self)
+      end
+    end
+
+    # Path to the lib directory in the gem
+    def lib_path
+      File.expand_path '..', File.dirname(__FILE__)
+    end
+
+    # Path to the templates directory in the gem
+    def self.templates_path
+      # File.expand_path(File.join(File.dirname(__FILE__), "..", "gems/bundler/lib/templates"))
+      File.join((File.expand_path '..', File.dirname(__FILE__)), 'templates')
+    end
+
+    # Obtain the ssh public key from file in environment
+    def self.public_ssh_key_from_file(project_root, environment)
+      ssh_key_path = "#{project_root}/config/keys/environments/#{environment}/id_rsa.pub"
+      return (File.exist?(ssh_key_path)) ? File.read(ssh_key_path).strip : ''
+    end
+
+    # Delete all files referent to a project
+    def destroy
+      `cd #{self.parent_path} && rm -rf #{self.name}`
+    end
+  end
+end