content_server 1.1.0 → 1.2.0

data/lib/file_utils/file_utils.rb

@@ -0,0 +1,260 @@
+# Author:
+# originator: Kolman Vornovizky (kolmanv@gmail.com)
+# update: Alexey Nemytov (alexeyn66@gmail.com) 31/07/2012
+# This file is the consist utility functionality for BBFS
+# Such as automatic file generation, symlink, etc.
+# Run from bbfs> ruby -Ilib bin/file_utils --command=generate_files --log_write_to_console=true --log_debug_level=3
+
+require 'content_data'
+require 'file_indexing'
+require 'file_utils'
+require 'file_utils/file_generator/file_generator'
+
+require 'log'
+require 'params'
+
+module FileUtils
+  Params.string 'command', nil ,'path'
+  Params.string 'ref_cd', nil ,'reference path'
+  Params.string 'base_cd', nil ,'base path'
+  Params.string 'dest', nil ,'destination path'
+  Params.string 'dest_server', nil ,'server name'
+  Params.string 'patterns', nil ,'patterns path'
+  Params.string 'cd', nil ,'path'
+  Params.string 'cd_a', nil ,'a path'
+  Params.string 'cd_b', nil ,'b path'
+  Params.string 'cd_out', nil ,'output path'
+  Params.string 'cd_in', nil ,'input path'
+  Params.string 'exist_cd', nil, 'exist_path'
+  #Params.string 'config_file', 'path' ,'configuration file path'
+  class FileUtils
+    def FileUtils.run
+      if Params['command'] == 'mksymlink'
+        if Params['ref_cd'].nil?
+          Log.error ("--ref_cd is not set")
+          return
+        end
+        ref_cd = ContentData.new()
+        ref_cd.from_file(Params['ref_cd'])
+        if ref_cd.nil?
+          Log.error ("Error loading content data ref_cd=%s" % Params['ref_cd'])
+          return
+        end
+
+        if Params['base_cd'].nil?
+          Log.error ("--base_cd is not set")
+          return
+        end
+        base_cd = ContentData.new()
+        base_cd.from_file(Params['base_cd'])
+        if base_cd.nil?
+          Log.error ("Error loading content data base_cd=%s" % Params['base_cd'])
+          return
+        end
+
+        if Params['dest'].nil?
+          Log.error ("--dest is not set")
+          return
+        end
+
+        not_found = nil
+        begin
+          not_found = FileUtil.mksymlink(ref_cd, base_cd, Params['dest'])
+        rescue NotImplementedError
+          Log.error ("symlinks are unimplemented on this machine")
+          return nil
+        end
+        return not_found
+      elsif (Params['command'] == "merge" or
+          Params['command'] == "intersect" or
+          Params['command'] == "minus")
+
+        if Params['cd_a'].nil?
+          Log.error ("--cd_a is not set")
+          return
+        end
+        cd_a = ContentData.new()
+        cd_a.from_file(Params['cd_a'])
+        if cd_a.nil?
+          Log.error ("Error loading content data cd_a=%s" % Params['cd_a'])
+          return
+        end
+
+        if Params['cd_b'].nil?
+          Log.error ("--cd_b is not set")
+          return
+        end
+        cd_b = ContentData.new()
+        cd_b.from_file(Params['cd_b'])
+        if cd_b.nil?
+          Log.error ("Error loading content data cd_b=%s" % Params['cd_b'])
+          return
+        end
+
+        if Params['cd_b'].nil?
+          Log.error ("--dest is not set")
+          return
+        end
+
+        output = FileUtil.contet_data_command(Params['command'], cd_a, cd_b, Params['dest'])
+
+      elsif Params['command'] == 'unify_time'
+        if  Params['cd'].nil?
+          Log.error ("--cd is not set")
+          return
+        end
+        cd = ContentData.new()
+        cd.from_file(Params['cd'])
+        if cd.nil?
+          Log.error ("Error loading content data cd=%s" % Params['cd'])
+          return
+        end
+        output = unify_time(cd)
+        # indexer
+      elsif Params['command'] == 'indexer'
+        if Params['patterns'].nil?
+          Log.error ("--patterns is not set")
+          return
+        end
+
+        patterns = FileIndexing::IndexerPatterns.new
+        Params['patterns'].split(':').each { |pattern|
+          Log.debug1 "Pattern: #{pattern}"
+          patterns.add_pattern File.expand_path(pattern)
+        }
+
+        unless patterns.size > 0
+          Log.error ("Error loading patterns=%s (empty file)" % Params['patterns'])
+          return
+        end
+
+        exist_cd = nil
+        if not Params['exist_cd'].nil?
+          exist_cd = ContentData::ContentData.new()
+          exist_cd.from_file(Params['exist_cd'])
+          if exist_cd.nil?
+            Log.error ("Error loading content data exist_cd=%s" % Params['exist_cd'])
+            return
+          end
+        end
+        indexer = FileIndexing::IndexAgent.new
+        indexer.index(patterns, exist_cd)
+        Log.debug1 indexer.indexed_content.to_s
+        # crawler
+      elsif Params['command'] == 'crawler'
+        if Params['conf_file'].nil?
+          Log.error ("--conf_file is not set")
+          return
+        end
+        if not File.exists?(Params['conf_file'])
+          Log.error ("config file doesn't exist conf_file=%s" % Params['conf_file'])
+          return
+        end
+
+        if Params['cd_out'].nil?
+          time = Tme.now.utc
+          Params['cd_out'] = "crawler.out.#{time.strftime('%Y/%m/%d_%H-%M-%S')}"
+        end
+        unless (Params['cd_in'].nil?)
+          if not File.exists?(Params['conf_file'])
+            Log.error ("input data file doesn't exist cd_in=%s" % Params['cd_in'])
+            return
+          end
+        end
+
+        conf = Configuration.new(Params['conf_file'])
+        threads = Array.new
+        conf.server_conf_vec.each do |server|
+          threads.push(Thread.new { Crawler.new(server, Params['cd_out'], Params['cd_in']) })
+        end
+
+        threads.each { |a| a.join }
+        join_servers_results(conf.server_conf_vec, Params['cd_out'])
+      elsif Params['command'] == 'generate_files'
+        fg = FileGenerator::FileGenerator.new()
+        fg.run()
+      end
+    end
+
+    def self.contet_data_command(command, cd_a, cd_b, dest_path)
+      dest = nil
+      if command == "merge"
+        dest = ContentData.merge(cd_a, cd_b)
+      elsif command == "intersect"
+        dest = ContentData.intersect(cd_a, cd_b)
+      elsif command == "minus"
+        dest = ContentData.remove(cd_b, cd_a)
+      end
+      if dest
+        dest.to_file(dest_path)
+      end
+    end
+
+    # Unify modification/first_appearance time according to input DB
+    # Input: ContentData
+    # Output: ContentData with unified times
+    #         Files modification time attribute physically updated
+    # Assumption: Files in the input db are from this device.
+    #             There is no check what device they are belong - only the check of server name.
+    #             It is a user responsibility (meanwhile) to provide a correct input
+    #             If file has a modification time attribute that doesn't present in the input db,
+      #             then the assumption is that this file wasnt indexized and it will not be treated
+      #             (e.i. we do nothing with it)
+      def self.unify_time(content_data)
+        orig_content_data = ContentData::ContentData.new(content_data)
+        content_data.unify_time
+        content_data.each_instance { |checksum, size, content_mod_time, unified_inst_mod_time, server, path|
+          location = [server, path]
+          orig_inst_mod_time = orig_content_data.get_instance_mod_time(checksum, location)
+          file_mtime, file_size = File.open(path) { |f| [f.mtime, f.size] }
+          Log.debug1 "file:#{path} file_mtime:#{file_mtime}."
+          Log.debug1 "update mtime:#{unified_inst_mod_time}"
+          Log.debug1 "original instance mtime:#{orig_inst_mod_time}."
+          Log.debug1 "unify instance mtime:#{unified_inst_mod_time}."
+          Log.debug1 "Comparison: Real file = unified? #{file_mtime.to_i == unified_inst_mod_time}"
+          if (file_mtime.to_i == orig_inst_mod_time) \
+                and file_size == size \
+                and (file_mtime.to_i != unified_inst_mod_time)
+            Log.debug1 ("Comparison results: File actual time is same as instance time before unification. Need to modify file time")
+            File.utime(File.atime(path), unified_inst_mod_time, path)
+            file_mtime = File.open(path) { |f| f.mtime }
+            Log.debug1 "new file mtime:#{file_mtime}."
+            Log.debug1 "new file mtime in seconds:#{file_mtime.to_i}."
+          end
+        }
+        content_data
+      end
+
+      # Creates directory structure and symlinks with ref_cd structure to the base_cd files and dest as a root dir
+      # Parameters: ref_cd [ContentData]
+      #             base_cd [ContentData]
+      #             dest [String]
+      # Output: ContentData object consists of contents/instances from ref_cd that have no target in base_cd
+
+      def self.mksymlink(ref_cd, base_cd, dest)
+        # symlinks are not implemented in Windows
+        raise NotImplementedError.new if (RUBY_PLATFORM =~ /mingw/ or RUBY_PLATFORM =~ /ms/ or RUBY_PLATFORM =~ /win/)
+
+        not_found = {}
+        not_found_cd = ContentData::ContentData.new
+        warnings = []
+        dest.chop! if (dest.end_with?("/") or dest.end_with?("\\"))
+
+        ref_cd.each_instance { |checksum, size, content_mod_time, inst_mod_time, server, path|
+          if base_cd.content_exists(checksum)
+            symlink_path = dest + path
+            ::FileUtils.mkdir_p(File.dirname(symlink_path)) unless (Dir.exists?(File.dirname(symlink_path)))
+            File.symlink(path, symlink_path)
+          else
+            # add instance to not_found cd
+            not_found_cd.add_instance(checksum, size, server, path, inst_mod_time)
+            warnings << "Warning: base content does not contains:'%s'" % checksum
+          end
+        }
+        Log.warning (warnings)
+        not_found_cd
+      end
+  end
+
+end
+

