OpenNebula

if [ -z "$ONE_LOCATION" ]; then

    SUNSTONE_PID=/var/run/one/sunstone.pid

    SUNSTONE_SERVER=/usr/lib/one/sunstone/config.ru

    SUNSTONE_LOCK_FILE=/var/lock/one/.sunstone.lock

    SUNSTONE_LOG=/var/log/one/sunstone.log

else

    SUNSTONE_PID=$ONE_LOCATION/var/sunstone.pid

    SUNSTONE_SERVER=$ONE_LOCATION/lib/sunstone/config.ru

    SUNSTONE_LOCK_FILE=$ONE_LOCATION/var/.sunstone.lock

    SUNSTONE_LOG=$ONE_LOCATION/var/sunstone.log

fi

PORT="4567"

HOST="127.0.0.1"

setup()

{

  if [ -f $SUNSTONE_LOCK_FILE ]; then

    if [ -f  $SUNSTONE_PID ]; then

      SUNSTONEPID=`cat $SUNSTONE_PID`

      ps $SUNSTONEPID &> /dev/null

      if [ $? -eq 0 ]; then

        echo "Sunstone Server is still running (PID:$SUNSTONEPID). Please try 'sunstone-server stop' first."

        exit 1

      fi

    fi

    echo "Stale .lock detected. Erasing it."

    rm $SUNSTONE_LOCK_FILE

  fi

}

start()

{

  if [ ! -f "$SUNSTONE_SERVER" ]; then

    echo "Can not find $SUNSTONE_SERVER."

    exit 1

  fi

  # Start the sunstone daemon

  touch $SUNSTONE_LOCK_FILE

  rackup $SUNSTONE_SERVER -s thin -p $PORT -o $HOST -P $SUNSTONE_PID &> $SUNSTONE_LOG &

  LASTRC=$?

  if [ $LASTRC -ne 0 ]; then

    echo "Error executing $SUNSTONE_SERVER"

    exit 1

  fi

  sleep 1

  ps $LASTPID &> /dev/null

  if [ $? -ne 0 ]; then

    echo "Error executing $SUNSTONE_SERVER."

    exit 1

  fi

  echo "sunstone-server started"

}

#

# Function that stops the daemon/service

#

stop()

{

  if [ ! -f $SUNSTONE_PID ]; then

    echo "Couldn't find sunstone-server process pid."

    exit 1

  fi

  # Kill the sunstone daemon

  kill -INT `cat $SUNSTONE_PID` &> /dev/null

  echo "sunstone-server stopped"

}

while getopts "p:h:" OPTION

do

  case $OPTION in

    p)  PORT=$OPTARG;;

    h)  HOST=$OPTARG;;

    \?) echo "Invalid option: -$OPTARG" >&2; exit 3 ;;

  esac

done

shift $((OPTIND-1))

case "$1" in

  start)

  setup

  start

  ;;

  stop)

  stop

  ;;

  *)

  echo "Usage: sunstone {start|stop}" >&2

  exit 3

  ;;

esac

require 'sunstone-server.rb'

$: << File.dirname(__FILE__)

require 'OpenNebulaJSON/ClusterJSON'

require 'OpenNebulaJSON/HostJSON'

require 'OpenNebulaJSON/ImageJSON'

require 'OpenNebulaJSON/JSONUtils'

require 'OpenNebulaJSON/PoolJSON'

require 'OpenNebulaJSON/UserJSON'

require 'OpenNebulaJSON/VirtualMachineJSON'

require 'OpenNebulaJSON/VirtualNetworkJSON'

require 'OpenNebulaJSON/JSONUtils'

require 'OpenNebulaJSON/JSONUtils'

require 'OpenNebulaJSON/JSONUtils'

require 'OpenNebulaJSON/JSONUtils'

require 'OpenNebulaJSON/JSONUtils'

require 'OpenNebulaJSON/JSONUtils'

require 'OpenNebulaJSON/JSONUtils'

# -------------------------------------------------------------------------- #

# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             #

#                                                                            #

# Licensed under the Apache License, Version 2.0 (the "License"); you may    #

# not use this file except in compliance with the License. You may obtain    #

# a copy of the License at                                                   #

#                                                                            #

# http://www.apache.org/licenses/LICENSE-2.0                                 #

#                                                                            #

# Unless required by applicable law or agreed to in writing, software        #

# distributed under the License is distributed on an "AS IS" BASIS,          #

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #

# See the License for the specific language governing permissions and        #

# limitations under the License.                                             #

#--------------------------------------------------------------------------- #

# TBD Change path for intallation tree

#require 'OpenNebulaJSON'

