appscake 0.0.1 → 0.0.2

data/LICENSE.txt

@@ -0,0 +1,45 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2008, Regents of the University of California
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, with or
+without modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.  USERS OF THIS SOFTWARE ACKNOWLEDGE THE POSSIBLE
+ PRESENCE OF OTHER OPEN SOURCE LICENSED MATERIAL, COPYRIGHTED MATERIAL OR
+PATENTED MATERIAL IN THIS SOFTWARE, AND IF ANY SUCH MATERIAL IS DISCOVERED THE PARTY
+DISCOVERING IT MAY INFORM DR. CHANDRA KRINTZ AT THE UNIVERSITY OF CALIFORNIA, 
+SANTA BARBARA WHO WILL THEN ASCERTAIN THE MOST APPROPRIATE REMEDY, WHICH
+IN THE REGENTS’ DISCRETION MAY INCLUDE, WITHOUT LIMITATION, REPLACEMENT
+OF THE CODE SO IDENTIFIED, LICENSING OF THE CODE SO IDENTIFIED, OR WITHDRAWAL
+OF THE CODE CAPABILITY TO THE EXTENT NEEDED TO COMPLY WITH ANY SUCH LICENSES
+OR RIGHTS.
+
+This software makes use of third party software libraries released under different
+licenses. The table below lists all the contained libraries and the licenses under
+which they are provided to you.
+
+* Twitter Bootstrap - Apache Software License 2.0
+* jQuery Validation Plugin - MIT License
+

data/README.txt

@@ -0,0 +1,56 @@
+AppsCake - Web Frontend for AppScale Tools
+==========================================
+
+"AppsCake makes deploying AppScale a piece of cake"
+
+AppsCake is a simple and lightweight web application that allows users to
+interact with AppScale tools over the web. This way even those users who
+are not familiar with general cloud principles or those who are not
+comfortable with working with a traditional command line interface can
+get started with deploying AppScale clouds and AppScale cloud applications.
+
+AppsCake has been developed using the Ruby programming language and is 
+based on Sinatra. So far it has been tested in Xen and EC2 cloud
+environments.
+
+Prerequisites
+=============
+
+Following software is required to install and run AppsCake:
+
+1. Ruby interpreter
+2. Sinatra gem
+3. AppScale tools gem (or alternatively you can install AppScale tools
+   binary distribution on your machine/VM and put them in the PATH)
+
+Installation
+============
+
+There are 2 ways to install AppsCake:
+
+1. Pull the source from the Github
+	- https://github.com/AppScale/appscake
+
+2. Install the AppsCake gem
+	sudo gem install appscake
+
+Running AppsCake
+================
+
+To launch AppsCake, simply go into the bin directory and execute the
+'appscake' script:
+
+./appscake
+
+Once the server has started up, fire up your web browser and navigate
+to https://<appscake-host>:8443
+
+If you're installing AppsCake on an EC2 image make sure to modify your
+security group so that it allows inbound traffic on the port 8443.
+
+
+
+======================================================================
+AppsCake is a project by the UCSB RACELab
+http://appscake.cs.ucsb.edu
+

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+
+# TODO(cgb): This probably should be moved into a Gemfile and out of this file.
+spec = Gem::Specification.new do |s|
+  s.name = 'appscake'
+  s.version = '0.0.2'
+
+  s.summary = "A web interface to the AppScale command-line tools."
+  s.description = <<-EOF
+    AppsCake provides a pretty web interface that can be used to deploy
+    AppScale over machines in Xen, KVM, Amazon EC2, or Eucalyptus. In
+    short, it makes deploying AppScale a piece of cake!
+  EOF
+
+  s.author = "Hiranya Jayathilaka"
+  s.email = "appscale_community@googlegroups.com"
+  s.homepage = "http://appscale.cs.ucsb.edu"
+
+  s.executables = ["appscake"]
+  s.default_executable = 'appscake'
+  s.platform = Gem::Platform::RUBY
+
+  candidates = Dir.glob("**/*")
+  s.files = candidates.delete_if do |item|
+    item.include?(".git") || item.include?("rdoc") || item.include?("pkg")
+  end
+  s.require_path = "lib"
+  s.autorequire = "appscake_utils"
+
+  s.has_rdoc = false
+  s.add_dependency('net-ssh', '>= 2.6.0')
+end
+
+
+# responds to 'rake gem'
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+end