data/lib/file_utils/version.rb

@@ -0,0 +1,3 @@
+module FileUtils
+  VERSION = "1.1.0"
+end

data/lib/file_utils.rb

@@ -0,0 +1,4 @@
+require 'file_utils/file_utils'
+
+module FileUtils
+end

data/lib/log/version.rb

@@ -0,0 +1,3 @@
+module Log
+  VERSION = "1.1.0"
+end

data/lib/log.rb

@@ -0,0 +1,188 @@
+# Author: Yaron Dror (yaron.dror.bb@gmail.com)
+# Description: The file contains the code which implements the 'Log' module
+# Run: Add to 'require' list. Execute Log.init
+
+#require 'email'
+require 'log4r'
+require 'log4r/outputter/emailoutputter'
+
+require 'params'
+
+# Module: Log.
+# Abstruct: The Log is used to log info\warning\error\debug messages
+#           This module is actually a wrapper to log4r gem and serves
+#           as a central code to use the log utility.
+module Log
+
+  #Auxiliary method to retrieve the executable name
+  def Log.executable_name
+    /([a-zA-Z0-9\-_\.]+):\d+/ =~ caller[caller.size-1]
+    return $1
+  end
+
+  # Global params
+  Params.integer('log_debug_level', 0 , \
+      'Verbosity of logging. 0 will log only INFO messages. Other value, will log all DEBUG messages as well.')
+  Params.boolean('log_flush_each_message', true, \
+      'If true then File and Console outputters will be flushed for each message.')
+  Params.boolean('log_write_to_file', true , \
+      'If true then the logger will write the messages to a file.')
+  Params.path('log_file_name', "~/.bbfs/log/#{Log.executable_name}.log4r" , \
+      'log file name: ~/.bbfs/log/<executable_name>.log')
+  Params.integer('log_rotation_size',1000000 , \
+      'max log file size. when reaching this size, a new file is created for rest of log')
+  Params.boolean('log_write_to_console', false , \
+      'If true then the logger will write the messages to the console.')
+  Params.boolean('log_write_to_email', false , \
+      'If true then the logger will write the error and fatal messages to email.')
+  Params.string('from_email', 'bbfsdev@gmail.com', 'From gmail address for update.')
+  Params.string('from_email_password', '', 'From gmail password.')
+  Params.string('to_email', 'bbfsdev@gmail.com', 'Destination email for updates.')
+
+  #Should be called from executable right after params handling.
+  # Init Log level and set output to file,stdout and email according to configuration params.
+  def Log.init
+    @log4r = Log4r::Logger.new 'BBFS log'
+    @log4r.trace = true
+
+    #levels setup
+    log4r_level = Log4r::DEBUG
+    log4r_level = Log4r::INFO if 0 == Params['log_debug_level']
+
+    #formatters
+    formatter = Log4r::PatternFormatter.new(:pattern => "[%l] [%d] [%m]")
+
+    #stdout setup
+    if Params['log_write_to_console']
+      stdout_outputter = Log4r::Outputter.stdout
+      stdout_outputter.formatter = formatter
+      stdout_outputter.level = log4r_level
+      @log4r.outputters << stdout_outputter
+    end
+
+    #file setup
+    if Params['log_write_to_file']
+      if File.exist?(Params['log_file_name'])
+        File.delete(Params['log_file_name'])
+      else
+        dir_name = File.dirname(Params['log_file_name'])
+        FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
+      end
+      file_config = {
+          "filename" => Params['log_file_name'],
+          "maxsize" => Params['log_rotation_size'],
+          "trunc" => true
+      }
+      file_outputter = Log4r::RollingFileOutputter.new("file_log", file_config)
+      file_outputter.level = log4r_level
+      file_outputter.formatter = formatter
+      @log4r.outputters << file_outputter
+    end
+
+    #email setup
+    if Params['log_write_to_email']
+      email_outputter = Log4r::EmailOutputter.new('email_log',
+                                                  :server => 'smtp.gmail.com',
+                                                  :port => 587,
+                                                  :subject => "Error happened at server:'#{Params['local_server_name']}' run by #{ENV['USER']}. Service_name is #{Params['service_name']}",
+                                                  :acct => Params['from_email'],
+                                                  :from => Params['from_email'],
+                                                  :passwd => Params['from_email_password'],
+                                                  :to => Params['to_email'],
+                                                  :immediate_at => 'FATAL,ERROR',
+                                                  :authtype => :plain,
+                                                  :tls => true,
+                                                  :formatfirst => true,
+                                                  :buffsize => 9999,
+      )
+      email_outputter.level = Log4r::ERROR
+      email_outputter.formatter = formatter
+      @log4r.outputters << email_outputter
+    end
+
+    # Write init message and user parameters
+    @log4r.info('BBFS Log initialized.') # log first data
+
+    # print params to console
+    if Params['print_params_to_stdout']
+      Params.get_init_info_messages().each { |msg|
+        puts(msg)
+      }
+    else
+      Log.info("Not printing executable parameters to console since param:'print_params_to_stdout' is false")
+    end
+    #print params to log info and warning
+    Params.get_init_info_messages().each { |msg|
+      Log.info(msg)
+    }
+    Params.get_init_warning_messages().each { |msg|
+      Log.warning(msg)
+    }
+  end
+
+  # Auxiliary method to add the calling method to the message
+  def Log.msg_with_caller(msg)
+    /([a-zA-Z0-9\-_\.]+:\d+)/ =~ caller[1]
+    $1 + ':' + msg
+  end
+
+  # Log warning massages
+  def Log.warning(msg)
+    Log.init if @log4r.nil?
+    @log4r.warn(msg_with_caller(msg))
+    Log.flush if Params['log_flush_each_message']
+  end
+
+  # Log error massages
+  def Log.error(msg)
+    Log.init if @log4r.nil?
+    @log4r.error(msg_with_caller(msg))
+    Log.flush if Params['log_flush_each_message']
+  end
+
+  # Log info massages
+  def Log.info(msg)
+    Log.init if @log4r.nil?
+    @log4r.info(msg_with_caller(msg))
+    Log.flush if Params['log_flush_each_message']
+  end
+
+  # Log debug level 1 massages
+  def Log.debug1(msg)
+    if Params['log_debug_level'] >= 1
+      Log.init if @log4r.nil?
+      @log4r.debug(msg_with_caller(msg))
+      Log.flush if Params['log_flush_each_message']
+    end
+  end
+
+  # Log debug level 2 massages
+  def Log.debug2(msg)
+    if Params['log_debug_level'] >= 2
+      Log.init if @log4r.nil?
+      @log4r.debug(msg_with_caller(msg))
+      Log.flush if Params['log_flush_each_message']
+    end
+  end
+
+  # Log debug level 3 massages
+  def Log.debug3(msg)
+    if Params['log_debug_level'] >= 3
+      Log.init if @log4r.nil?
+      @log4r.debug(msg_with_caller(msg))
+      Log.flush if Params['log_flush_each_message']
+    end
+  end
+
+  # Flush email log
+  def Log.flush()
+    return if @log4r.nil?
+    @log4r.outputters.each { |o|
+      # Not flushing to email since this will cause empty emails to be sent
+      # Email is already configured to immediately send mail on ERROR|FATAL messages.
+      o.flush unless o.is_a?(Log4r::EmailOutputter)
+    }
+  end
+
+  private_class_method(:msg_with_caller)
+end

