beeta 0.0.1

data/Rakefile

@@ -0,0 +1,147 @@
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require './lib/beeta/config'
+
+begin
+	require 'bundler'
+	Bundler::GemHelper.install_tasks
+rescue LoadError => e
+	$stderr.puts(' Bundler is not installed.  Its rake tasks won\'t work. '.
+		center((ENV['COLUMNS'] || 80).to_i, '*'))
+end
+
+$: << "#{File.dirname(__FILE__)}/lib"
+
+Rake::RDocTask.new(:doc) { |t|
+	t.main = 'doc/README'
+	t.rdoc_files.include 'lib/**/*.rb', 'doc/*', 'bin/*', 'ext/**/*.c',
+		'ext/**/*.rb'
+	t.options << '-S' << '-N'
+	t.rdoc_dir = 'doc/rdoc'
+}
+
+desc "Runs IRB, automatically require()ing beeta."
+task(:irb) {
+	exec "irb -Ilib -rbeeta"
+}
+
+desc "Runs tests."
+task(:test) {
+	system "ruby -Ilib -Itest test/*_test.rb"
+}
+
+task :default => :test
+
+task(:gitolite_setup) {
+	require 'fileutils'
+	Beeta::Config.load
+	dir = Beeta::Config.gitolite_repo_path
+	location = "git@#{Beeta::Config.gitolite_host}:gitolite-admin"
+	FileUtils.mkdir_p File.dirname(dir)
+	if File.exists? dir
+		system "git pull #{dir}"
+	else
+		system "git clone #{location} #{dir}"
+	end
+}
+
+desc "Update the database with the latest schema."
+task(:migrate) {
+	require 'sequel'
+	require 'sequel/extensions/migration'
+	Beeta::Config.load
+	Sequel.connect(Beeta::Config.db) { |db|
+		Sequel::Migrator.apply(db, './migrations')
+	}
+}
+
+desc "Run beeta with unicorn"
+task(:unicorn) {
+	sh "unicorn -c conf/unicorn.rb"
+}
+
+desc "Run beeta with unicorn in daemon mode"
+task(:daemon) {
+	sh "unicorn -D -c conf/unicorn.rb"
+}
+
+task(:install_gitolite) {
+	if File.exists? File.expand_path "~git/bin/gl-setup"
+		puts "Gitolite appears to be installed"
+	else
+		puts "Installing Gitolite"
+		tmpidrsa = "/tmp/#{ENV['USER']}-#{rand(10000)}.pub"
+		sh "cp ~/.ssh/id_rsa.pub #{tmpidrsa} && chmod 644 #{tmpidrsa}"
+		install_script = File.expand_path(File.join(File.dirname(__FILE__), 'bin/install_gitolite.sh'))
+		sh "su git -c '#{install_script} #{tmpidrsa}'"
+		sh "rm #{tmpidrsa}"
+	end
+}
+
+task(:install_deps) {
+	sh 'gem install bundler'
+	sh 'bundle'
+}
+
+desc "Perform all initial setup functions."
+task(:newb) {
+	# automatic gitolite installation isn't working
+	# #Rake::Task["install_gitolite"].invoke
+	%w(gitolite_setup install_gitolite_gem install_deps migrate test
+	  ).each do |task|
+		Rake::Task[task].invoke
+	end
+
+	puts <<MSG
+==============================
+	So, what have you done?
+		Configured gitolite, installed the gitolite gem, bundle installed gems,
+		run db migrations and executed tests.
+
+	What now?
+		1. README
+		2. Code stuff
+		3. Submit back
+		4. ???
+		5. Profit!
+MSG
+}
+
+desc "Perform project release check-in and tag with a version number. Each new release version will be automatically."
+task(:release) {
+  puts 'Running release task, may take a few minutes'
+  new_version = increment_ver
+  run_commands(
+	"git add lib/version.rb" &&
+    	"git commit -am 'Bump to Beeta version #{new_version}'" &&
+   	"git tag v#{new_version} HEAD^" &&
+        "gem build beeta.gemspec")
+
+  puts '********************************************************************************'
+  puts
+  puts "Don't forget to `gem push` and `git push --tags`!"
+  puts
+  puts '********************************************************************************'
+}
+
+def increment_ver
+  puts "Reading the current Beeta version"
+  specs = Gem::SpecFetcher.fetcher.fetch(Gem::Dependency.new("beeta"))
+  versions = specs.map {|spec,| spec.version}.sort
+  new_version = versions.last.to_s
+  puts "New Version is going to be #{new_version}"
+  version_file =<<-EOT
+		module Beeta
+		VERSION = "#{new_version}"
+		end
+		EOT
+
+  puts "Using Beeta version #{new_version}"
+  File.open('lib/version.rb', 'w') do |f|
+    f.write version_file
+  end
+  new_version
+end
+
+
+

