From ab25aac502a768b6a530ada5c46d6aabe6a56c4c Mon Sep 17 00:00:00 2001 From: AndrewMurrell Date: Sat, 26 Apr 2014 22:47:58 -0400 Subject: Added READMEs for scheduling and started seeding in lib. --- lib/scheduling/README.md | 13 +++++++++++++ lib/scheduling/elimination.rb | 25 ++++++++++++------------- lib/scheduling/roundrobin.rb | 31 +++++++++++++++++++++---------- lib/seeding/.keep | 0 lib/seeding/README.md | 3 +++ 5 files changed, 49 insertions(+), 23 deletions(-) create mode 100644 lib/scheduling/README.md create mode 100644 lib/seeding/.keep create mode 100644 lib/seeding/README.md (limited to 'lib') diff --git a/lib/scheduling/README.md b/lib/scheduling/README.md new file mode 100644 index 0000000..173b7be --- /dev/null +++ b/lib/scheduling/README.md @@ -0,0 +1,13 @@ +Files in this directory should implement the following interface: + + - `initialize(tournament_stage)` + construct new Scheduling object from tournament_stage + + - `create_matches` + creates all the matches of the current round + + - `finish_match(match)` + progresses the match through the schedule + + - `graph` + returns a string representation of an svg image of the current stage \ No newline at end of file diff --git a/lib/scheduling/elimination.rb b/lib/scheduling/elimination.rb index 074cb5c..4518cff 100644 --- a/lib/scheduling/elimination.rb +++ b/lib/scheduling/elimination.rb @@ -33,8 +33,7 @@ module Scheduling end end - def match_finished(match) - #what in the goddamn fuck does this mean + def finish_match(match) matches = match.tournament_stage.matches_ordered cur_match_num = matches.invert[match] unless cur_match_num == 1 @@ -55,17 +54,17 @@ module Scheduling height = [(matchHeight+50) * logBase**(depth-1) + 100, 500].max; str = <<-STRING - - - - - - - -STRING + + + + + + + + STRING base = 1 pBase = 1 (1..matches.count).each do |i| diff --git a/lib/scheduling/roundrobin.rb b/lib/scheduling/roundrobin.rb index e149860..7a9e257 100644 --- a/lib/scheduling/roundrobin.rb +++ b/lib/scheduling/roundrobin.rb @@ -14,6 +14,17 @@ module Scheduling end end + def finish_match(match) + #declare winner of match, and store that somehow + rotate + return "totes worked\n" + end + + def graph(current_user) + end + + private + def create_round_array #round robin should look like this. #NOTE: I DO NOT KNOW IF THIS IS HOW TO PROPERLY POPULATE THE ROUND ROBIN ARRAY WITH TEAMS @@ -28,15 +39,23 @@ module Scheduling end end - #this is called when a round has completed + def tournament_stage + @tournament_stage + end + + def tournament + tournament_stage.tournament + end + def rotate + #this is called when a round has completed + #remove first team hold = @team_pairs.shift #rotate by 1 element @team_pairs.rotate! #place first team the front of the array @team_pairs.unshift(hold) - end def mother_fuckin_winner @@ -50,14 +69,6 @@ module Scheduling scores[weiner] end - def match_finished(match) - #declare winner of match, and store that somehow - rotate - return "totes worked\n" - end - def graph(current_user) - - end end end diff --git a/lib/seeding/.keep b/lib/seeding/.keep new file mode 100644 index 0000000..e69de29 diff --git a/lib/seeding/README.md b/lib/seeding/README.md new file mode 100644 index 0000000..2f12622 --- /dev/null +++ b/lib/seeding/README.md @@ -0,0 +1,3 @@ +Files in this directory should implement the following interface: + +- -- cgit v1.2.3-2-g168b From 4638a832b3b9da87bf076f4370e0d99bdf11ee78 Mon Sep 17 00:00:00 2001 From: AndrewMurrell Date: Sat, 26 Apr 2014 23:21:57 -0400 Subject: Fixed metaprogramming, I think. and added README for seeding --- lib/seeding/README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'lib') diff --git a/lib/seeding/README.md b/lib/seeding/README.md index 2f12622..0afbb94 100644 --- a/lib/seeding/README.md +++ b/lib/seeding/README.md @@ -1,3 +1,4 @@ Files in this directory should implement the following interface: -- +- seed_matches(tournament) + take the matches of a tournament and the players in a tournament, assign players to teams, and teams to matches -- cgit v1.2.3-2-g168b From 40939795096c0b7a1791d71d920b84ff283fb550 Mon Sep 17 00:00:00 2001 From: Luke Shumaker Date: Fri, 25 Apr 2014 11:09:09 -0400 Subject: Sampling methods WIP --- lib/sampling/README.md | 28 +++++++ lib/sampling/double_bind.rb | 7 ++ lib/sampling/manual.rb | 35 +++++++++ lib/sampling/riot_api.rb | 169 +++++++++++++++++++++++++++++++++++++++++++ lib/throttled_api_request.rb | 25 +++++++ 5 files changed, 264 insertions(+) create mode 100644 lib/sampling/README.md create mode 100644 lib/sampling/double_bind.rb create mode 100644 lib/sampling/manual.rb create mode 100644 lib/sampling/riot_api.rb create mode 100644 lib/throttled_api_request.rb (limited to 'lib') diff --git a/lib/sampling/README.md b/lib/sampling/README.md new file mode 100644 index 0000000..28c603e --- /dev/null +++ b/lib/sampling/README.md @@ -0,0 +1,28 @@ +Files in this directory should be modules implementing the following +interface: + + - `works_with?(Game) => Boolean` + Returns whether or not this sampling method works with the + specified game. + + - `uses_remote?() => Boolean` + Return whether or not this sampling method requires remote IDs for + users. + - `set_remote_name(User, Game, String)` + Set the remote ID for a user for the specified game. It is safe to + assume that this sampling method `works_with?` that game. + - `get_remote_name(Object)` + When given an object from `RemoteUsername#value`, give back a + human-readable/editable name to display. + + - `sampling_start(Match)` + Fetch the statistics for a match. + - `sampling_done?(Match) => Boolean` + Returns whether or not statistics have been completely collected + yet. + + - `render_user_interaction(Match, User) => String` + Returns HTML to render on a page. + - `handle_user_interaction(Match, User, Hash params)` + Handles params from the form generated by + `#user_interaction_render`. diff --git a/lib/sampling/double_bind.rb b/lib/sampling/double_bind.rb new file mode 100644 index 0000000..4a5201c --- /dev/null +++ b/lib/sampling/double_bind.rb @@ -0,0 +1,7 @@ +module Sampling + module DoubleBlind + def works_with?(game) + return true + end + end +end diff --git a/lib/sampling/manual.rb b/lib/sampling/manual.rb new file mode 100644 index 0000000..17c8104 --- /dev/null +++ b/lib/sampling/manual.rb @@ -0,0 +1,35 @@ +module Sampling + module HostEntry + def self.works_with?(game) + return true + end + + def self.uses_remote? + return false + end + + def self.set_remote_name(user, game, value) + raise "This sampling method doesn't use remote usernames." + end + + def self.get_remote_name(value) + raise "This sampling method doesn't use remote usernames." + end + + def self.sampling_start(match) + # TODO + end + + def self.sampling_done?(match) + # TODO + end + + def self.render_user_interaction(match, user) + + end + + def self.handle_user_interaction(match, user, sampling_params) + match.statistics.create(user: nil, name: "blowout", + end + end +end diff --git a/lib/sampling/riot_api.rb b/lib/sampling/riot_api.rb new file mode 100644 index 0000000..3de4185 --- /dev/null +++ b/lib/sampling/riot_api.rb @@ -0,0 +1,169 @@ +module Sampling + module RiotApi + ## + # Return whether or not this sampling method works with the specified game. + # Spoiler: It only works with League of Legends (or subclasses of it). + public + def works_with?(game) + if api_key.nil? or region.nil? + return false + end + if game.name == "League of Legends" + return true + end + unless game.parent.nil? + return works_with?(game.parent) + end + end + + ## + # This sampling method uses remote IDs + public + def uses_remote? + return true + end + + ## + # When given a summoner name for a user, figure out the summoner ID. + public + def set_remote_name(user, game, summoner_name) + Delayed::Job.enqueue(UsernameJob.new(user, game, summoner_name), :queue => api_name) + end + private + class UsernameJob < Job + def initialize(user, game, summoner_name) + @user_id = user.id + @game_id = game.id + # Escape any funny stuff + summoner_names = [summoner_name].map{|name|Sampling::RiotApi::standardize(name.gsub(',',''))} + # Generate the request + super("v1.3/summoner/by-name/%{summonerNames}", { :summonerNames => summoner_names.join(",") }) + end + def handle(data) + user = User.find(@user_id) + game = Game.find(@game_id) + + normalized_summoner_name = data.keys.first + remote_data = { + :id => data[normalized_summoner_name]["id"], + :name => data[normalized_summoner_name]["name"], + } + + user.set_remote_username(game, remote_data) + end + end + + ## + # When given data from RemoteUsername#value, give back a readable name to display. + # Here, this is the summoner name. + public + def get_remote_name(data) + data["name"] + end + + ## + # Fetch all the statistics for a match. + public + def sampling_start(match) + @match.teams.each do |team| + team.users.each do |user| + Delayed::Job.enqueue(MatchJob.new(user, match), :queue => api_name) + end + end + end + private + class FetchStatisticsJob < Job + def initialize(user, match) + @user_id = user.id + @match_id = match.id + # Get the summoner id + summoner = user.get_remote_username(match.tournament_stage.tournament.game) + if summoner.nil? + raise "Someone didn't enter their summoner name" + end + # Generate the request + super("v1.3/game/by-summoner/%{summonerId}/recent", { :summonerId => summoner["id"] }) + end + def handle(data) + user = User.find(@user_id) + match = Match.find(@match_id) + Statistic.create(user: user, match: match, value: TODO) + end + end + + public + def sampling_done?(match) + # TODO + end + + public + def render_user_interaction(match, user) + return "" + end + + public + def handle_user_interaction(match, user) + end + + ######################################################################## + + private + def api_name + "prod.api.pvp.net/api/lol" + end + + private + def api_key + ENV["RIOT_API_KEY"] + end + + private + def region + ENV["RIOT_API_REGION"] + end + + private + def url(request, args={}) + "https://prod.api.pvp.net/api/lol/#{region}/#{request % args.merge(args){|k,v|url_escape(v)}}?#{api_key}" + end + + private + def url_escape(string) + URI::escape(string.to_s, /[^a-zA-Z0-9._~!$&'()*+,;=:@-]/) + end + + private + def standardize(summoner_name) + summoner_name.to_s.downcase.gsub(' ', '') + end + + private + class Job < ThrottledApiRequest.new(api_name, 10.seconds, 10) + def initialize(request, args={}) + @url = Sampling::RiotApi::url(request, args) + end + + def perform + response = open(@url) + status = response.status + data = JSON::parse(response.read) + + # Error codes that RIOT uses: + # "400"=>"Bad request" + # "401"=>"Unauthorized" + # "429"=>"Rate limit exceeded" + # "500"=>"Internal server error" + # "503"=>"Service unavailable" + # "404"=>"Not found" + # Should probably handle these better + if status[0] != "200" + raise "GET #{@url} => #{status.join(" ")}" + end + self.handle(data) + end + + def handle(data) + end + end + end +end diff --git a/lib/throttled_api_request.rb b/lib/throttled_api_request.rb new file mode 100644 index 0000000..3f30c56 --- /dev/null +++ b/lib/throttled_api_request.rb @@ -0,0 +1,25 @@ +class ThrottledApiRequest < Struct.new(:api_name, :unit_time, :requests_per) + def before(job) + loop do + sleep_for = -1 + ActiveRecord::Base.transaction do + ApiRequests.create(:api_name => self.api_name) + recent_requests = ApiRequets. + where(:api_name => self.api_name). + where("updated_at > ?", Time.now.utc - self.unit_time). + order(:updated_at) + if (recent_requests.count > self.requests_per) + sleep_for = Time.now.utc - recent_requests[recent_requests.count-self.requests_per].updated_at + raise ActiveRecord::Rollback + else + sleep_for = -1 + end + end + if sleep_for != -1 + sleep(sleep_for) + else + break + end + end + end +end -- cgit v1.2.3-2-g168b