data/bin/appscake

@@ -1,5 +1,165 @@
-#!/bin/bash
-# Programmer: Chris Bunch (cgb@cs.ucsb.edu)
-# Makes AppsCake exec'able, nice when you install via gem
+#!/usr/bin/ruby
+# Author: Hiranya Jayathilaka (hiranya@cs.ucsb.edu)
+# AppsCake web interface for deploying and launching AppScale clouds
+# AppsCake = Makes deploying AppScale a 'piece of cake'
 
-ruby ../appscake.rb
+require 'rubygems'
+require 'sinatra/base'
+require 'webrick'
+require 'webrick/https'
+require 'openssl'
+
+CERT_DIR = File.expand_path(File.join(File.dirname(__FILE__), "..", "certificates"))
+
+LIB_DIR = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift LIB_DIR
+require 'appscake_utils'
+
+puts "\nAppsCake - Makes deploying AppScale a 'piece of cake'!\n\n"
+
+class AppsCake < Sinatra::Base
+  set :views, settings.root + '/../views'
+  set :public_folder, settings.root + '/../public'
+
+  get '/' do
+    erb :index
+  end
+
+  post '/virtual.do' do
+    if locked?
+      return report_error("Server Busy", "AppsCake is currently busy deploying a cloud." +
+          " Please try again later.")
+    end
+
+    status, yaml_result, yaml = validate_yaml(params[:ips])
+    if !status
+      return report_error("IP Configuration Error", yaml_result)
+    end
+
+    status,acc_result = validate_appscale_credentials(params[:virtual_user],
+                                                      params[:virtual_pass], params[:virtual_pass2])
+    if !status
+      return report_error("AppScale Administrator Account Configuration Error", acc_result)
+    end
+
+    status,ssh_result = validate_ssh_credentials(params[:virtual_keyname], params[:root_password], yaml)
+    if !status
+      return report_error("AppScale SSH Configuration Error", ssh_result)
+    end
+
+    add_key_options = {
+        'ips' => yaml,
+        'keyname' => params[:virtual_keyname],
+        'auto' => true,
+        'root_password' => params[:root_password]
+    }
+
+    app_name = nil
+    file_location = nil
+    if !params[:target_app].nil? and params[:target_app] != '_none_'
+      puts params[:target_app]
+      app_name = params[:target_app]
+      file_location = File.join(File.dirname(__FILE__), "repository", params[:target_app])
+    end
+
+    run_instances_options = {
+        'ips' => yaml,
+        'keyname' => params[:virtual_keyname],
+        'file_location' => file_location,
+        'appname' => app_name,
+        'appengine' => 1,
+        'autoscale' => true,
+        'separate' => false,
+        'confirm' => false,
+        'table' => 'cassandra',
+        'infrastructure' => nil,
+        'admin_user' => params[:virtual_user],
+        'admin_pass' => params[:virtual_pass]
+    }
+
+    deploy_on_virtual_cluster(params, add_key_options, run_instances_options, yaml_result)
+  end
+
+  post '/iaas_ec2.do' do
+    status, result = validate_ec2_cluster_settings(params[:min], params[:max], params[:ami])
+    if !status
+      return report_error("Cluster Configuration Error", result)
+    end
+
+    status, result = validate_ec2_credentials(params[:username], params[:access_key],
+                                              params[:secret_key], params[:region])
+    if !status
+      return report_error("EC2 Security Configuration Error", result)
+    end
+
+    status, result = validate_ec2_certificate_uploads(params[:username], params[:private_key],
+                                                      params[:cert])
+    if !status
+      return report_error("EC2 Security Configuration Error", result)
+    end
+    cert_timestamp = result
+
+    status,acc_result = validate_appscale_credentials(params[:ec2_user],
+                                                      params[:ec2_pass], params[:ec2_pass2])
+    if !status
+      return report_error("AppScale Administrator Account Configuration Error", acc_result)
+    end
+
+    app_name = nil
+    file_location = nil
+    if !params[:target_app].nil? and params[:target_app] != '_none_'
+      app_name = params[:target_app]
+      file_location = File.join(File.dirname(__FILE__), "repository", params[:target_app])
+    end
+
+    run_instances_options = {
+        'keyname' => params[:ec2_keyname],
+        'group' => params[:ec2_keyname],
+        'file_location' => file_location,
+        'appname' => app_name,
+        'appengine' => 1,
+        'autoscale' => true,
+        'separate' => false,
+        'confirm' => false,
+        'table' => 'cassandra',
+        'infrastructure' => 'ec2',
+        'min_images' => params[:min].to_i,
+        'max_images' => params[:max].to_i,
+        'instance_type' => params[:instance_type],
+        'machine' => params[:ami],
+        'admin_user' => params[:ec2_user],
+        'admin_pass' => params[:ec2_pass],
+    }
+    deploy_on_ec2(params, run_instances_options, cert_timestamp)
+  end
+
+  get '/view_logs' do
+    timestamp = params[:ts]
+    if timestamp.nil? or timestamp.length == 0
+      return report_error("Invalid URL Request", "No timestamp information found in the request")
+    end
+    @timestamp = timestamp
+    erb :view_log
+  end
+end
+
+webrick_options = {
+    :Port               => 8443,
+    :Logger             => WEBrick::Log::new($stderr, WEBrick::Log::INFO),
+    :DocumentRoot       => "/ruby/htdocs",
+    :SSLEnable          => true,
+    :SSLVerifyClient    => OpenSSL::SSL::VERIFY_NONE,
+    :SSLCertificate     => OpenSSL::X509::Certificate.new(
+        File.open(File.join(CERT_DIR, "cert-appscake.pem")).read),
+    :SSLPrivateKey      => OpenSSL::PKey::RSA.new(
+        File.open(File.join(CERT_DIR, "pk-appscake.pem")).read),
+    :SSLCertName        => [["CN", WEBrick::Utils::getservername]],
+    :app                => AppsCake,
+    :server             => 'webrick'
+}
+
+Rack::Server.start webrick_options
+
+at_exit do
+  puts "Terminating AppsCake..."
+end

