fare 0.1.0

data/lib/fare/configuration.rb

@@ -0,0 +1,57 @@
+module Fare
+  class Configuration
+
+    attr_reader :publish_topics, :environments, :subscribers
+    attr_accessor :app_name, :app_version, :default_version
+
+    def initialize
+      @publish_topics = []
+      @environments = {}
+      @subscribers = {}
+      @default_version = "0.0"
+      @backup = false
+    end
+
+    def load_environment(environment)
+      environments.fetch(environment) { Proc.new {} }.call
+    end
+
+    def subscribe_topics
+      subscribers.map { |name, config| config.topics }.flatten
+    end
+
+    def subscriber(name)
+      subscribers[name.to_s] ||= SubscriberConfiguration.new(name.to_s)
+    end
+
+    def backup?
+      @backup
+    end
+
+    def backup!
+      @backup = true
+    end
+
+    class SubscriberConfiguration
+
+      attr_accessor :setup, :always_run, :stacks
+
+      def initialize(name)
+        @name = name
+        @stacks = []
+        @setup = Proc.new {}
+        @always_run = Proc.new {}
+      end
+
+      def topics
+        stacks.map(&:topics).flatten
+      end
+
+      def load_setup
+        @setup.call
+      end
+
+    end
+
+  end
+end

data/lib/fare/configuration_dsl.rb

@@ -0,0 +1,134 @@
+module Fare
+
+  # This class is the context in which the fare config file is loaded.
+  # It provides a DSL that fills a configuration object.
+  class ConfigurationDSL
+
+    InvalidOption = Class.new(ArgumentError)
+    VALID_PART_OF_TOPIC_NAME = /\A\w+\z/
+
+    attr_reader :configuration
+
+    def initialize
+      @configuration = Configuration.new
+    end
+
+    def environment(name, &block)
+      validate! "Environment", name.to_s
+      configuration.environments[name.to_s] = block
+    end
+
+    def app_name(name)
+      validate! "App name", name
+      configuration.app_name = name
+    end
+
+    def default_version(version)
+      configuration.default_version = version
+    end
+
+    def app_version(version)
+      configuration.app_version = version
+    end
+
+    def backup!
+      configuration.backup!
+    end
+
+    def publishes(topic)
+      topic.each do |key, value|
+        case key
+        when :subject then validate! "Subject", value
+        when :action  then validate! "Action", value
+        when :version then true
+        else
+          raise InvalidOption, "Unknown option: #{key}"
+        end
+      end
+      configuration.publish_topics << topic
+    end
+
+    def subscriber(name = configuration.app_name, &block)
+      config = configuration.subscriber(name)
+      SubscriberDSL.new(config).parse(&block)
+    end
+
+    private
+
+    def validate!(name, value)
+      if value !~ VALID_PART_OF_TOPIC_NAME
+        raise InvalidOption, "#{name} can only contain word characters: #{value.inspect}"
+      end
+    end
+
+    class SubscriberDSL
+
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def parse(&block)
+        instance_eval(&block)
+      end
+
+      def stack(&block)
+        stack_dsl = StackDSL.new(configuration)
+        stack_dsl.parse(&block)
+        stack_dsl.verify!
+        stack = stack_dsl.to_stack
+        configuration.stacks << stack
+      end
+
+      def setup(&block)
+        configuration.setup = block
+      end
+
+      def always_run(&block)
+        configuration.always_run = block
+      end
+
+    end
+
+    class StackDSL
+
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        @topics = []
+        @run = :not_specified
+      end
+
+      def verify!
+        if @topics.empty?
+          raise "Stack without topics for stack on line #{@source_location.last} of #{@source_location.first}"
+        end
+        if @run == :not_specified
+          raise "No run list specified for stack on line #{@source_location.last} of #{@source_location.first}"
+        end
+      end
+
+      def to_stack
+        SubscriberStack.new(configuration, @topics, @run)
+      end
+
+      def parse(&block)
+        @source_location = block.source_location
+        instance_eval(&block)
+      end
+
+      def listen_to(topic)
+        @topics << Topic.new(topic)
+      end
+
+      def run(&block)
+        @run = block
+      end
+
+    end
+
+  end
+
+end