data/bin/install_gitolite.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env sh
+
+# This script will install gitolite under the current user's account. Normally it is expected that you would install gitolite
+# to a 'git' user. Therefore, you should probably copy your public key into /tmp and su/sudo into the git account and run the
+# script from there.
+#
+# For more information see: http://sitaramc.github.com/gitolite/doc/1-INSTALL.html
+
+GITOLITE_DIR=/tmp/gitolite-source
+TMPKEY=$1
+VER=v1.5.9.1
+KEY_ERROR_MSG='Please provide a public key to import into gitolite.'
+
+if [ -z $TMPKEY ]; then
+	echo $KEY_ERROR_MSG
+	exit
+fi
+
+if [ ! -f $TMPKEY ]; then
+	echo $TMPKEY 'does not exist. ' $KEY_ERROR_MSG
+	exit
+fi
+
+if [ ! -d $GITOLITE_DIR ]; then
+	git clone git://github.com/sitaramc/gitolite $GITOLITE_DIR
+fi
+
+cd $GITOLITE_DIR && git checkout $VER
+mkdir -p $HOME/bin $HOME/share/gitolite/conf $HOME/share/gitolite/hooks
+$GITOLITE_DIR/src/gl-system-install $HOME/bin $HOME/share/gitolite/conf $HOME/share/gitolite/hooks
+$HOME/bin/gl-setup $TMPKEY
+

data/doc/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 AT&T
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the 
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software. 
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.

data/doc/project.vim

@@ -0,0 +1,15 @@
+" For as long as I can get away with it, here are the code formatting standards
+" for the codebase.  I don't know how to do this in Emacs or TextMate, but feel
+" free to add equivalent files.
+
+" Tabs and shifts rendered as 4 spaces; change it if you want!
+set ts=4
+set sw=4
+
+" Hard tabs for indentation, soft tabs for alignment if that is needed for some
+" reason:
+set noexpandtab
+set sts=0
+
+" Wrap at 80 characters:
+set tw=80

data/lib/beeta.rb

@@ -0,0 +1,41 @@
+%w(
+	watts
+	json
+	sequel
+	gitolite
+).each &method(:require)
+
+module Beeta
+	def self.init
+		# First off, we need to load the configuration file:
+		Beeta::Config.load
+
+		# Before the models are loaded, we need to connect to the DB:
+		Sequel::Model.db = Sequel.connect Beeta::Config.db
+
+		const_set(:GitoliteRepo,
+		          Gitolite::GitoliteAdmin.new(Beeta::Config.gitolite_repo_path))
+	end
+end
+
+require 'beeta/config'
+Beeta.init
+
+%w(
+	beeta/resource
+	beeta/model
+).each &method(:require)
+
+class Beeta::App < Watts::App
+	include Beeta::Resource
+
+	resource('/', Discovery) {
+		resource("app", AppList) {
+			resource(/^[-0-9a-z]+$/i, App)
+		}
+
+		resource("user", UserList) {
+			resource(/^[0-9a-z]+$/i, User)
+		}
+	}
+end

data/lib/beeta/config.rb