data/certificates/cert-appscake.pem

@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIELzCCAxegAwIBAgIJAOIyrR3Lx40pMA0GCSqGSIb3DQEBBQUAMIGtMQswCQYD
+VQQGEwJVUzELMAkGA1UECAwCQ0ExFjAUBgNVBAcMDVNhbnRhIEJhcmJhcmExGTAX
+BgNVBAoMEFVDIFNhbnRhIEJhcmJhcmExJzAlBgNVBAsMHkRlcGFydG1lbnQgb2Yg
+Q29tcHV0ZXIgU2NpZW5jZTERMA8GA1UEAwwIQXBwU2NhbGUxIjAgBgkqhkiG9w0B
+CQEWE2hpcmFueWFAY3MudWNzYi5lZHUwHhcNMTIwOTI1MjEyOTIzWhcNMTIxMDI1
+MjEyOTIzWjCBrTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1T
+YW50YSBCYXJiYXJhMRkwFwYDVQQKDBBVQyBTYW50YSBCYXJiYXJhMScwJQYDVQQL
+DB5EZXBhcnRtZW50IG9mIENvbXB1dGVyIFNjaWVuY2UxETAPBgNVBAMMCEFwcFNj
+YWxlMSIwIAYJKoZIhvcNAQkBFhNoaXJhbnlhQGNzLnVjc2IuZWR1MIIBIjANBgkq
+hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0uzoMSPlUZrn7eAnwVYT4D8DgkHEU+W5
+BuHp5fby9Wj3/WerEr//ie61w29r1XPdF1KP2O+nj6LSk3AzluwEi03pJQBhWNmm
+FKU8zavKwvRJtOYesNttwx6GDTQ/3cGSQpJ/5T9o+Xk/iOA9IFiOhCEH8L8OYoIb
+SmmoR020cAOA7RpJ/T30DH7JNfDP4Q4BfyOimzKzpMz0w3scEJ3WAYz1LR0pc0MF
+Kcz/NVYWouGO6l3S5kLANkXn7zWqH34dopOOSBWKqo9zEDVihlu0IzzZeJ4x7OSw
+WlWH+DcPqvH8R7UCp0SooCMmrlniJp8AUMmHZ/p/vHZrwpQKWRnFbQIDAQABo1Aw
+TjAdBgNVHQ4EFgQUbuGZ86sFEYgjUWClz2cr7NwIUHQwHwYDVR0jBBgwFoAUbuGZ
+86sFEYgjUWClz2cr7NwIUHQwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOC
+AQEAnVXP7n5Hf/mRQU0Bm7ZFcJ726hHG3Kt9b80zhBbBCI4ZBPR1HlWR8JclBINX
+ES+/T0AoNU5C8XR5sJ6sFTL6VpYd2PyX/wfXnvzaejR5TyEv81LjK2PHjS/fFBMh
+zjMxCM+ABWNZZEAdBkqvaFKL+pz73ges7pIBtxpT7PcEj3M1oTMZUUUlbEHv45HX
+er3sUZb2rn3DztqZRdwzZUIdGOvP5h2jSJcNdD/3JqoROufHQbRWlGtMBYUfWCGf
+Z7wOgs73OhMFBd+9Mvw4+s321yH8TBvGWH2vdQ7llg0ev4J7f+3p8hVEZN3IjlDL
+cUOI1rlQiIJZCaQPaqlODOpvNg==
+-----END CERTIFICATE-----

