tools

hue.rb (5400B)

---

 # frozen_string_literal: true
 
 require 'net/http'
 require 'json'
 require 'securerandom'
 require 'logger'
 require 'fileutils'
 require 'socket'
 require 'timeout'
 
 module Hue
   DEVICE_TYPE = 'hue-cli'
   DEFAULT_UDP_TIMEOUT = 5
   ERROR_DEFAULT_EXISTS = 'Default application already registered.'
   ERROR_NO_BRIDGE_FOUND = 'No bridge found.'
 
   def self.device_type
     DEVICE_TYPE
   end
 
   def self.one_time_uuid
     SecureRandom.hex(16)
   end
 
   def self.register_default
     raise Hue::Error, ERROR_DEFAULT_EXISTS if begin
       Hue::Config::Application.default
     rescue StandardError
       nil
     end
 
     bridge_config = register_bridges.values.first # Assuming one bridge for now
     puts 'Registering new app...'
     instance = Hue::Bridge.register(bridge_config.uri)
     app_config = Hue::Config::Application.new(bridge_config.id, instance.application_id)
     app_config.write
     instance
   end
 
   def self.application
     application_config = Hue::Config::Application.default
     bridge_id = application_config.bridge_id
     bridge_config = Hue::Config::Bridge.find(bridge_id) || register_bridges[bridge_id]
 
     raise Error, "Unable to find bridge: #{bridge_id}" unless bridge_config
 
     Hue::Bridge.new(application_config.id, bridge_config.uri)
   end
 
   def self.remove_default
     instance = application
     instance.unregister
     Hue::Config::Application.default.delete
     true
   end
 
   def self.discover
     bridges = {}
     udp_discover(bridges)
     nupnp_discover(bridges)
     bridges
   end
 
   UDP_SSDP_PAYLOAD = <<~PAYLOAD
     M-SEARCH * HTTP/1.1
     ST: ssdp:all
     MX: 10
     MAN: ssdp:discover
     HOST: 239.255.255.250:1900
   PAYLOAD
   UDP_SSDP_ADDRESS = '239.255.255.250'
   UDP_SSDP_PORT = 1900
 
   def self.udp_discover(bridges)
     log = Hue.logger
     log.info('Bridge UDP Discovery')
     socket = UDPSocket.new(Socket::AF_INET)
     socket.send(UDP_SSDP_PAYLOAD, 0, UDP_SSDP_ADDRESS, UDP_SSDP_PORT)
     Timeout.timeout(DEFAULT_UDP_TIMEOUT, Hue::Error) { listen_for_bridges(socket, bridges, log) }
   rescue Hue::Error => e
     log.warn(e)
     log.info('UDPSocket timed out.')
   end
 
   def self.listen_for_bridges(socket, bridges, log)
     loop do
       message, (_, port, hostname, ip_add) = socket.recvfrom(1024)
       if message =~ /IpBridge/ && /LOCATION: (.*)$/.match(message)
         uuid_match = /uuid:(.{36})/.match(message)
         next unless uuid_match
 
         uuid = uuid_match.captures.first
         log.info("Found bridge (#{hostname}:#{port}) with uuid: #{uuid}") unless bridges[uuid]
         bridges[uuid] = "http://#{ip_add}/api"
       else
         log.debug("Found #{hostname}:#{port}: #{message}")
       end
     end
   end
 
   def self.nupnp_discover(bridges)
     return unless bridges.empty?
 
     Hue.logger.info('Bridge NUPNP Discovery')
     response = Net::HTTP.get_response(URI('https://www.meethue.com/api/nupnp'))
     json = begin
       JSON.parse(response.body)
     rescue StandardError
       nil
     end
     return unless json
 
     json.each do |bridge|
       uuid = bridge['id']
       ip_add = bridge['internalipaddress']
       bridges[uuid] = "http://#{ip_add}/api" if uuid && ip_add
     end
   end
 
   def self.register_bridges
     bridges = discover
     raise Error, ERROR_NO_BRIDGE_FOUND if bridges.empty?
 
     bridges.each_with_object({}) do |(id, ip), hash|
       config = Hue::Config::Bridge.new(id, ip)
       config.write
       hash[id] = config
     end
   end
 
   class Error < StandardError
     attr_accessor :original_error
 
     def initialize(message, original_error = nil)
       super(message)
       @original_error = original_error
     end
 
     def to_s
       @original_error ? "#{super}\nCause: #{@original_error}" : super
     end
   end
 
   module API
     class Error < ::Hue::Error
       def initialize(api_error)
         @type = api_error['type']
         @address = api_error['address']
         super(api_error['description'])
       end
     end
   end
 
   def self.logger
     @logger ||= begin
       log_dir_path = ensure_log_dir
       log_file_path = File.join(log_dir_path, 'hue.log')
       log_file = File.new(log_file_path, File::WRONLY | File::APPEND | File::CREAT)
       logger = Logger.new(log_file)
       logger.level = Logger::INFO
       logger
     end
   end
 
   def self.ensure_log_dir
     home = Dir.home
     [File.join(home, '.hue'), File.join(home, ".#{device_type}")].each do |path|
       FileUtils.mkdir_p(path)
       return path
     rescue Errno::EACCES
       next
     end
     raise Error, 'Unable to create log directory'
   end
 
   def self.percent_to_unit_interval(value)
     if (percent = /(\d+)%/.match(value.to_s))
       percent.captures.first.to_i / 100.0
     end
   end
 end
 
 # Core library components
 require_relative 'hue/config/abstract'
 require_relative 'hue/config/application'
 require_relative 'hue/config/bridge'
 require_relative 'hue/bridge'
 require_relative 'hue/colors'
 require_relative 'hue/bulb'
 
 # CLI components (utilities must come before extensions)
 require_relative 'hue/utilities/indentation'
 require_relative 'hue/cli'
 require_relative 'hue/cli/command'
 require_relative 'hue/cli/processors/light_state_alias'
 require_relative 'hue/cli/commands/register'
 require_relative 'hue/cli/commands/delete'
 require_relative 'hue/cli/commands/light'
 require_relative 'hue/cli/commands/lights'
 require_relative 'hue/extensions/hue'
 require_relative 'hue/extensions/bridge'
 require_relative 'hue/extensions/bulb'