@@ -0,0 +1,35 @@
+require 'json'
+
+module Beeta
+	module Config
+		ConfigFile = %W(
+			#{ENV['BEETA_CONF']}
+			./beeta.json
+			#{ENV['HOME']}/.beeta.json
+			/etc/beeta.json
+		).select { |fn| File.exist? fn }.first
+
+		class << self; attr_accessor :config, :loaded; end
+
+		def self.load(fn = nil, force = false)
+			fn ||= ConfigFile
+			return false if(fn.nil? || (!force && loaded))
+
+			self.config = JSON.parse File.read(fn)
+			# TODO:  When the config solidifies reasonably, get rid of the
+			# overly metaprogrammed bits here, and replace with regular
+			# methods.  It's just a little easier for now to be able to add
+			# values to the config file and have the methods appear out of
+			# nowhere.
+			config.each { |k,v|
+				class << self; self; end.module_eval {
+					define_method(k) { v }
+				}
+			}
+
+			self.loaded = true
+		end
+	end
+end
+
+Beeta::Config.load

data/lib/beeta/model.rb

@@ -0,0 +1,98 @@
+require 'sequel/model'
+require 'digest/sha1'
+
+module Beeta::Model
+	module Mixin
+		def to_json
+			h = {}
+			self.class::PublicProperties.each { |p| h[p] = send(p) }
+			h.to_json
+		end
+	end
+
+	class User < Sequel::Model
+		include Mixin
+		set_dataset :user
+
+		PublicProperties = [
+			:email,
+			:created,
+			:app_uris,
+		]
+
+		def self.random_salt
+			rand.to_s[2..-1]
+		end
+
+		def self.hash_password salt, pw
+			Digest::SHA1.hexdigest "#{salt}#{pw}"
+		end
+
+		def self.authenticate email, pw
+			u = self[:email => email]
+			return unless u
+			return u if hash_password(u.salt, pw) == u.hashed_password
+		end
+
+		def before_create
+			self.created = Time.now
+			super
+		end
+
+		def app_uris
+			[]
+		end
+
+		def password=(pw)
+			self.salt = self.class.random_salt
+			self.hashed_password = self.class.hash_password salt, pw
+			pw
+		end
+	end
+
+	class App < Sequel::Model
+		include Mixin
+		set_dataset :app
+
+		many_to_one :owner, :class => User
+		one_to_many :instances
+
+		PublicProperties = [
+			:owner,
+			:name,
+			:max_instances,
+			:min_instances,
+			:git_repo,
+		]
+
+		# The address of the git repository.
+		def git_repo
+			# TODO:  Don't hard-code the git user?  For the sake of simplicity,
+			# I think it's okay to say that the gitolite user has to be named
+			# 'git' for now.
+			"git@#{Beeta::Config.gitolite_host}:#{name}"
+		end
+
+		def validate
+			super
+			errors.add(:name, "can't be empty.") if(name.nil? || name.empty?)
+			if(((App[:name => name].id != id) rescue nil))
+				errors.add(:name, "must be unique.")
+			end
+
+			errors.add(:owner, "can't be blank.") unless owner
+
+			errors.empty?
+		end
+	end
+
+	# Currently unused placeholder.  The idea is that we have N instances
+	# (running Unicorn/Rainbows/etc.) that can be routed to.  We're going to
+	# punt on the routing for now, but this will need to be hooked in so that
+	# we can keep track of pid/host/port to pass back through the API.
+	class Instance < Sequel::Model
+		set_dataset :instance
+
+		many_to_one :app
+	end
+end

data/lib/beeta/resource.rb

