c66-copper 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb48cc101f266912993eabc1c9836ca74d693afb
+  data.tar.gz: b13bfa681af1d729ca5185ddff419940e5921713
+SHA512:
+  metadata.gz: b1137fb18f6e4f9ce9772056fad87741df3ecf9a47f9b61110038021bfc2b1551840644ae957e28b44b2d7fe060f543f9c35f650954806d7decdfd100412fb9c
+  data.tar.gz: a69ea15d41f510779d435b9eb74bfad4752396d551dcbd5ee513c7b40ab0fd9263d02d35a0d745e02b195a655035c5c74a28c8b73a8d85e30e248a91ef67375f

data/README.md

@@ -0,0 +1,5 @@
+# Copper
+
+### Copper is a configuration validator for Kubernetes by Cloud 66
+
+For more information, please visit [http://copper.sh](http://copper.sh)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "copper"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/copper

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+require 'thor'
+require 'yaml'
+require 'colorize'
+require_relative '../lib/copper'
+
+module Copper
+	class CopperCLI < Thor
+		package_name "copper"
+
+		desc "version", "Show Copper version"
+		def version
+			say "#{::Copper::APP_NAME} #{::Copper::VERSION}\n#{::Copper::COPYRIGHT_MESSAGE}"
+		end
+
+		desc "update", "Update Copper to the latest version"
+		option :version, type: :string, desc: "Force a specific version"
+		def update
+			say "Updating Copper..."
+			unless options[:version]
+				say `gem install copper --no-ri --no-rdoc`
+			else
+				say `gem install copper -v #{options[:version]} --no-ri --no-rdoc`
+			end
+		end
+
+		desc "check", "Runs the given rules against a file"
+		option :rules, type: :string, desc: "Rules in ccop file format"
+		option :file, type: :string, desc: "Configuration file"
+		option :format, type: :string, enum: ['yaml'], default: 'yaml'
+		option :debug, type: :boolean, default: false
+		option :'parserdebug', type: :boolean, default: false
+		def check
+			$debug = options[:debug] || false
+			$parser_debug = options[:'parserdebug'] || false
+			require 'byebug' if $debug
+
+			rule_file = options[:rules]
+			unless File.exists?(rule_file)
+				puts "Rule file #{rule_file} not found".red
+				exit(1)
+			end
+			content_file = options[:file]
+			unless File.exists?(content_file)
+				puts "Config file #{content_file} not found".red
+				exit(1)
+			end
+
+			rules = File.read(rule_file)
+			file = ""
+			raise ::NotImplementedError if options[:format] != 'yaml'
+			# load the yaml file and split them into separate yamls
+
+			content = File.read(content_file)
+			content.split('---').each_with_index do |part, idx|
+				puts "Validating part #{idx}"
+				file = YAML::load(part)
+				validate(rules, file)
+			end
+		end
+
+		no_commands {
+		def validate(rules, file)
+			ccop = ::Copper::Copper.new(rules, { context: file })
+			results = ccop.execute
+
+			if results.nil?
+				puts "Aborting"
+				exit
+			end
+
+			results.each do |rule|
+				action = rule[:action]
+				outcome = rule[:outcome]
+				if !outcome
+					if action == :warn
+						outcome_text = 'WARN'.yellow
+					else
+						outcome_text = 'FAIL'.red
+					end
+				else
+					outcome_text = 'PASS'.green
+				end
+				puts "\t#{rule[:name]} - #{outcome_text}"
+			end
+		rescue ::Copper::ParseError => exc
+			puts "Syntax error: #{exc.message} at line #{ccop.parser.failure_line}, column: #{ccop.parser.failure_column}"
+		rescue ::Copper::RuntimeError => exc
+			puts "Runtime error: #{exc.message}"
+		end
+		}
+
+	end
+
+	CopperCLI.start
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/copper/action.rb

@@ -0,0 +1,9 @@
+module Copper
+	class Action < CopperNode
+
+		def value(vars = {})
+			return text_value.to_sym
+		end
+
+	end
+end

data/lib/copper/attribute.rb

@@ -0,0 +1,30 @@
+module Copper
+
+	class Attribute < CopperNode
+
+		# attribute takes in a parent as it always depends on another node
+		# like "abc".count here count is the attribute and string (abc) is the parent
+		# parent is a PORO
+		def value(parent, vars = {})
+			raise "invalid use of attribute" if parent.nil? # this shouldn't happen as parser will not let .count to be called without a parent
+
+			# 0 is the name of the attribute
+			attribute = elements[0].value
+			# 1 is the params and is optional
+			params = elements[1].value(vars) unless elements[1].nil?
+
+			# now we should call the func based on the name of the attribute with params on parent
+			# here we first convert the PORO to a DataType to make the calls safe
+			dt_obj = factory(parent)
+			if dt_obj.respond_to?(attribute)
+				if params.nil?
+					return dt_obj.send(attribute)
+				else
+					return dt_obj.send(attribute, *params)
+				end
+			else
+				raise ParseError, "#{attribute} is not a valid attribute for #{dt_obj.class.name}"
+			end
+		end
+	end
+end

data/lib/copper/attribute_params.rb

@@ -0,0 +1,9 @@
+module Copper
+	class AttributeParams < CopperNode
+
+		def value(vars = {})
+			return elements[0].value(vars)
+		end
+
+	end
+end

data/lib/copper/attributes.rb

@@ -0,0 +1,21 @@
+module Copper
+
+	class Attributes < CopperNode
+
+		# parent is the object attributes work on
+		# like "abc".map(xxx).count : abc (string) is parent for gsub and array from map is the parent for count
+		def value(parent, vars = {})
+			# this has all the attributes as an array. they will be [attribute, attributes]
+			# attributes will then be [attribute and attributes] and so on
+
+			current_obj = elements[0].value(parent, vars)
+			# no right association, so we are the last attribute
+			return current_obj if elements[1].nil?
+
+			# has right association, which means we need to get the value of the current attribute and pass into the
+			# next one
+			return elements[1].value(current_obj, vars)
+		end
+
+	end
+end

data/lib/copper/attributes_right_associated.rb

@@ -0,0 +1,11 @@
+module Copper
+	class AttributesRightAssociated < CopperNode
+		def value(vars = {})
+			byebug
+			rhs = self.parent.elements[0].value(vars)
+			lhs = self.elements[1].value(vars)
+
+			return lhs
+		end
+	end
+end

data/lib/copper/boolean.rb

@@ -0,0 +1,9 @@
+module Copper
+	class Boolean < CopperNode
+
+		def value(vars = {})
+			return text_value == 'true'
+		end
+
+	end
+end

data/lib/copper/comparison.rb

@@ -0,0 +1,58 @@
+module Copper
+	class Comparison < CopperNode
+
+		def value(vars = {})
+			lhs = elements[0].value(vars)
+			comp_op = elements[1].value(vars)
+			rhs = elements[2].value(vars)
+
+			raise ParseError, "cannot compare nil" if rhs.nil? || lhs.nil?
+
+			begin
+				case comp_op
+				when '='
+					return equality(lhs, rhs)
+				when '=='
+					return equality(lhs, rhs)
+				when '>'
+					return lhs > rhs
+				when '<'
+					return lhs < rhs
+				when '<='
+					return lhs <= rhs
+				when '>='
+					return lhs > rhs
+				when '!='
+					return lhs != rhs
+				when 'in'
+					# this depends on the types
+					rhs_class = ::Copper::DataTypes::DataType.get_class(rhs.class.name)
+					rhs_obj = rhs_class.new(rhs)
+					if rhs_obj.respond_to?(:in)
+						return rhs_obj.in(lhs)
+					else
+						raise ::Copper::RuntimeError, "in is not a valid comparision on #{rhs_class.name}"
+					end
+
+				when '->'
+					# this is a special case to pipe lhs to console
+					console(lhs)
+				end
+			rescue NoMethodError => exc
+				raise ParseError, "comparison error: #{exc.message}"
+			end
+		end
+
+		private
+
+		def equality(lhs, rhs)
+			if lhs.is_a?(Array) && rhs.is_a?(Array)
+				return lhs.sort == rhs.sort
+			else
+				return lhs == rhs
+			end
+		rescue ArgumentError => exc
+			raise ParseError, "equality comparison failed: #{exc.message}"
+		end
+	end
+end

data/lib/copper/compop.rb

@@ -0,0 +1,8 @@
+module Copper
+	class CompOp < CopperNode
+
+		def value(vars = {})
+			return text_value
+		end
+	end
+end

data/lib/copper/copper.rb

@@ -0,0 +1,32 @@
+module Copper
+	class Copper
+		def initialize(content, vars = {})
+			@content = content
+			@vars = vars
+
+			# add the resevered ones
+			@vars[:variables] = ::Copper::DataTypes::DataType::RESEVERED_TYPES
+			@parser = Parser.new
+		end
+
+		def execute(options = {})
+			root_node = @parser.parse(@content)
+			result = root_node.value(@vars) unless root_node.nil?
+			puts result if $debug
+
+			return result
+		end
+
+		def valid?
+			self.execute(@content, @vars)
+			return true
+		rescue CopperError
+			return false
+		end
+
+		def parser
+			@parser.cc_parser
+		end
+
+	end
+end

data/lib/copper/copper_node.rb

@@ -0,0 +1,16 @@
+module Copper
+	# Copper parser node with helper methods for cleaning.
+	class CopperNode < Treetop::Runtime::SyntaxNode
+
+		protected
+
+		def console(text)
+			puts "[DEBUG] #{self.class.name} ==> #{text} (#{text.class.name})" if $debug
+		end
+
+		def factory(poro)
+			return ::Copper::DataTypes::DataType.factory(poro)
+		end
+
+	end
+end

data/lib/copper/data_types/array.rb

@@ -0,0 +1,61 @@
+module Copper
+	module DataTypes
+		class Array < DataType
+
+			def count
+				return @value.size
+			end
+
+			def first
+				raise RuntimeError, "cannot call first on an empty array" if @value.empty?
+				return @value.first
+			end
+
+			def last
+				raise RuntimeError, "cannot call last on an empty array" if @value.empty?
+				return @value.last
+			end
+
+			def in(value)
+				@value.include?(value)
+			end
+
+			# get item at index
+			def at(index)
+				if index >= @value.size
+					raise RuntimeError, "index #{index} out of bound [0..#{@result.size - 1}]"
+				else
+					return @value[index]
+				end
+			end
+
+			# map the items into the given class
+			def as(clazz)
+				found_class = ::Copper::DataTypes::DataType.get_class(clazz)
+				return @value.map { |x| found_class.new(x).value }
+			end
+
+			def extract(regex, index)
+				result = []
+				@value.each do |v|
+					raise RuntimeError, "#{v} is not a String" unless v.is_a?(::String)
+					found = v.match(regex)
+					result << nil if found.nil?
+					result << nil if found[index].nil?
+					result << found[index]
+				end
+
+				return result
+			end
+
+			def unique
+				@value.uniq
+			end
+
+			def contains(item)
+				@value.include?(item)
+			end
+
+		end
+	end
+end

data/lib/copper/data_types/data_type.rb

@@ -0,0 +1,54 @@
+module Copper
+	module DataTypes
+		class DataType
+
+			CLASS_MAP = {
+				"String" => "::Copper::DataTypes::String",
+				"Array" => "::Copper::DataTypes::Array",
+				"Semantic::Version" => "::Copper::DataTypes::Semver",
+				"Semver" => "::Copper::DataTypes::Semver",
+				"Range" => "::Copper::DataTypes::Range",
+				"IPAddress" => "::Copper::DataTypes::IPAddress",
+				"IPAddress::IPv4" => "::Copper::DataTypes::IPAddress",
+				"IPAddress::IPv6" => "::Copper::DataTypes::IPAddress"
+			}
+
+			RESEVERED_TYPES = {
+				semver: "Semver",
+				array: "Array",
+				string: "String",
+				range: "Range",
+				ipaddr: "IPAddress"
+			}
+
+			def initialize(value)
+				@value = value
+			end
+
+			def value
+				@value
+			end
+
+			def as(clazz)
+				found_class = ::Copper::DataTypes::DataType.get_class(clazz)
+				return found_class.new(@value).value
+			end
+
+			# returns a DataType based on the given PORO
+			# this is to control the attribute exposure, better error handling, etc
+			def self.factory(poro)
+				poro_class = poro.class.name
+
+				clazz = self.get_class(poro_class)
+				return clazz.new(poro)
+			end
+
+			def self.get_class(class_name)
+				raise RuntimeError, "unknown return value #{class_name}" unless ::Copper::DataTypes::DataType::CLASS_MAP.has_key?(class_name)
+				return Module.const_get(::Copper::DataTypes::DataType::CLASS_MAP[class_name])
+			rescue NameError => exc
+				raise ::Copper::RuntimeError, "invalid return type #{class_name}"
+			end
+		end
+	end
+end

data/lib/copper/data_types/ip_addr.rb

@@ -0,0 +1,82 @@
+require 'ipaddr'
+
+module Copper
+	module DataTypes
+
+		class IPAddress
+			def initialize(value)
+				if value.is_a? ::String
+					@value = ::IPAddress.parse(value)
+				elsif value.is_a?(::IPAddress::IPv4)
+					@value = value
+				elsif value.is_a?(::IPAddress::IPv6)
+					@value = value
+				else
+					raise ::Copper::RuntimeError, "cannot convert #{value} to IPAddress"
+				end
+			rescue ArgumentError => exc
+				raise ::Copper::RuntimeError, exc.message
+			end
+
+			def first
+				@value.first
+			end
+
+			def last
+				@value.last
+			end
+
+			def in(value)
+				raise ::Copper::RuntimeError, "#{value} is not an IP address" unless value.is_a?(::IPAddress)
+				(@value.first.to_i <= value.to_i) && (@value.last.to_i >= value.to_i)
+			end
+
+			def full_address
+				@value.to_string
+			end
+
+			def address
+				@value.address
+			end
+
+			def netmask
+				@value.netmask
+			end
+
+			def octets
+				@value.octets
+			end
+
+			def prefix
+				@value.prefix.to_i
+			end
+
+			def is_network
+				@value.network?
+			end
+
+			def is_loopback
+				@value.loopback?
+			end
+
+			def is_multicast
+				@value.multicast?
+			end
+
+			def is_class_a
+				@value.a?
+			end
+
+			def is_class_b
+				@value.b?
+			end
+
+			def is_class_c
+				@value.c?
+			end
+
+		end
+
+	end
+
+end

data/lib/copper/data_types/range.rb

@@ -0,0 +1,17 @@
+module Copper
+	module DataTypes
+
+		class Range < DataType
+
+			def contains(value)
+				@value.include?(value)
+			end
+
+			def in(value)
+				@value.include?(value)
+			end
+
+		end
+
+	end
+end

data/lib/copper/data_types/semver.rb

@@ -0,0 +1,45 @@
+require 'semantic'
+
+module Copper
+	module DataTypes
+		class Semver < DataType
+
+			def initialize(value)
+				if value.is_a? ::String
+					@value = ::Semantic::Version.new(value)
+				elsif value.is_a? ::Semantic::Version
+					@value = ::Semantic::Version.new(value.to_s)
+				else
+					raise ::Copper::RuntimeError, "cannot convert #{value} to Semver"
+				end
+			rescue ArgumentError => exc
+				raise ::Copper::RuntimeError, exc.message
+			end
+
+			def major
+				@value.major
+			end
+
+			def minor
+				@value.minor
+			end
+
+			def patch
+				@value.patch
+			end
+
+			def build
+				@value.build
+			end
+
+			def pre
+				@value.pre
+			end
+
+			def satisfies(condition)
+				@value.satisfies?(condition)
+			end
+
+		end
+	end
+end

data/lib/copper/data_types/string.rb

@@ -0,0 +1,23 @@
+module Copper
+	module DataTypes
+		class String < DataType
+
+			def count
+				return @value.size
+			end
+
+			def gsub(pattern, replacement)
+				return @value.gsub(pattern, replacement)
+			end
+
+			def at(index)
+				if index >= @value.size
+					raise ParseError, "index #{index} out of bound [0..#{@result.size - 1}]"
+				else
+					return @value[index]
+				end
+			end
+
+		end
+	end
+end

data/lib/copper/error.rb

@@ -0,0 +1,5 @@
+module Copper
+  class CopperError < StandardError; end
+  class ParseError < CopperError; end
+  class RuntimeError < CopperError; end
+end

data/lib/copper/expression.rb

@@ -0,0 +1,8 @@
+module Copper
+	class Expression < CopperNode
+
+		def value(vars = {})
+			return elements[0].value(vars)
+		end
+	end
+end

data/lib/copper/expression_utils.rb

@@ -0,0 +1,13 @@
+module Copper
+	module ExpressionUtils
+
+		def handle_attributes(parent, vars)
+			tail = elements.last
+			return parent if tail.nil? || !tail.is_a?(::Copper::Attributes)
+
+			# run the tail
+			return tail.value(parent, vars)
+		end
+
+	end
+end