require 'models/OpenNebulaJSON'

include OpenNebulaJSON

class OneUI

    def initialize(username, password)

        # TBD one_client_user(name) from CloudServer

        @client = Client.new("dummy:dummy")

        @client.one_auth = "#{username}:#{password}"

    end

    ############################################################################

    #

    ############################################################################

    def self.authorize(user="", sha1_pass="")

        if user.empty? || sha1_pass.empty?

            return [401, false]

        end

        # TBD get_user_password(name) from CloudServer

        user_pool = UserPool.new(Client.new)

        rc = user_pool.info

        if OpenNebula.is_error?(rc)

            return [500, false]

        end

        user_pass = user_pool["USER[NAME=\"#{user}\"]/PASSWORD"]

        if user_pass == sha1_pass

            return [204, user_pool["USER[NAME=\"#{user}\"]/ID"]]

        else

            return [401, nil]

        end

    end

    ############################################################################

    #

    ############################################################################

    def get_pool(kind, user_id)

        user_flag = user_id=="0" ? -2 : -1

        pool = case kind

            when "cluster" then ClusterPoolJSON.new(@client)

            when "host"    then HostPoolJSON.new(@client)

            when "image"   then ImagePoolJSON.new(@client, user_flag)

            when "vm"      then VirtualMachinePoolJSON.new(@client, user_flag)

            when "vnet"    then VirtualNetworkPoolJSON.new(@client, user_flag)

            when "user"    then UserPoolJSON.new(@client)

            else

                error = Error.new("Error: #{kind} resource not supported")

                return [404, error.to_json]

        end

        rc = pool.info

        if OpenNebula.is_error?(rc)

            return [500, rc.to_json]

        else

            return [200, pool.to_json]

        end

    end

    ############################################################################

    #

    ############################################################################

    def get_resource(kind, id)

        resource = retrieve_resource(kind, id)

        if OpenNebula.is_error?(resource)

            return [404, resource.to_json]

        else

            return [200, resource.to_json]

        end

    end

    ############################################################################

    #

    ############################################################################

    def create_resource(kind, template)

        resource = case kind

            when "cluster" then ClusterJSON.new(Cluster.build_xml, @client)

            when "host"    then HostJSON.new(Host.build_xml, @client)

            when "image"   then ImageJSON.new(Image.build_xml, @client)

            when "vm"      then VirtualMachineJSON.new(VirtualMachine.build_xml,@client)

            when "vnet"    then VirtualNetworkJSON.new(VirtualNetwork.build_xml, @client)

            when "user"    then UserJSON.new(User.build_xml, @client)

            else

                error = Error.new("Error: #{kind} resource not supported")

                return [404, error.to_json]

        end

        rc = resource.allocate(template)

        if OpenNebula.is_error?(rc)

            return [500, rc.to_json]

        else

            resource.info

            return [201, resource.to_json]

        end

    end

    ############################################################################

    #

    ############################################################################

    def delete_resource(kind, id)

        resource = retrieve_resource(kind, id)

        if OpenNebula.is_error?(resource)

            return [404, resource.to_json]

        end

        rc = resource.delete

        if OpenNebula.is_error?(rc)

            return [500, rc.to_json]

        else

            return [204, resource.to_json]

        end

    end

    ############################################################################

    #

    ############################################################################

    def perform_action(kind, id, action_json)

        resource = retrieve_resource(kind, id)

        if OpenNebula.is_error?(resource)

            return [404, resource.to_json]

        end

        rc = resource.perform_action(action_json)

        if OpenNebula.is_error?(rc)

            return [500, rc.to_json]

        else

            return [204, resource.to_json]

        end

    end

    ############################################################################

    #

    ############################################################################

    def get_configuration

        one_config = VAR_LOCATION + "/config"

        config = Hash.new

        begin

            cfg = File.read(one_config)

        rescue Exception => e

            error = Error.new("Error reading config: #{e.inspect}")

            return [500, error.to_json]

        end

        cfg.lines do |line|

            m=line.match(/^([^=]+)=(.*)$/)

            if m

                name=m[1].strip.upcase

                value=m[2].strip

                config[name]=value

            end

        end

        return [200, config.to_json]

    end

    ############################################################################

    #

    ############################################################################

    def get_vm_log(id)

        id = id.to_s

        vm_log_file = VAR_LOCATION + "/#{id}/vm.log"

        begin

            log = File.read(vm_log_file)

        rescue Exception => e

            error = Error.new("Error: log for VM #{id} not available")

            return [500, error.to_s]

        end

        return [200, log]

    end

    private

    def retrieve_resource(kind, id)

        resource = case kind

            when "cluster" then ClusterJSON.new_with_id(id, @client)

            when "host"    then HostJSON.new_with_id(id, @client)

            when "image"   then ImageJSON.new_with_id(id, @client)

            when "vm"      then VirtualMachineJSON.new_with_id(id, @client)

            when "vnet"    then VirtualNetworkJSON.new_with_id(id, @client)

            when "user"    then UserJSON.new_with_id(id, @client)

            else

                error = Error.new("Error: #{kind} resource not supported")

                return error

        end

        rc = resource.info

        if OpenNebula.is_error?(rc)

            return rc

        else

            return resource

        end

    end