data/certificates/pk-appscake.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEA0uzoMSPlUZrn7eAnwVYT4D8DgkHEU+W5BuHp5fby9Wj3/Wer
+Er//ie61w29r1XPdF1KP2O+nj6LSk3AzluwEi03pJQBhWNmmFKU8zavKwvRJtOYe
+sNttwx6GDTQ/3cGSQpJ/5T9o+Xk/iOA9IFiOhCEH8L8OYoIbSmmoR020cAOA7RpJ
+/T30DH7JNfDP4Q4BfyOimzKzpMz0w3scEJ3WAYz1LR0pc0MFKcz/NVYWouGO6l3S
+5kLANkXn7zWqH34dopOOSBWKqo9zEDVihlu0IzzZeJ4x7OSwWlWH+DcPqvH8R7UC
+p0SooCMmrlniJp8AUMmHZ/p/vHZrwpQKWRnFbQIDAQABAoIBAEsFdHi1+cSSwld7
+WOiNQziJcSgNWFU26h6mj9j5guUC1uHM064xmCRpQUEoCkS7lzHKbduNMh4GnbtP
+NypA/ETIC1rbzcQaddX2B7BnoBDDbsvm5ZemFF5IJwnfQbAQP4NqNA9IBIBnPc/j
+Yhp1JQud7AMXEXi8KhTHi9EAtGL6Vq/SsVmK63BosFK8PFyaZ/EYAIL7QTJQBdwW
+DWjW5FUVBP0NY+iJXuEt1slV32Xhx3eSPk53L2CG9o2aMkT+dbx/mC13edYI7UU7
+4bjq+F7Gxz93w+ZsRJ2YkciSHHk8qQ/FZrqpSr0GYul9eUSGkm8l8LZGNbzHsl8D
+yAQrJUECgYEA7myy2+Ha0RG0icf001OPr+T3JGJK93R+VIC7LGF/rCuU6RLll7Nl
+rYpMuYKvmiGaORpJYVc5zVwzeY5k90IyaVPa2xKtVo9tRfeNEaTaqlB6gTm+m5E3
+iJFYym+G+KwuTuuhVVU9nV7KWODSBfLglEgOSpLTCGui0QN+qbY2ZVUCgYEA4nlF
+s4NjQfUZiGGRbFKNqosVp2rgtFR95HXXRLjYTWtK/FS0ieMJyJUEFWJiNi0j9P+/
+J9CmQy4r66MpqFooYHquMYRDukXCQ27KdfLe4UHM+bTQOAoCY7Tl/ds7mVHSp2cI
+P/T2W3ehrxNPB2KNeU3OgJd9IPYNW/wwHotwX7kCgYBt7+stHmByZLKVkYDfbLll
+hrM6sKQWpD2YI1+rIC3pqpLYQeFh6NOqiInGRG9KJ9JgIDHT04+QlMIbe8AsjvaF
+wKe6ukr5Ddt6FqKSjyxQuhkyuvib7QLpUvPZLEHVKjeUJmxW1544kTvGbawKGCrb
+1LnaQwdR66fArtbZ1G4SnQKBgCcHOynKdKqDMJk+Jy+BsoQ3X83wLzUkcmWSoTxo
+lm4RFWUSu+IfTCpS89czkzU+5jlscWbNIDnnlQ4Qmjc3AkpOGgLShlFtgCLazu0w
+o5QyIL7PmCpwHyVLoW7z/vtXDHRo3xUWg/YTUbu4GiBtrW/AJtwmPxwVCwxVE33Q
+DdeRAoGABCXxlPDzGW5qeHDDGWD6FdnRo6MqFS5W72MZM13t9AXSkP0Mnfds5smV
+q0ejip4UNuvgfckU+ZnECTV/gU++1ePICyyY+4ERmjZq2YaI67AtH8KYGCDhlM2L
+XHdEbTcJKqBzsBKi22xAISaSvUpZ8UPFoaRQBYsAKeQB52DJLEk=
+-----END RSA PRIVATE KEY-----