data/lib/fare/configuration_when_locked.rb

@@ -0,0 +1,82 @@
+module Fare
+  class ConfigurationWhenLocked
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+      validate_lockfile!
+      @configuration = loaded_configuration.load_configuration
+      @configuration.load_environment(environment)
+    end
+
+    def validate_subscriber!
+      configuration.setup.call
+      configuration.stacks.each(&:to_app)
+    end
+
+    def find_publishable_topic(options)
+      lock_file_contents.fetch("publishes").find { |t|
+        t.fetch("subject") == options.fetch(:subject) && t.fetch("action") == options.fetch(:action)
+      }
+    end
+
+    def app_name
+      configuration.app_name
+    end
+
+    def app_version
+      configuration.app_version || "unknown"
+    end
+
+    def fetch_subscriber(name)
+      configuration.subscribers.fetch(name)
+    end
+
+    def fetch_subscriber_queue(name)
+      Fare.queue_adapter.fetch(environment, name)
+    end
+
+    private
+
+    def subscribers
+      configuration.subscribers
+    end
+
+    attr_reader :configuration
+
+    def validate_lockfile!
+      unless File.exist?(lock_filename)
+        raise LockFileNotFoundError, "Lockfile doesn't exist at #{lock_filename}"
+      end
+      if loaded_configuration.checksum != lock_file_contents.fetch("checksum")
+        raise ChecksumNotMatchingError, "Checksum of lockfile doesn't match. Run `fare update` maybe?"
+      end
+    end
+
+    def lock_filename
+      loaded_configuration.lock_filename
+    end
+
+    def lock_file_contents
+      @lock_file_contents ||= YAML.load(File.open(loaded_configuration.lock_filename, "r:utf-8").read)
+    end
+
+    def loaded_configuration
+      @loaded_configuration ||= LoadConfigurationFile.new(filename: filename, environment: environment)
+    end
+
+    def environment
+      options.fetch(:environment) { find_environment }
+    end
+
+    def filename
+      options.fetch(:filename) { Fare.default_config_file }
+    end
+
+    def find_environment
+      Fare.default_environment || raise(NoEnvironmentFoundError, "No environment specified!")
+    end
+
+  end
+end

data/lib/fare/event.rb

@@ -0,0 +1,26 @@
+module Fare
+  class Event
+    include Virtus.model
+
+    attribute :id
+    attribute :subject
+    attribute :action
+    attribute :payload
+    attribute :source
+    attribute :version
+    attribute :sent_at, DateTime
+
+    def serialize
+      Base64.urlsafe_encode64(attributes.to_json)
+    end
+
+    def self.deserialize(message)
+      new JSON.parse(Base64.urlsafe_decode64(message))
+    end
+
+    def to_json(*)
+      attributes.to_json
+    end
+
+  end
+end

data/lib/fare/generate_lock_file.rb