end

#!/usr/bin/env ruby

# -------------------------------------------------------------------------- #

# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             #

#                                                                            #

# Licensed under the Apache License, Version 2.0 (the "License"); you may    #

# not use this file except in compliance with the License. You may obtain    #

# a copy of the License at                                                   #

#                                                                            #

# http://www.apache.org/licenses/LICENSE-2.0                                 #

#                                                                            #

# Unless required by applicable law or agreed to in writing, software        #

# distributed under the License is distributed on an "AS IS" BASIS,          #

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #

# See the License for the specific language governing permissions and        #

# limitations under the License.                                             #

#--------------------------------------------------------------------------- #

##############################################################################

# Environment Configuration for the Server

##############################################################################

HOST     = "127.0.0.1"

PORT     = "4567"

##############################################################################

# Required libraries

##############################################################################

require 'rubygems'

require 'sinatra'

require 'models/OneUI'

##############################################################################

# Sinatra Configuration

##############################################################################

set :host, HOST

set :port, PORT

use Rack::Session::Pool

##############################################################################

# Helpers

##############################################################################

helpers do

    def authorized?

        session["ip"] && session["ip"]==request.ip ? true : false

    end

    def build_session

        auth = Rack::Auth::Basic::Request.new(request.env)

        if auth.provided? && auth.basic? && auth.credentials

            user = auth.credentials[0]

            sha1_pass = Digest::SHA1.hexdigest(auth.credentials[1])

            rc = OneUI.authorize(user, sha1_pass)

            if rc[1]

                session["user"]       = user

                session["user_id"]    = rc[1]

                session["password"]   = sha1_pass

                session["ip"]         = request.ip

                session["user_agent"] = request.user_agent

                session["remember"]   = params[:remember]

                if params[:remember]

                    env['rack.session.options'][:expire_after] = 30*60*60*24

                end

                return [204, ""]

            else

                return [rc.first, ""]

            end

        end

        return [401, ""]

    end

    def destroy_session

        session.clear

        return [204, ""]

    end

end

before do

    unless request.path=='/login' || request.path=='/'

        halt 401 unless authorized?

        @OneUI = OneUI.new(session["user"], session["password"])

    end

end

after do

    unless request.path=='/login' || request.path=='/'

        unless session['remember']

            if params[:timeout] === true

                env['rack.session.options'][:defer] = true

            else

                env['rack.session.options'][:expire_after] = 60*10

            end

        end

    end

end

##############################################################################

# HTML Requests

##############################################################################

get '/' do

    redirect '/login' unless authorized?

    time = Time.now + 60

    response.set_cookie("one-user", :value=>"#{session['user']}", :expires=>time)

    response.set_cookie("one-user_id", :value=>"#{session['user_id']}", :expires=>time)

    File.read(File.dirname(__FILE__)+'/templates/index.html')

end

get '/login' do

    File.read(File.dirname(__FILE__)+'/templates/login.html')

end

##############################################################################

# Login

##############################################################################

post '/login' do

    build_session

end

post '/logout' do

    destroy_session

end

##############################################################################

# GET Pool information

##############################################################################

get '/:pool' do

    @OneUI.get_pool(params[:pool], session["user_id"])

end

##############################################################################

# GET Resource information

##############################################################################

get '/:resource/:id' do

    @OneUI.get_resource(params[:resource], params[:id])

end

##############################################################################

# Delete Resource

##############################################################################

delete '/:resource/:id' do

    @OneUI.delete_resource(params[:resource], params[:id])

end

##############################################################################

# Create a new Resource

##############################################################################

post '/:pool' do

    @OneUI.create_resource(params[:pool], request.body.read)

end

##############################################################################

# Perform an action on a Resource

##############################################################################

post '/:resource/:id/action' do

    @OneUI.perform_action(params[:resource], params[:id], request.body.read)

end

##############################################################################

# Config and Logs

##############################################################################

get '/config' do

    @OneUI.get_configuration

end

get '/vm/:id/log' do

    @OneUI.get_vm_log(params[:id].to_i)

end