data/lib/appscake_utils.rb

@@ -0,0 +1,325 @@
+require 'thread'
+require 'net/ssh'
+require 'yaml'
+
+tools_home = `which appscale-run-instances`
+if tools_home.length == 0
+  # If AppScale-Tools are not installed on the local machine, use the Gem
+  require 'appscale-tools'
+else
+  # Give priority to the the local copy of AppScale Tools
+  $:.unshift File.join(File.dirname(tools_home), "..", "lib")
+  require 'appscale_tools'
+end
+
+$mutex = Mutex.new
+
+def report_error(title, msg)
+  @title = title
+  @error = msg
+  return erb :error
+end
+
+def validate_appscale_credentials(user, pass1, pass2)
+  if user.nil? or user.length == 0
+    return [false, "Administrator username not provided"]
+  elsif pass1.nil? or pass2.nil? or pass1.length == 0 or pass2.length == 0
+    return [false, "Administrator password not provided"]
+  elsif pass1 != pass2
+    return [false, "Password entries do not match"]
+  elsif pass1.length < 6
+    return [false, "Password must contain at least 6 characters"]
+  else
+    return [true, '']
+  end
+end
+
+def validate_ssh_credentials(keyname, root_password, ips_yaml)
+  if keyname.nil? or keyname.length == 0
+    return [false, "AppScale key name not provided"]
+  elsif root_password.nil? or root_password == 0
+    return [false, "Root password for AppScale machines not provided"]
+  else
+    # Randomly pick a server and try to connect to it via SSH using the
+    # provided credentials. This will guard againt invalid root passwords
+    # entered by the user and any obvious network level issues which might
+    # prevent AppsCake from connecting to the specified machines. The test
+    # assumes that all hosts can be accessed using the same root password
+    # and they are on the same network (if one is reachable, then all are
+    # reachable) which is the case for most typical AppScale deployments.
+    # In scenarios where the above assumption is not the case (i.e. some
+    # machines are reachable and some are not) the test may pass, but the 
+    # final deployment may fail. These runtime errors will go to the deployment 
+    # logs generated by AppsCake per each deployment which can also be accessed 
+    # over the web.
+    node_layout = NodeLayout.new(ips_yaml, {:database => "cassandra"})
+    ips = node_layout.nodes.collect { |node| node.id }
+    begin
+      Net::SSH.start(ips[0], 'root', :password => root_password, :timeout => 10) do |ssh|
+        ssh.exec('ls')
+      end
+    rescue Timeout::Error
+      return [false, "Connection timed out for #{ips[0]}"]
+    rescue Errno::EHOSTUNREACH
+      return [false, "Host unreachable error for #{ips[0]}"]
+    rescue Errno::ECONNREFUSED
+      return [false, "Connection refused for #{ips[0]}"]
+    rescue Net::SSH::AuthenticationFailed
+      return [false, "Authentication failed for #{ips[0]} - Please ensure that the specified" +
+          " root password is correct"]
+    rescue Exception => e
+      return [false, "Unexpected runtime error connecting to #{ips[0]}"]
+    end
+    return [true, '']
+  end
+end
+
+def validate_yaml(yaml_str)
+  if yaml_str.nil? or yaml_str.length == 0
+    return [false, "ips.yaml configuration not provided"]
+  end
+
+  yaml = YAML.load(yaml_str)
+  critical_roles = %w[ appengine loadbalancer database login shadow zookeeper ]
+  aggregate_roles = {
+      'master' => %w[ shadow loadbalancer zookeeper login ],
+      'controller' => %w[ shadow loadbalancer zookeeper database login ],
+      'servers' => %w[ appengine database loadbalancer ]
+  }
+  optional_roles = %w[ open memcache ]
+
+  success_result = ''
+  yaml.each do |symbol, value|
+    role = symbol.to_s
+    if !critical_roles.include? role and !aggregate_roles.has_key? role and
+        !optional_roles.include? role
+      return [false, "Unknown AppScale server role: #{role}"]
+    else
+      critical_roles.delete_if { |r|
+        r == role or (aggregate_roles.has_key? role and aggregate_roles[role].include? r)
+      }
+      success_result += "<p>#{role}</p><ul>"
+      if value.kind_of?(Array)
+        value.each do |val|
+          success_result += "<li>#{val}</li>"
+        end
+      else
+        success_result += "<li>#{value}</li>"
+      end
+      success_result += '</ul>'
+    end
+  end
+
+  if critical_roles.length > 0
+    result = "Following required roles are not configured: "
+    critical_roles.each do |role|
+      result += "#{role}, "
+    end
+    return [false, result[0..-3]]
+  end
+
+  [true, success_result, yaml]
+end
+
+def validate_ec2_cluster_settings(min, max, ami)
+  if min.nil? or min.length == 0
+    return [false, "Minimum number of nodes unspecified"]
+  elsif max.nil? or max.length == 0
+    return [false, "Maximum number of nodes unspecified"]
+  elsif ami.nil? or ami.length == 0
+    return [false, "AMI ID not specified"]
+  elsif min.to_i <= 0
+    return [false, "Minimum number of nodes must be positive"]
+  elsif max.to_i < min.to_i
+    return [false, "Maximum number of nodes must not be smaller than the minimum numberof nodes"]
+  else
+    return [true, ""]
+  end
+end
+
+def validate_ec2_credentials(username, access_key, secret_key, region)
+  if username.nil? or username.length == 0
+    return [false, "EC2 username not specified"]
+  elsif access_key.nil? or access_key.length == 0
+    return [false, "EC2 access key not specified"]
+  elsif secret_key.nil? or secret_key.length == 0
+    return [false, "EC2 secret key not specified"]
+  elsif region.nil? or region.length == 0
+    return [false, "EC2 region not specified"]
+  else
+    output = CommonFunctions::shell("ec2-describe-regions -O #{access_key}  -W #{secret_key}")
+    if output.nil? or output.length == 0
+      return [false, "Unable to execute EC2 command line tools"]
+    elsif output.include?"AuthFailure"
+      return [false, "EC2 authentication failed. Invalid EC2 access key or/and secret key."]
+    elsif !output.include?region
+      return [false, "Invalid EC2 region. This region is not available for your account."]
+    end
+  end
+  [true, ""]
+end
+
+def validate_ec2_certificate_uploads(username, pk_upload, cert_upload)
+  if pk_upload.nil?
+    return [false, "Primary key not uploaded"]
+  elsif pk_upload[:type] != "application/x-x509-ca-cert" and
+      pk_upload[:type] != "application/x-pem-file"
+    return [false, "Invalid primary key format: #{pk_upload[:type]}"]
+  elsif cert_upload.nil?
+    return [false, "X509 certificate not uploaded"]
+  elsif cert_upload[:type] != "application/x-x509-ca-cert" and
+      cert_upload[:type] != "application/x-pem-file"
+    return [false, "Invalid certificate format: #{cert_upload[:type]}"]
+  else
+    timestamp = Time.now.to_i
+    File.open("certificates/#{username}_#{timestamp}_pk.pem", "w") do |f|
+      f.write(pk_upload[:tempfile].read)
+    end
+    File.open("certificates/#{username}_#{timestamp}_cert.pem", "w") do |f|
+      f.write(cert_upload[:tempfile].read)
+    end
+  end
+  [true, timestamp]
+end
+
+def locked?
+  $mutex.synchronize do
+    return File.exists?('appscake.lock')
+  end
+end
+
+def lock
+  $mutex.synchronize do
+    if !File.exists?('appscake.lock')
+      File.open('appscake.lock', 'w') do |file|
+        file.write('AppsCake.lock')
+      end
+      return true
+    else
+      return false
+    end
+  end
+end
+
+def unlock
+  $mutex.synchronize do
+    if File.exists?('appscake.lock')
+      File.delete('appscake.lock')
+      return true
+    else
+      return false
+    end
+  end
+end
+
+def deploy(options)
+  30.times do |i|
+    puts "Deploying..."
+    sleep(1)
+  end
+end
+
+def add_key(options)
+  puts "Generating RSA keys..."
+end
+
+def redirect_standard_io(timestamp)
+  begin
+    orig_stderr = $stderr.clone
+    orig_stdout = $stdout.clone
+    log_path = File.join(File.expand_path(File.dirname(__FILE__)), "logs")
+    $stderr.reopen File.new(File.join(log_path, "deploy-#{timestamp}.log"), "w")
+    $stderr.sync = true
+    $stdout.reopen File.new(File.join(log_path, "deploy-#{timestamp}.log"), "w")
+    $stdout.sync = true
+    retval = yield
+  rescue Exception => e
+    puts "[__ERROR__] Runtime error in deployment process: #{e.message}"
+    $stdout.reopen orig_stdout
+    $stderr.reopen orig_stderr
+    raise e
+  ensure
+    $stdout.reopen orig_stdout
+    $stderr.reopen orig_stderr
+  end
+  retval
+end
+
+def deploy_on_virtual_cluster(params, add_key_options, run_instances_options, success_msg)
+  if lock
+    begin
+      timestamp = Time.now.to_i
+      pid = fork do
+        begin
+          redirect_standard_io(timestamp) do
+            key_file = File.expand_path("~/.appscale/#{params[:keyname]}")
+            if File.exists?(key_file)
+              puts "AppScale key '#{params[:keyname]}' found on the disk. Reusing..."
+            else
+              puts "AppScale key '#{params[:keyname]}' not found on the disk. Generating..."
+              AppScaleTools.add_keypair(add_key_options)
+            end
+            AppScaleTools.run_instances(run_instances_options)
+          end
+        ensure
+          # If the fork was successful, the sub-process should release the lock
+          unlock
+        end
+      end
+      Process.detach(pid)
+      @timestamp = timestamp
+      @pid = pid
+      @html = success_msg
+      return erb :success
+    rescue Exception => e
+      # If something went wrong with the fork, release the lock immediately and return
+      unlock
+      return report_error("Unexpected Runtime Error", "Runtime error while executing" +
+          " appscale tools: #{e.message}")
+    end
+  else
+    return report_error("Server Busy", "AppsCake is currently busy deploying a cloud." +
+        " Please try again later.")
+  end
+end
+
+def deploy_on_ec2(params, run_instances_options, cert_timestamp)
+  if lock
+    begin
+      timestamp = Time.now.to_i
+      pid = fork do
+        ENV['EC2_REGION'] = params[:region]
+        ENV['EC2_PRIVATE_KEY'] = File.join(File.dirname(__FILE__), "certificates",
+                                    "#{params[:username]}_#{cert_timestamp}_pk.pem")
+        ENV['EC2_CERT'] = File.join(File.dirname(__FILE__), "certificates",
+                                           "#{params[:username]}_#{cert_timestamp}_cert.pem")
+        ENV['EC2_ACCESS_KEY'] = params[:access_key]
+        ENV['EC2_SECRET_KEY'] = params[:secret_key]
+        ENV['EC2_JVM_ARGS'] = "-Djavax.net.ssl.trustStore=#{ENV['JAVA_HOME']}/lib/security/cacerts"
+        ENV['EC2_URL'] = "https://ec2.#{params[:region]}.amazonaws.com"
+        ENV['S3_URL'] = "https://s3.amazonaws.com:443"
+        begin
+          redirect_standard_io(timestamp) do
+            AppScaleTools.run_instances(run_instances_options)
+          end
+        ensure
+          # If the fork was successful, the sub-process should release the lock
+          unlock
+        end
+      end
+      Process.detach(pid)
+      @timestamp = timestamp
+      @pid = pid
+      @html = ""
+      return erb :success
+    rescue Exception => e
+      # If something went wrong with the fork, release the lock immediately and return
+      unlock
+      return report_error("Unexpected Runtime Error", "Runtime error while executing" +
+          " appscale tools: #{e.message}")
+    end
+  else
+    return report_error("Server Busy", "AppsCake is currently busy deploying a cloud." +
+        " Please try again later.")
+  end
+end