sportsflix 0.1.0.alpha.1

data/README.md

@@ -0,0 +1,57 @@
+# sportsflix
+
+Watch the best sports stream in HD from the command line
+
+## Installation
+
+```sh
+gem install sportsflix
+```
+
+## Usage
+
+### Examples
+
+**Watch Benfica game**
+```
+sflix watch --video-format=mkv --video-player=vlc --club=BENFICA
+```
+
+**Watch game on Mac OS with VLC**
+```
+sflix watch --video-player-path="/Applications/VLC.app/Contents/MacOS/VLC"
+```
+
+### Help
+
+    Commands:
+      sflix help [COMMAND]  # Describe available commands or one specific command
+      sflix watch           # watch stream in the chosen player
+    
+    Options:
+      vvv, [--verbose], [--no-verbose]
+      o, [--offset=N]
+                                                   # Default: 0
+      f, [--video-format=VIDEO-FORMAT]
+                                                   # Default: mp4
+      c, [--club=CLUB]
+      p, [--video-player=VIDEO-PLAYER]
+                                                   # Default: vlc
+      pp, [--video-player-path=VIDEO-PLAYER-PATH]
+                                                   # Default: vlc
+      ni, [--no-interactive]
+      s, [--server-only], [--no-server-only]
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rtfpessoa/sportsflix. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Copyright
+
+Copyright (c) 2017-present Rodrigo Fernandes. See [LICENSE](https://github.com/rtfpessoa/sportsflix/blob/master/LICENSE.md) for details.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'sportsflix'
+
+# 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/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/bin/sflix

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "sportsflix/cli"
+
+Sportsflix::CLI.start(ARGV)

data/circle.yml

@@ -0,0 +1,11 @@
+machine:
+  ruby:
+    version: 2.3.1
+dependencies:
+  override:
+    - gem install bundler -v 1.14.3
+    - bundle check || bundle install
+test:
+  override:
+    - bundle exec rubocop
+    - bundle exec rake

data/lib/sportsflix.rb

@@ -0,0 +1,124 @@
+require 'net/http'
+require 'socket'
+require 'sportsflix/players/vlc'
+require 'sportsflix/providers/arenavision'
+require 'sportsflix/utils/exec'
+
+module Sportsflix
+  class API
+
+    def initialize(options)
+      @verbose        = options[:verbose]
+      @stream_offset  = options[:offset]
+      @club_name      = options[:club]
+      @no_interactive = options['no-interactive']
+      @video_player   = options['video-player'].to_sym
+
+      @arenavision_client = Providers::Arenavision::Client.new(options)
+      @executor           = Sportsflix::Utils::Executor.new(options)
+      @players            = {
+          :vlc => Sportsflix::Players::VLC::Client.new(options)
+      }
+    end
+
+    def watch
+      streams = @arenavision_client.list_streams
+
+      if @club_name
+        streams = streams.select do |stream|
+          stream[:game].downcase.include?(@club_name.downcase)
+        end
+      end
+
+      response = ask_choose_stream(streams)
+
+      stream_uri = @arenavision_client.get_stream_uri(response[:channel_number])
+
+      unless @players.key?(@video_player)
+        puts "Unable to find client for #{@video_player} player"
+        exit(1)
+      end
+
+      player = @players[@video_player]
+      player.start({
+                       :proxy => response[:stream][:proxy],
+                       :uri   => stream_uri
+                   })
+    end
+
+    private
+    def ask_choose_stream(streams)
+      selection       = ask_stream(streams)
+      selected_stream = streams[selection]
+
+      stream_languages   = selected_stream[:stream_nr]
+      language_selection = ask_language(stream_languages)
+
+      stream_channels   = stream_languages[language_selection]
+      stream_channel_nr = ask_channel(stream_channels)
+
+      {
+          :stream         => selected_stream,
+          :channel_number => stream_channel_nr
+      }
+    end
+
+    def ask_stream(streams)
+      selection = 0
+      if streams.empty?
+        puts "There are no streams matching your query #{@club_name}"
+        exit(1)
+      elsif streams.length > 1 && !@no_interactive
+        streams.each_with_index do |stream, idx|
+          puts "#{idx}) #{stream[:game]}"
+        end
+
+        printf 'Choose the game: '
+        selection = STDIN.gets.chomp.to_i
+        puts ''
+      end
+      selection
+    end
+
+    def ask_language(stream_channels)
+      channel_selection = 0
+      if stream_channels.length > 1 && !@no_interactive
+        stream_channels.each_with_index do |channel, idx|
+          puts "#{idx}) #{channel[:language]}"
+        end
+
+        printf 'Choose the language: '
+        channel_selection = STDIN.gets.chomp.to_i
+        puts ''
+      end
+      channel_selection
+    end
+
+    def ask_channel(stream_channels)
+      stream_channel_nr = stream_channels[:start]
+      if stream_channels[:start] != stream_channels[:end] && !@no_interactive
+        possible_channels = (stream_channels[:start]..stream_channels[:end]).to_a
+        possible_channels.each_with_index do |nr, idx|
+          if @stream_offset == idx
+            puts "*#{idx}) Channel #{nr}"
+          else
+            puts " #{idx}) Channel #{nr}"
+          end
+        end
+
+        printf 'Choose the channel number: '
+        stream_channel_idx_raw = STDIN.gets.chomp
+        puts ''
+
+        begin
+          stream_channel_offset = Integer(stream_channel_idx_raw)
+        rescue ArgumentError
+          stream_channel_offset = @stream_offset
+        end
+        stream_channel_nr = possible_channels[stream_channel_offset]
+      end
+      stream_channel_nr
+    end
+
+  end
+end

data/lib/sportsflix/cli.rb

@@ -0,0 +1,30 @@
+require 'thor'
+require 'sportsflix'
+
+module Sportsflix
+
+  class CLI < Thor
+
+    # SLB, SLB, SLB, SLB, Glorioso SLB, Glorioso SLB !!!
+    DEFAULT_TEAM              = 'BENFICA'
+    DEFAULT_OFFSET            = 0
+    DEFAULT_VIDEO_FORMAT      = 'mp4'
+    DEFAULT_VIDEO_PLAYER      = 'vlc'
+    DEFAULT_VIDEO_PLAYER_PATH = DEFAULT_VIDEO_PLAYER
+
+    class_option('verbose', { :aliases => :vvv, :type => :boolean, :default => false })
+    class_option('offset', { :aliases => :o, :type => :numeric, :default => DEFAULT_OFFSET })
+    class_option('video-format', { :aliases => :f, :type => :string, :default => DEFAULT_VIDEO_FORMAT })
+    class_option('club', { :aliases => :c, :type => :string })
+    class_option('video-player', { :aliases => :p, :type => :string, :default => DEFAULT_VIDEO_PLAYER })
+    class_option('video-player-path', { :aliases => :pp, :type => :string, :default => DEFAULT_VIDEO_PLAYER_PATH })
+    class_option('no-interactive', { :aliases => :ni, :type => :boolean, :default => false })
+    class_option('server-only', { :aliases => :s, :type => :boolean, :default => false })
+
+    desc('watch', 'watch stream in the chosen player')
+    def watch
+      api = API.new(options)
+      api.watch
+    end
+  end
+end

data/lib/sportsflix/players/proxies/acestream.rb

@@ -0,0 +1,59 @@
+require 'sportsflix/utils/exec'
+
+module Sportsflix
+  module Players
+    module Proxies
+      module Acestream
+        class Client
+
+          ACESTREAM_STREAM_URI_PREFIX    = 'acestream://'
+          ACESTREAM_PROXY_IMAGE_NAME     = ['ikatson/aceproxy', 'zveronline/aceproxy']
+          ACESTREAM_PROXY_IMAGE_NAME_IDX = 0
+          ACESTREAM_PROXY_DOCKER_NAME    = 'acestream'
+
+          def initialize(options)
+            @verbose      = options[:verbose]
+            @video_format = options['video-format']
+
+            @executor = Sportsflix::Utils::Executor.new(options)
+          end
+
+          def start
+            @executor.run %{docker pull #{ACESTREAM_PROXY_IMAGE_NAME[ACESTREAM_PROXY_IMAGE_NAME_IDX]}}
+            @executor.run %{docker run -d -t -p 8000:8000 --name #{ACESTREAM_PROXY_DOCKER_NAME} #{ACESTREAM_PROXY_IMAGE_NAME[ACESTREAM_PROXY_IMAGE_NAME_IDX]}}
+          end
+
+          def stop
+            @executor.run %{docker rm -f #{ACESTREAM_PROXY_DOCKER_NAME}}
+          end
+
+          def url(uri)
+            stream_uuid = uri.sub(ACESTREAM_STREAM_URI_PREFIX, '')
+            machine_ip  = local_ip
+            "http://#{machine_ip}:8000/pid/#{stream_uuid}/stream.#{@video_format}"
+          end
+
+          private
+          def local_ip
+            # Turn off reverse DNS resolution temporarily
+            orig                         = Socket.do_not_reverse_lookup
+            Socket.do_not_reverse_lookup = true
+
+            begin
+              UDPSocket.open do |s|
+                # Google
+                s.connect '64.233.187.99', 1
+                s.addr.last
+              end
+            rescue
+              return '127.0.0.1'
+            end
+          ensure
+            # Restore DNS resolution
+            Socket.do_not_reverse_lookup = orig
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sportsflix/players/proxies/default.rb

@@ -0,0 +1,26 @@
+module Sportsflix
+  module Players
+    module Proxies
+      module Default
+        class Client
+
+          def initialize(options)
+            @verbose = options[:verbose]
+          end
+
+          def start
+            puts 'Starting default proxy' if @verbose
+          end
+
+          def stop
+            puts 'Stopping default proxy' if @verbose
+          end
+
+          def url(uri)
+            uri
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sportsflix/players/vlc.rb

@@ -0,0 +1,84 @@
+require 'sportsflix/players/proxies/acestream'
+require 'sportsflix/players/proxies/default'
+require 'sportsflix/utils/exec'
+
+module Sportsflix
+  module Players
+    module VLC
+      class Client
+
+        ALTERNATIVE_PLAYER_PATHS = [
+            'vlc',
+            '/Applications/VLC.app/Contents/MacOS/VLC',
+            '/c/Program Files/VideoLAN/VLC/vlc.exe',
+            '/mnt/c/Program Files/VideoLAN/VLC/vlc.exe'
+        ]
+
+        def initialize(options)
+          @verbose           = options[:verbose]
+          @server_only       = options['server-only']
+          @video_player_path = options['video-player-path']
+
+          @executor       = Sportsflix::Utils::Executor.new(options)
+          @stream_proxies = {
+              :default   => Sportsflix::Players::Proxies::Default::Client.new(options),
+              :acestream => Sportsflix::Players::Proxies::Acestream::Client.new(options)
+          }
+        end
+
+        def start(stream)
+          proxy = @stream_proxies[stream[:proxy]]
+
+          proxy.stop
+          proxy.start
+
+          # Waiting for proxy to start
+          sleep(10)
+
+          unless @server_only
+            video_player     = find_video_player
+            stream_final_url = proxy.url(stream[:uri])
+
+            puts "Playing #{stream_final_url}"
+            @executor.run %{#{video_player} #{stream_final_url}}
+
+            proxy.stop
+          end
+        end
+
+        private
+        def find_video_player
+          unless which(@video_player_path) || File.exist?(@video_player_path)
+            puts "Could not find video player #{@video_player_path}, searching for alternatives ..."
+
+            ALTERNATIVE_PLAYER_PATHS.each do |path|
+              if which(path) || File.exist?(path)
+                puts "Found VLC player in #{path}"
+                return path
+              end
+            end
+
+            puts 'Could not find vlc in any of the alternative locations'
+            exit(1)
+          end
+
+          @video_player_path
+        end
+
+        # Cross-platform way of finding an executable in the $PATH.
+        # Source: http://stackoverflow.com/posts/5471032/revisions
+        def which(cmd)
+          exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+            exts.each { |ext|
+              bin = File.join(path, "#{cmd}#{ext}")
+              return File.executable?(bin) && !File.directory?(bin)
+            }
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/sportsflix/providers/arenavision.rb

@@ -0,0 +1,88 @@
+require 'net/http'
+require 'oga'
+
+module Sportsflix
+  module Providers
+    module Arenavision
+      class Client
+        ARENAVISION_BASE_URL        = ['http://arenavision.in', 'http://arenavision.ru']
+        ARENAVISION_DEFAULT_URL_IDX = 0
+
+        def initialize(options)
+          @verbose     = options[:verbose]
+          @club_name   = options[:club]
+          @server_only = options['server-only']
+
+          @schedule = get_page_contents("#{ARENAVISION_BASE_URL[ARENAVISION_DEFAULT_URL_IDX]}/schedule")
+        end
+
+        def list_streams
+          streams = @schedule.css('table tr')
+          # Remove first element
+          streams = streams.drop(1)
+          # Remove last element
+          streams.pop(2)
+
+          # Remove weird empty lines with non-breaking spaces ?!?
+          streams = streams.select do |item|
+            item_text = item.css('td:nth-child(1)').text
+            item_text = item_text.force_encoding('UTF-8')
+            item_text =item_text.delete(' ').strip
+            not item_text.empty?
+          end
+
+          streams.map do |item|
+            {
+                :date        => clean_str(item.css('td:nth-child(1)').text),
+                :hour        => clean_str(item.css('td:nth-child(2)').text),
+                :sport       => clean_str(item.css('td:nth-child(3)').text),
+                :competition => clean_str(item.css('td:nth-child(4)').text),
+                :game        => clean_str(item.css('td:nth-child(5)').text),
+                :stream_nr   => parse_stream_ids(clean_str(item.css('td:nth-child(6)').text)),
+                :proxy       => :acestream
+            }
+          end
+        end
+
+        def get_stream_uri(stream_nr)
+          stream_raw = get_page_contents("#{ARENAVISION_BASE_URL[ARENAVISION_DEFAULT_URL_IDX]}/av#{stream_nr}")
+          stream_raw.css('p[class="auto-style1"] a').first.get('href')
+        end
+
+        private
+        def get_page_contents(raw_url)
+          url  = URI.parse(raw_url)
+          enum = Enumerator.new do |yielder|
+            Net::HTTP.start(url.host, url.port) do |http|
+              http.request_get(url.path) do |response|
+                response.read_body do |chunk|
+                  yielder << chunk
+                end
+              end
+            end
+          end
+
+          Oga.parse_xml(enum)
+        end
+
+        def parse_stream_ids(raw_stream)
+          matches = raw_stream.scan(/(([0-9]+)(?:-([0-9]+))? \[(.+?)\])/)
+          matches.map do |match|
+            {
+                :start    => match[1].to_i,
+                :end      => (match[2] || match[1]).to_i,
+                :language => match[3]
+            }
+          end
+        end
+
+        def clean_str(str)
+          str.force_encoding('UTF-8')
+              .gsub("\n\t\t", ' ')
+              .strip
+        end
+
+      end
+    end
+  end
+end