data/lib/networking/tcp.rb

@@ -0,0 +1,213 @@
+require 'log'
+require 'socket'
+
+module Networking
+
+  Params.integer('client_retry_delay', 60, 'Number of seconds before trying to reconnect.')
+
+  # TODO(kolman): To get robustness, just use try catch + return 0 bytes on write +
+  # return false on status on read.
+  def Networking.write_to_stream(stream, obj)
+    Log.debug3('Writing to stream.')
+    marshal_data = Marshal.dump(obj)
+    Log.debug2("Writing data size: #{marshal_data.length}")
+    data_size = [marshal_data.length].pack("l")
+    if data_size.nil? || marshal_data.nil?
+      Log.debug2 'Send data size is nil!'
+    end
+    begin
+      bytes_written = stream.write data_size
+      bytes_written += stream.write marshal_data
+      return bytes_written
+    rescue Exception => e
+      Log.warning("Could not write tcp/ip stream, #{e.to_s}")
+      begin
+        stream.close()
+      rescue IOError => e
+        Log.warning("Could not close stream, #{e.to_s}.")
+      end
+      return 0
+    end
+  end
+
+  # Returns pair [status(true/false), obj]
+  def Networking.read_from_stream(stream)
+    Log.debug3('Read from stream.')
+    begin
+      return [false, nil] unless size_of_data = stream.read(4)
+      size_of_data = size_of_data.unpack("l")[0]
+      Log.debug2("Reading data size:#{size_of_data}")
+      data = stream.read(size_of_data)
+    rescue Exception => e
+      Log.warning("Could not read tcp/ip stream, #{e.to_s}.")
+      begin
+        stream.close()
+      rescue IOError => e
+        Log.warning("Could not close stream, #{e.to_s}.")
+      end
+      return [false, nil]
+    end
+
+    unmarshalled_data = Marshal.load(data)
+    Log.debug2('Read good.')
+    return [true, unmarshalled_data]
+  end
+
+  # Limit on number of concurrent connections?
+  # The TCP server is not responsible for reconnection.
+  class TCPServer
+    attr_reader :tcp_thread
+
+    def initialize(port, obj_clb, new_clb=nil, closed_clb=nil, max_parallel=1)
+      @port = port
+      @obj_clb = obj_clb
+      @new_clb = new_clb
+      @closed_clb = closed_clb
+      # Max parallel connections is not implemented yet.
+      @max_parallel = max_parallel
+      @sockets = {}
+      @tcp_thread = run_server
+      @tcp_thread.abort_on_exception = true
+    end
+
+    def send_obj(obj, addr_info=nil)
+      Log.debug3("send_obj with addr_info:#{addr_info}")
+      unless addr_info.nil?
+        if @sockets.key?(addr_info)
+          Networking.write_to_stream(@sockets[addr_info], obj)
+        else
+          Log.warning("Could not find client socket: #{addr_info}")
+          return 0
+        end
+      else
+        out = {}
+        @sockets.each { |key, sock| out[key] = Networking.write_to_stream(sock, obj) }
+        return out
+      end
+    end
+
+    private
+    # Creates new thread/pool
+    def run_server
+      Log.debug3('run_server')
+      return Thread.new do
+        loop {
+          begin
+            Socket.tcp_server_loop(@port) do |sock, addr_info|
+              Log.debug2("----- #{@port} -----")
+              Log.debug2("tcp_server_loop... #{sock} #{addr_info.inspect}")
+              @sockets[addr_info] = sock
+              @new_clb.call(addr_info) if @new_clb != nil
+              loop do
+                # Blocking read.
+                Log.debug2('read_from_stream')
+                stream_ok, obj = Networking.read_from_stream(sock)
+                Log.debug2("Server returned from read: #{stream_ok}")
+                @obj_clb.call(addr_info, obj) if @obj_clb != nil && stream_ok
+                break if !stream_ok
+              end
+              Log.warning("Connection broken, #{addr_info.inspect}")
+              begin
+                @sockets[addr_info].close() unless @sockets[addr_info].nil?
+              rescue IOError => e
+                Log.warning("Could not close socket, #{e.to_s}.")
+              end
+              @sockets.delete(addr_info)
+              @closed_clb.call(addr_info) if @closed_clb != nil
+            end
+            # !!! note this break is needed for tests only !!!! server loop should never end.
+            # and if it ends, it will fail, and rescue will work.
+            break
+          rescue IOError => e
+            Log.warning("Connection broken during tcp_server_loop. Restarting server loop " \
+                       "port:#{port}.")
+          end
+        }
+      end
+    end
+  end  # TCPServer
+
+  class TCPClient
+    attr_reader :tcp_thread
+
+    def initialize(host, port, obj_clb=nil, reconnected_clb=nil)
+      @host = host
+      @port = port
+      @tcp_socket = nil
+      @obj_clb = obj_clb
+      @reconnected_clb = reconnected_clb
+      Log.debug3("Start TCPClient initialize  with @obj_clb: #{@obj_clb}")
+      if @obj_clb != nil
+        @tcp_thread = start_reading
+        @tcp_thread.abort_on_exception = true
+      end
+      # Variable to signal when remote server is ready.
+      @remote_server_available = ConditionVariable.new
+      @remote_server_available_mutex = Mutex.new
+      open_socket unless socket_good?
+      Log.debug3("End TCPClient initialize.")
+    end
+
+    def send_obj(obj)
+      Log.debug1('send_obj')
+      open_socket unless socket_good?
+      Log.debug1('after open')
+      if !socket_good?
+        Log.warning('Socket not opened for writing, skipping send.')
+        return false
+      end
+      Log.debug2("writing... socket port: #{@tcp_socket.peeraddr}")
+      bytes_written = Networking.write_to_stream(@tcp_socket, obj)
+      return bytes_written
+    end
+
+    # This function may be executed only from one thread!!! or in synchronized manner.
+    # private
+    def open_socket
+      Log.debug1("Connecting to content server #{@host}:#{@port}.")
+      begin
+        @tcp_socket = TCPSocket.new(@host, @port)
+      rescue Errno::ECONNREFUSED
+        Log.warning('Connection refused')
+      end
+      Log.debug3("Reconnect clb: '#{@reconnected_clb.nil? ? 'nil' : @reconnected_clb}'")
+      if socket_good?
+        @remote_server_available_mutex.synchronize {
+          @remote_server_available.signal
+        }
+        @reconnected_clb.call if @reconnected_clb != nil && socket_good?
+      end
+    end
+
+    private
+    def socket_good?
+      Log.debug3("socket_good? #{@tcp_socket != nil && !@tcp_socket.closed?}")
+      return @tcp_socket != nil && !@tcp_socket.closed?
+    end
+
+    private
+    def start_reading
+      return Thread.new do
+        loop do
+          Log.debug3('Start blocking read (TCPClient).')
+          # Blocking read.
+          if !socket_good?
+            Log.warning("Socket not good, waiting for reconnection with " \
+                          "#{Params['client_retry_delay']} seconds timeout.")
+            @remote_server_available_mutex.synchronize {
+              @remote_server_available.wait(@remote_server_available_mutex,
+                                            Params['client_retry_delay'])
+            }
+          else
+            read_ok, obj = Networking.read_from_stream(@tcp_socket)
+            Log.debug3("Client returned from read: #{read_ok}")
+            # Handle case when socket is closed in middle.
+            # In that case we should not call obj_clb.
+            @obj_clb.call(obj) if (read_ok && @obj_clb != nil)
+          end
+        end
+      end
+    end
+  end  # TCPClient
+end
+

data/lib/networking/version.rb

@@ -0,0 +1,3 @@
+module Networking
+  VERSION = "1.1.0"
+end

data/lib/networking.rb

@@ -0,0 +1,4 @@
+require 'networking/tcp'
+
+module Networking
+end

data/lib/params/version.rb

@@ -0,0 +1,3 @@
+module Params
+  VERSION = "1.1.0"
+end