@@ -0,0 +1,116 @@
+require 'beeta/model'
+
+# TODO:  These are all pretty short, but will get bigger and should be split.
+# While most resources are under 10 lines, though, this is a little easier.
+module Beeta::Resource
+	include Beeta
+
+	# The Generic resource, with some utility methods for the other Beeta
+	# resources.
+	class Generic < Watts::Resource
+		include Beeta
+
+		def error_404
+			@error_404 ||= json_resp({'error'=>'Not Found'}, 404)
+		end
+
+		# Returns the body given with the request, as with a POST or PUT.
+		def req_body
+			@req_body ||= env['rack.input'].read
+		end
+
+		# Returns the req_body, run through the JSON parser.  Returns nil if we
+		# can't parse it.
+		def json_body
+			@json_body ||=
+				begin
+					JSON.parse(req_body)
+				rescue JSON::ParserError
+					nil
+				end
+		end
+
+		def json_resp body, status = 200
+			js = JSON.unparse body
+			[status,
+				{ 'Content-Type' => 'application/json',
+				  'Content-Length' => js.size.to_s,
+				},
+			 [js]]
+		end
+
+		def json_error str, status = 400
+			json_resp({'error' => str}, status)
+		end
+	end
+
+	class Discovery < Generic
+		get { |*_|
+			json_resp 'apps' => '/app', 'users' => '/users'
+		}
+	end
+
+	# TODO:  These are all pretty similar; maybe a CRUD and a CRUDList
+	# superclass, but that depends on if we call gitolite from the models (I'm
+	# leaning towards yes) or we manage that through an intermediary, and also
+	# on auth.  We'll be using SSO ideally, although we may skip that for now.
+
+	class App < Generic
+		get { |name| json_resp Models::App[:name => name] }
+		put { |name|
+			# TODO:  Authorization.
+			a = Models::App[:name => name]
+			return error_404 unless a
+			a.set json_body
+			return json_resp(a) if a.save
+			# TODO:  Restart the app.
+		}
+	end
+
+	class AppList < Generic
+		get { json_resp Model::App.all }
+
+		# Not particularly married to POSTing to the app list, as a name must
+		# be supplied anyway, so just a PUT to /app/name might be more
+		# appropriate.
+		post {
+			# TODO:  Authentication, tagging the App as owned by the user that
+			# is posting the data.
+			unless json_body
+				return json_error('No body provided, or could not parse body.')
+			end
+
+			a = Model::App.new json_body
+			if !a.valid?
+				# TODO:  409 when the name is taken.
+				return json_resp(a.errors, 400)
+			end
+
+			# TODO:  Make this the model's responsibility(?)
+			repo = Gitolite::Config::Repo.new a.name
+			# TODO:  After auth stuff, the below:
+			repo.add_permission('RW+C', '', `id -nu`.strip)
+			Beeta::GitoliteRepo.config.add_repo repo
+			Beeta::GitoliteRepo.save_and_apply
+
+			return json_resp(a) if a.save
+			# TODO:  Provide git URI.
+		}
+	end
+
+	class UserList < Generic
+		get { |name| json_resp Models::User.all }
+		# TODO:  Use SSO.
+	end
+
+	class User < Generic
+		get { |name| json_resp Models::User[:name => name] }
+		put { |name|
+			a = Models::App[:name => name]
+			return error_404 unless a
+			a.set json_body
+			return json_resp(a) if a.save
+			# TODO:  Restart the app.
+		}
+	end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Beeta
+    VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+name: beeta
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Pete Elmore
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-11 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: watts
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: gitolite
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 2
+        - alpha
+        version: 0.0.2.alpha
+  type: :runtime
+  version_requirements: *id005
+description: 
+email: pete@debu.gs
+executables: 
+- install_gitolite.sh
+extensions: []
+
+extra_rdoc_files: 
+- doc/TODO
+- doc/project.vim
+- doc/LICENSE
+files: 
+- lib/beeta/resource.rb
+- lib/beeta/config.rb
+- lib/beeta/model.rb
+- lib/version.rb
+- lib/beeta.rb
+- doc/TODO
+- doc/project.vim
+- doc/LICENSE
+- bin/install_gitolite.sh
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/pete/beeta
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 6
+      - 8
+      version: 1.6.8
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Platform in the form of a service.
+test_files: []
+