fog-oraclecloud 0.1.15 → 0.1.16

data/lib/fog/oraclecloud/database.rb

@@ -17,6 +17,8 @@ module Fog
       collection  :servers
       model       :patch
       collection  :patches
+      model       :access_rule
+      collection  :access_rules
 
 			request_path 'fog/oraclecloud/requests/database'
       request :list_instances
@@ -35,6 +37,8 @@ module Fog
       request :backup_instance
       request :recover_instance
       request :list_patches
+      request :create_access_rule
+      request :get_access_rule
 
       class Real
 
@@ -62,6 +66,7 @@ module Fog
 
         def request(params, parse_json = true, &block)
           begin
+            Fog::Logger.debug("Sending #{params[:body].to_s} to #{params[:path]}")
             response = @connection.request(params.merge!({
               :headers  => {
                 'Authorization' => auth_header,
@@ -109,6 +114,7 @@ module Fog
             :snapshots  => {},
             :servers    => {},
             :backups    => {},
+            :access_rules => {},
             :recoveries => {},
             :deleted_at => {},
             :created_at => {},

data/lib/fog/oraclecloud/java.rb

@@ -54,6 +54,7 @@ module Fog
 
         def request(params, parse_json = true, &block)
 					begin
+            Fog::Logger.debug("Sending #{params[:body].to_s} to #{params[:path]}")
 						response = @connection.request(params.merge!({
 							:headers  => {
 								'Authorization' => auth_header,

data/lib/fog/oraclecloud/models/compute/instance.rb

@@ -58,9 +58,9 @@ module Fog
         end
 
         def create
-        	requires :name, :shape, :imagelist, :sshkeys
+        	requires :name, :sshkeys
           
-          data = service.create_instance(name, shape, imagelist, label, sshkeys)
+          data = service.create_instance(name, shape || 'oc3', imagelist || '/oracle/public/oel_6.4_2GB_v1', label, sshkeys)
           merge_attributes(data.body['instances'][0])
         end
 
@@ -68,6 +68,68 @@ module Fog
         	requires :name
         	service.delete_instance(name)
         end
+
+        def get_security_lists
+        	seclists = []
+        	networking['eth0']['seclists'].each do |seclist| 
+        		seclists.push(Fog::Compute[:oraclecloud].security_lists.new({
+        			'name'=>seclist
+        		}))
+        	end
+        	seclists
+        end
+
+        def create_security_list(seclist_name=nil, description=nil, policy="deny", outbound_policy="permit")
+        	if !seclist_name then
+        		seclist_name = "#{name}_SecList"
+        	end
+        	data = Fog::Compute[:oraclecloud].security_lists.create(
+        		:name => seclist_name,
+        		:description => description,
+        		:policy => policy,
+        		:outbound_cidr_policy => outbound_policy
+        	)
+        	# Now attach to this instance
+        	Fog::Compute[:oraclecloud].security_associations.create(
+        		:name => "#{name}_SecAssoc",
+        		:seclist => seclist_name,
+        		:vcable => vcable_id
+        	)
+        	data
+        end
+
+        def get_public_ip_address
+        	if !networking['eth0'] or !networking['eth0']['nat'] or !networking['eth0']['nat'].include? 'ipreservation:' then
+        		# Instance doesn't have a public ip reservation yet
+        		return false
+        	end
+        	ip_name = networking['eth0']['nat'].sub "ipreservation:", ''
+        	ip = Fog::Compute[:oraclecloud].ip_reservations.get(ip_name)
+        	ip.ip
+        end
+
+        def add_public_ip_address
+        	existing = get_public_ip_address 
+        	if existing then
+        		raise ArgumentError.new "Can't add public id address to instance that already has one (#{existing.ip})"
+        	end
+        	begin 
+        		ip = Fog::Compute[:oraclecloud].ip_reservations.get("#{name}_publicIp")
+        	rescue Fog::Compute::OracleCloud::NotFound    
+        		# Doesn't exist yet. Create it now
+	        	ip = Fog::Compute[:oraclecloud].ip_reservations.create(
+	        		:name => "#{name}_publicIp"
+	        	)
+	        end
+        	# Attach it to this instance
+        	Fog::Logger.debug "Associating IP Reservation (#{name}_publicIp) with vcable: #{vcable_id}"
+        	assoc = Fog::Compute[:oraclecloud].ip_associations.create(
+        		:parentpool => "ipreservation:#{name}_publicIp",
+        		:vcable => vcable_id
+        	)
+        	Fog::Logger.debug "Created IP Association - #{assoc.uri}"
+        	ip
+        end
 	    end
 	  end
   end

data/lib/fog/oraclecloud/models/compute/ip_association.rb

@@ -0,0 +1,42 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+  	class OracleCloud
+	    class IpAssociation < Fog::Model
+	      identity  :name
+
+	      attribute :account
+	      attribute :ip
+	      attribute :parentpool
+	      attribute :reservation
+	      attribute :vcable
+	      attribute :uri
+
+ 				def save
+ 					if name.nil? then
+	          create
+	         else
+            # TODO: Support?
+	         	#update
+	        end
+        end
+
+        def create 
+          requires :parentpool, :vcable
+          data = service.create_ip_association({
+          	:parentpool => parentpool,
+            :vcable => vcable
+          })
+          merge_attributes(data.body)
+        end
+
+        def destroy
+        	requires :name
+        	service.delete_ip_association(name)
+        end
+
+	    end
+	  end
+  end
+end

data/lib/fog/oraclecloud/models/compute/ip_associations.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+
+module Fog
+  module Compute
+  	class OracleCloud
+	    class IpAssociations < Fog::Collection
+
+	    	model Fog::Compute::OracleCloud::IpAssociation
+				
+				def all
+					data = service.list_ip_associations().body['result']
+					load(data)
+				end
+
+ 				def get(name)
+          data = service.get_ip_association(name).body
+          new(data)
+        end
+	    end
+	  end
+  end
+end

data/lib/fog/oraclecloud/models/compute/ip_reservation.rb

@@ -16,14 +16,18 @@ module Fog
 	      attribute :used
 
  				def save
- 					if !name.nil? && !name.start_with?("/Compute-") then
-	          create
-	         else
-	         	update
-	        end
+          begin
+            # Check if it's already created
+            res = Fog::Compute[:oraclecloud].ip_reservations.get(name)
+            update
+          rescue Fog::Compute::OracleCloud::NotFound    
+            # It wasn't found. 
+            create
+          end
         end
 
         def create 
+          requires :name
           data = service.create_ip_reservation({
           	:name => name,
           	:parentpool => parentpool || '/oracle/public/ippool', 
@@ -34,6 +38,7 @@ module Fog
         end
 
         def update
+          requires :name, :parentpool
         	data = service.update_ip_reservation({
         		:name => name,
         		:parentpool => parentpool,

data/lib/fog/oraclecloud/models/compute/security_application.rb

@@ -30,6 +30,7 @@ module Fog
                                             :icmptype => icmptype,
                                             :icmpcode => icmpcode,
                                             :description => description)
+          merge_attributes(data.body)
         end
 
         def destroy

data/lib/fog/oraclecloud/models/compute/security_applications.rb

@@ -1,5 +1,3 @@
-require 'fog/core/collection'
-
 module Fog
   module Compute
   	class OracleCloud
@@ -9,6 +7,12 @@ module Fog
 				
 				def all
 					data = service.list_security_applications().body['result']
+					public_data = service.list_security_applications('public').body['result']
+					load(data.concat(public_data))
+				end
+
+				def all_public
+					data = service.list_security_applications('public').body['result']
 					load(data)
 				end
 

data/lib/fog/oraclecloud/models/compute/security_association.rb

@@ -0,0 +1,31 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+  	class OracleCloud
+	    class SecurityAssociation < Fog::Model
+	      identity  :name
+
+	      attribute :seclist
+	      attribute :vcable
+	      attribute :uri
+
+ 				def save
+          #identity ? update : create
+          create
+        end
+
+				def create
+        	requires :name, :seclist, :vcable
+          
+          data = service.create_security_association(name, seclist, vcable)
+        end
+
+        def destroy
+          requires :name
+          service.delete_security_association(name)
+        end
+	    end
+	  end
+  end
+end

data/lib/fog/oraclecloud/models/compute/security_associations.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Compute
+  	class OracleCloud
+	    class SecurityAssociations < Fog::Collection
+
+	    	model Fog::Compute::OracleCloud::SecurityAssociation
+				
+				def all
+					data = service.list_security_associations().body['result']
+					load(data)
+				end
+
+ 				def get(name)
+          data = service.get_security_association(name).body
+          new(data)
+        end
+	    end
+	  end
+  end
+end

data/lib/fog/oraclecloud/models/compute/security_ip_list.rb

@@ -0,0 +1,27 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+  	class OracleCloud
+	    class SecurityIpList < Fog::Model
+	      identity  :name
+
+	      attribute :description
+	      attribute :uri
+	      attribute :secipentries
+
+ 	      def save
+          #identity ? update : create
+          create
+        end
+
+        def create
+        	requires :name, :secipentries
+          
+          data = service.create_security_ip_list(name, description, secipentries)
+          merge_attributes(data.body)
+        end
+	    end
+	  end
+  end
+end

data/lib/fog/oraclecloud/models/compute/security_ip_lists.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+
+module Fog
+  module Compute
+  	class OracleCloud
+	    class SecurityIpLists < Fog::Collection
+
+	    	model Fog::Compute::OracleCloud::SecurityIpList
+				
+				def all
+					data = service.list_security_ip_lists().body['result']
+					load(data)
+				end
+
+ 				def get(name)
+          data = service.get_security_ip_list(name).body
+          new(data)
+        end
+	    end
+	  end
+  end
+end

data/lib/fog/oraclecloud/models/compute/security_list.rb

@@ -7,7 +7,7 @@ module Fog
 	      identity  :name
 
 	      attribute :account
-	      attribute :name
+	      attribute :description
 	      attribute :uri
 	      attribute :outbound_cidr_policy
 	      attribute :proxyuri
@@ -20,6 +20,80 @@ module Fog
           #identity ? update : create
           create
         end
+
+        def create
+        	requires :name
+          
+          data = service.create_security_list(name, description, policy, outbound_cidr_policy)
+          merge_attributes(data.body)
+
+        end
+
+				def destroy
+        	requires :name
+        	service.delete_security_list(name)
+        end
+
+        def add_rule (port, list, rule_name=nil) 
+        	if !rule_name then rule_name = "#{name}_#{port}_#{list}" end
+        	if port.is_a? Numeric then
+        		# See if it's a public port
+        		secapps = Fog::Compute[:oraclecloud].security_applications.all_public
+        		public_app = secapps.detect { |app| 
+        			Float(app.dport || 0) == port }
+        		if public_app then
+        			secapp = public_app.name
+        		else
+        			begin
+        				custom_app = Fog::Compute[:oraclecloud].security_applications.get("#{name}_#{port}")
+        			rescue Fog::Compute::OracleCloud::NotFound		
+
+	        			# Create custom security application
+	        			custom_app = Fog::Compute[:oraclecloud].security_applications.create(
+	        				:name => "#{name}_#{port}",
+	        				:protocol => 'tcp',
+	        				:dport => port
+	        			)
+	        		end
+        			secapp = custom_app.name
+        		end
+        	else
+        		# They want to use a named security application
+        		# TODO: Add support for user created security apps
+        		secapp = '/oracle/public/' + port
+        	end
+        	block = /\d{,2}|1\d{2}|2[0-4]\d|25[0-5]/
+					re = /\A#{block}\.#{block}\.#{block}\.#{block}\z/
+
+        	if re =~ list then 
+        		# They sent an ip address. Create new security ip list
+        		# Check if it exists already (assume this has been run before)
+        		begin
+        			seclist = Fog::Compute[:oraclecloud].security_ip_lists.get("#{name}_#{list}")
+        		rescue Fog::Compute::OracleCloud::NotFound		
+	        		Fog::Logger.debug "Creating Security IP List for #{list}"
+	        		seclist = Fog::Compute[:oraclecloud].security_ip_lists.create(
+	        			:name => "#{name}_#{list}",
+	        			:secipentries => [list]
+	        		)
+	        	end
+						list_name = "seciplist:#{name}_#{list}"        		
+        	else
+        		list_name = list
+        	end
+        	begin
+        		rule = Fog::Compute[:oraclecloud].security_rules.get(rule_name)
+        	rescue Fog::Compute::OracleCloud::NotFound		
+	        	Fog::Logger.debug "Creating Security Rule for #{list_name} to #{name} (app:#{port})"
+	        	rule = Fog::Compute[:oraclecloud].security_rules.create(
+	        		:application => secapp,
+	        		:name => rule_name,
+	        		:src_list => list_name,
+	        		:dst_list => "seclist:#{name}" 
+	        	) 
+	        end
+	        rule
+        end
 	    end
 	  end
   end