dkron-rb 0.9.2

data/lib/dkron-rb/cron.rb

@@ -0,0 +1,152 @@
+require 'chronic'
+
+module Dkron
+  module Output
+    class Cron
+      KEYWORDS = [:yearly, :annually, :monthly, :weekly, :daily, :midnight, :hourly, :minutely]
+      REGEX = /^(@(#{KEYWORDS.join '|'})|((\*?[\d\/,\-]*)\s*){5})$/
+
+      attr_accessor :time, :task
+
+      def initialize(time = nil, task = nil, at = nil)
+        @at_given = at
+        @time = time
+        @task = task
+        @at   = at.is_a?(String) ? (Chronic.parse(at) || 0) : (at || 0)
+      end
+
+      def self.enumerate(item, detect_cron = true)
+        if item and item.is_a?(String)
+          items =
+            if detect_cron && item =~ REGEX
+              [item]
+            else
+              item.split(',')
+            end
+        else
+          items = item
+          items = [items] unless items and items.respond_to?(:each)
+        end
+        items
+      end
+
+      def self.output(times, job)
+        enumerate(times).each do |time|
+          enumerate(job.at, false).each do |at|
+            yield new(time, job.output, at).output
+          end
+        end
+      end
+
+      def output
+        [time_in_cron_syntax, task].compact.join(' ').strip
+      end
+
+      def time_in_cron_syntax
+        @time = @time.to_i if @time.is_a?(Numeric) # Compatibility with `1.day` format using ruby 2.3 and activesupport
+        case @time
+          when REGEX  then @time # raw cron syntax given
+          when Symbol then parse_symbol
+          when String then parse_as_string
+          else parse_time
+        end
+      end
+
+    protected
+      def day_given?
+        months = %w(jan feb mar apr may jun jul aug sep oct nov dec)
+        @at_given.is_a?(String) && months.any? { |m| @at_given.downcase.index(m) }
+      end
+
+      def parse_symbol
+        shortcut = case @time
+          when :year     then Dkron.seconds(12, :months)
+          when :day      then Dkron.seconds(1, :day)
+          when :month    then Dkron.seconds(1, :month)
+          when :week     then Dkron.seconds(1, :week)
+          when :hour     then Dkron.seconds(1, :hour)
+        end
+
+        if shortcut.is_a?(Numeric)
+          @time = shortcut
+          parse_time
+        elsif shortcut
+          if @at.is_a?(Time) || (@at.is_a?(Numeric) && @at > 0)
+            raise ArgumentError, "You cannot specify an ':at' when using the shortcuts for times."
+          else
+            return shortcut
+          end
+        else
+          parse_as_string
+        end
+      end
+
+      def parse_time
+        timing = Array.new(6, '*')
+        case @time
+          when Dkron.seconds(0, :seconds)...Dkron.seconds(1, :minute)
+            raise ArgumentError, "Time must be in minutes or higher"
+          when Dkron.seconds(1, :minute)...Dkron.seconds(1, :hour)
+            minute_frequency = @time / 60
+            timing[0] = comma_separated_timing(minute_frequency, 59, @at || 0)
+          when Dkron.seconds(1, :hour)...Dkron.seconds(1, :day)
+            hour_frequency = (@time / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min : @at
+            timing[1] = comma_separated_timing(hour_frequency, 23)
+          when Dkron.seconds(1, :day)...Dkron.seconds(1, :month)
+            day_frequency = (@time / 24 / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min  : 0
+            timing[1] = @at.is_a?(Time) ? @at.hour : @at
+            timing[2] = comma_separated_timing(day_frequency, 31, 1)
+          when Dkron.seconds(1, :month)..Dkron.seconds(12, :months)
+            month_frequency = (@time / 30  / 24 / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min  : 0
+            timing[1] = @at.is_a?(Time) ? @at.hour : 0
+            timing[2] = if @at.is_a?(Time)
+              day_given? ? @at.day : 1
+            else
+              @at.zero? ? 1 : @at
+            end
+            timing[3] = comma_separated_timing(month_frequency, 12, 1)
+          else
+            return parse_as_string
+        end
+        timing.join(' ')
+      end
+
+      def parse_as_string
+        return unless @time
+        string = @time.to_s
+
+        timing = Array.new(4, '*')
+        timing[0] = @at.is_a?(Time) ? @at.min  : 0
+        timing[1] = @at.is_a?(Time) ? @at.hour : 0
+
+        return (timing << '1-5') * " " if string.downcase.index('weekday')
+        return (timing << '6,0') * " " if string.downcase.index('weekend')
+
+        %w(sun mon tue wed thu fri sat).each_with_index do |day, i|
+          return (timing << i) * " " if string.downcase.index(day)
+        end
+
+        raise ArgumentError, "Couldn't parse: #{@time}"
+      end
+
+      def comma_separated_timing(frequency, max, start = 0)
+        return start     if frequency.nil? || frequency == "" || frequency.zero?
+        return '*'       if frequency == 1
+        return frequency if frequency > (max * 0.5).ceil
+
+        original_start = start
+
+        start += frequency unless (max + 1).modulo(frequency).zero? || start > 0
+        output = (start..max).step(frequency).to_a
+
+        max_occurances = (max.to_f  / (frequency.to_f)).round
+        max_occurances += 1 if original_start.zero?
+
+        output[0, max_occurances].join(',')
+      end
+    end
+  end
+end

data/lib/dkron-rb/models/agent.rb

@@ -0,0 +1,152 @@
+=begin
+Dkron REST API
+
+You can communicate with Dkron using a RESTful JSON API over HTTP. Dkron nodes usually listen on port `8080` for API requests. All examples in this section assume that you've found a running leader at `localhost:8080`.\n\nDkron implements a RESTful JSON API over HTTP to communicate with software clients. Dkron listens in port `8080` by default. All examples in this section assume that you're using the default port.\n\nDefault API responses are unformatted JSON add the `pretty=true` param to format the response.\n
+
+OpenAPI spec version: 0.7.2
+
+Generated by: https://github.com/swagger-api/swagger-codegen.git
+
+
+=end
+
+require 'date'
+
+module Dkron
+  # Node basic details
+  class Agent
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+    end
+
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [].hash
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = Dkron.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/dkron-rb/models/execution.rb

@@ -0,0 +1,250 @@
+=begin
+#Dkron REST API
+
+#You can communicate with Dkron using a RESTful JSON API over HTTP. Dkron nodes usually listen on port `8080` for API requests. All examples in this section assume that you've found a running leader at `localhost:8080`.  Dkron implements a RESTful JSON API over HTTP to communicate with software clients. Dkron listens in port `8080` by default. All examples in this section assume that you're using the default port.  Default API responses are unformatted JSON add the `pretty=true` param to format the response. 
+
+OpenAPI spec version: 0.9.2
+
+Generated by: https://github.com/swagger-api/swagger-codegen.git
+
+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.
+
+=end
+
+require 'date'
+
+module Dkron
+  # An execution represents a timed job run.
+  class Execution
+    # job name
+    attr_accessor :job_name
+
+    # start time of the execution
+    attr_accessor :started_at
+
+    # when the execution finished running
+    attr_accessor :finished_at
+
+    # the execution run successfuly
+    attr_accessor :success
+
+    # partial output of the command execution
+    attr_accessor :output
+
+    # name of the node that executed the command
+    attr_accessor :node_name
+
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'job_name' => :'job_name',
+        :'started_at' => :'started_at',
+        :'finished_at' => :'finished_at',
+        :'success' => :'success',
+        :'output' => :'output',
+        :'node_name' => :'node_name'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        :'job_name' => :'String',
+        :'started_at' => :'DateTime',
+        :'finished_at' => :'DateTime',
+        :'success' => :'BOOLEAN',
+        :'output' => :'String',
+        :'node_name' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+
+      if attributes.has_key?(:'job_name')
+        self.job_name = attributes[:'job_name']
+      end
+
+      if attributes.has_key?(:'started_at')
+        self.started_at = attributes[:'started_at']
+      end
+
+      if attributes.has_key?(:'finished_at')
+        self.finished_at = attributes[:'finished_at']
+      end
+
+      if attributes.has_key?(:'success')
+        self.success = attributes[:'success']
+      end
+
+      if attributes.has_key?(:'output')
+        self.output = attributes[:'output']
+      end
+
+      if attributes.has_key?(:'node_name')
+        self.node_name = attributes[:'node_name']
+      end
+
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properies with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      return invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          job_name == o.job_name &&
+          started_at == o.started_at &&
+          finished_at == o.finished_at &&
+          success == o.success &&
+          output == o.output &&
+          node_name == o.node_name
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [job_name, started_at, finished_at, success, output, node_name].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = Dkron.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end