@@ -0,0 +1,131 @@
+module Fare
+  class GenerateLockFile
+    extend Forwardable
+
+    def_delegators :@configuration, :environment, :lock_filename, :checksum
+
+    attr_reader :topics, :force, :queues
+
+    def initialize(options = {})
+      @force = options.delete(:force) { false }
+      @configuration = LoadConfigurationFile.new(options)
+      @topics = {}
+      @queues = {}
+    end
+
+    def configuration
+      @configuration.configuration
+    end
+
+    def call
+      return if skip_generating?
+
+      configuration.load_environment(environment)
+
+      find_publishing_topics
+      find_subscriber_queues
+
+      File.open(lock_filename, "w:utf-8") do |f|
+        f.write(data.to_yaml)
+      end
+    end
+
+    private
+
+    def backup?
+      configuration.backup?
+    end
+
+    def skip_generating?
+      !force && checksum_matches?
+    end
+
+    def checksum_matches?
+      File.exist?(lock_filename) && YAML.load(File.open(lock_filename, "r:utf-8").read).fetch("checksum") == checksum
+    end
+
+    def find_publishing_topics
+      configuration.publish_topics.each do |topic_info|
+        topic = topic_for(topic_info)
+        subscribe topic, backup_queue if backup?
+      end
+    end
+
+    def find_subscriber_queues
+      configuration.subscribers.each do |subscriber_name, subscriber|
+        subscriber.topics.each do |topic_info|
+          topic = topic_for(topic_info)
+          subscribe topic, backup_queue if backup?
+          subscribe topic, queue_for(subscriber_name)
+        end
+      end
+    end
+
+    def data
+      data = {
+        "publishes"    => configuration.publish_topics.map   { |topic_info| serialize_topic(topic_info) },
+        "subscribes"   => configuration.subscribe_topics.map { |topic_info| serialize_topic(topic_info) },
+        "queues"       => Hash[ queues.map { |name, queue| [ name, queue.url ] }],
+        "checksum"     => checksum,
+      }
+      data["backup_queue"] = backup_queue.url if backup?
+      data
+    end
+
+    def subscribe(topic, queue)
+      subscription = topic.subscribe(queue.arn)
+      subscription.raw_message_delivery = true
+      account_id = topic.owner
+      policy = {
+        "Version" => "2012-10-17",
+        "Id"      => "Fare_Policy",
+        "Statement" => [
+          {
+            "Sid"       => "1",
+            "Effect"    => "Allow",
+            "Principal" => { "AWS" => "*" },
+            "Action"    => "SQS:SendMessage",
+            "Resource"  => queue.arn,
+            "Condition" => {
+              "ArnLike" => {
+                "aws:SourceArn" => "arn:aws:sns:*:#{account_id}:*"
+              }
+            }
+          },
+        ]
+      }
+      queue.policy = policy
+    end
+
+    def serialize_topic(topic_info)
+      {
+        "subject" => topic_info.fetch(:subject),
+        "action"  => topic_info.fetch(:action),
+        "version" => topic_info.fetch(:version) { configuration.default_version },
+        "arn"     => topic_for(topic_info).arn,
+      }
+    end
+
+    def backup_queue
+      if backup?
+        @backup_queue ||= queue_for("backup")
+      else
+        fail "NO BACKUP FOR YOU!"
+      end
+    end
+
+    def app_name
+      configuration.app_name
+    end
+
+    def topic_for(options)
+      topic_key = [options[:subject], options[:action] ]
+      topics[topic_key] ||= Fare.topic_adapter.create("#{environment}-#{options[:subject]}-#{options[:action]}").tap { |topic| puts "Created topic #{topic.arn}" }
+    end
+
+    def queue_for(name)
+      queues[name] ||= Fare.queue_adapter.fetch(environment, name)
+    end
+
+  end
+end

data/lib/fare/load_configuration_file.rb

@@ -0,0 +1,45 @@
+module Fare
+  class LoadConfigurationFile
+
+    attr_reader :filename, :environment
+
+    def initialize(options)
+      @filename = options.fetch(:filename) { Fare.default_config_file }
+      @environment = options.fetch(:environment) { Fare.default_environment }
+      verify_file!
+    end
+
+    def verify_file!
+      unless exists?
+        raise ConfigurationNotFoundError, "Configuration file doesn't exist at #{filename}"
+      end
+    end
+
+    def configuration
+      @configuration ||= load_configuration
+    end
+
+    def load_configuration
+      dsl = ConfigurationDSL.new
+      dsl.instance_eval(code, filename)
+      dsl.configuration
+    end
+
+    def code
+      @code ||= File.open(filename.to_s, "r:utf-8").read
+    end
+
+    def lock_filename
+      File.expand_path("../fare.#{environment}.lock", filename)
+    end
+
+    def checksum
+      Digest::MD5.hexdigest(code)
+    end
+
+    def exists?
+      File.exist?(filename)
+    end
+
+  end
+end