diff options
Diffstat (limited to 'crystal/tcpsocket.cr')
| -rw-r--r-- | crystal/tcpsocket.cr | 1058 |
1 files changed, 1015 insertions, 43 deletions
diff --git a/crystal/tcpsocket.cr b/crystal/tcpsocket.cr index b4ee6a8..f97169e 100644 --- a/crystal/tcpsocket.cr +++ b/crystal/tcpsocket.cr @@ -22,6 +22,22 @@ struct Nil end end +macro testrefuser2uid( path ) + {% if flag?(:windows) %} + File.exists?( {{path}} ) && ( File.read( {{ path }} ) =~ /^[0-9]+$/ ) + {% else %} + File.symlink?( {{path}} ) + {% end %} +end + +macro genrefuser2uid( path, uid, depth ) + {% if flag?(:windows) %} + File.write( {{path}}, {{uid}}.to_s ) + {% else %} + File.symlink( "../"*{{depth}} + "uids/#{{{uid}}}", {{path}} ) + {% end %} +end + def ppe(object) PrettyPrint.format( object, STDERR, 79 ) STDERR.puts @@ -40,25 +56,31 @@ ENV["XDG_CONFIG_HOME"]? && ( configdir = ENV["XDG_CONFIG_HOME"] + ENV["LOCALAPPDATA"]? && ( configdir = Path.windows( ENV["LOCALAPPDATA"] + "\\#{EXE}\\" ).to_s ) # cygwin will have both, but should probably use LOCALAPPDATA -def writeconfig( configdir : String, file : String, contents : String ) - Dir.mkdir_p( configdir ) - File.write( configdir + file, contents ) +def writeconfig( filepath : Path, contents : String ) + Dir.mkdir_p( filepath.parent ) + File.write( filepath, contents ) rescue exio : IO::Error - puts "ERROR: Unable to write #{ configdir + file }.txt: #{exio.message}" + puts "ERROR: Unable to write #{ filepath }: #{exio.message}" exit 7 end -configfile = configdir + "config.txt" +configfile = Path[configdir + "config.txt"].normalize +if ARGV.size >= 1 + configfile = Path[ ARGV[0] ].normalize +end +puts configfile + if File.exists?( configfile ) - config = BungmoBott::Config.from_yaml( File.read( configdir + "config.txt" ) ) + config = BungmoBott::Config.from_yaml( File.read( configfile ) ) else config = BungmoBott::Config.from_yaml("---") STDERR.puts "WARNING: #{configfile} not found. Writing new one." - writeconfig( configdir, "config.txt", config.to_yaml ) + writeconfig( configfile, config.to_yaml ) end puts config.to_yaml +# FIXME: maybe do this in the after_initialize method? unless config.yaml_unmapped.empty? STDERR.puts "WARNING: #{configfile} has unknown properties:" ppe config.yaml_unmapped @@ -74,14 +96,17 @@ if ( config.join_channels && ! config.join_channels.not_nil!.yaml_unmapped.empty ppe config.join_channels.not_nil!.yaml_unmapped end -secretsfile = configdir + "secrets.txt" +secretsfile = Path[ configdir + "secrets.txt" ].normalize +if ARGV.size >= 2 + secretsfile = Path[ ARGV[1] ].normalize +end if File.exists?( secretsfile ) secrets = BungmoBott::Secrets.from_yaml( File.read( secretsfile ) ) else secrets = BungmoBott::Secrets.from_yaml( "---" ) STDERR.puts "WARNING: #{secretsfile} not found. Writing new one." - writeconfig( configdir, "secrets.txt", secrets.to_yaml ) + writeconfig( secretsfile, secrets.to_yaml ) end unless secrets.yaml_unmapped.empty? @@ -89,6 +114,35 @@ unless secrets.yaml_unmapped.empty? ppe secrets.yaml_unmapped.keys end +def obsrandommediaenable( obs : OBS::WebSocket, siname : String ) + if ( Random.rand(3) < 2 ) + obs.scenes.current.metascene[siname][0].enable! + else + randsiname = obs.scenes.current.metascene.keys.select( /^#{siname}/ ).sample( 1 )[0] + obs.scenes.current.metascene[randsiname][0].enable! + end +end + +def obstemporarymediacreate( obs : OBS::WebSocket, sname : String, iname, path : String ) + iname = "media-temporary-effect-#{iname}" + isettings = Hash( String, String | Bool | Int64 | Float64 ){ + "advanced" => true, + "clear_on_media_end" => true, + "color_range" => 0.to_i64, + "is_local_file" => true, + "looping" => false, + "restart_on_activate" => true, + "local_file" => path, + } + response = obs.scenes[sname].createinput( iname, "ffmpeg_source", isettings ) + # Skip ORM stuff and configure the SceneItem as fast as we possibly can + if ( rdata = response["responseData"]? ) && ( goodtransform = obs.sources.last_known_real_transform?( iname ) ) + siid = rdata["sceneItemId"].as_i64 + obs.send( OBS.req( "SetSceneItemTransform", JSON.parse( { "sceneName" => sname, "sceneItemId" => siid, "sceneItemTransform" => { "positionX" => goodtransform.to_h["positionX"], "positionY" => goodtransform.to_h["positionY"] } }.to_json ) ) ) + end +end + + regextwitchuser = /^[0-9a-zA-Z_]+$/ # enable direct twitch api? @@ -132,6 +186,110 @@ else aws = true end +# enable microsoft speech services? +mss : Bool +{% if flag?(:windows) %} + mss = true +{% else %} + mss = false +{% end %} + +if ( mss || gcloud || aws ) && config.voice_list + text2speech = true +else + text2speech = false +end + +lastvoice = Array(String).new + +# channel message subscriptions: { service, chan } => [ client, client ] +#channelsubs = Hash( Tuple( String, String ), Array( OpenSSL::SSL::Socket::Server | Channel( Tuple( String, FastIRC::Message ) ) ) ).new +channelsubs = Hash( Tuple( String, String ), Array( OpenSSL::SSL::Socket::Server) ).new +# Unencrypted +#connections = Hash(TCPSocket, Hash(String, String)).new +# Encrypted +connections = Hash(OpenSSL::SSL::Socket::Server, Hash(String, String)).new +ircipc = Channel( Tuple( String, String ) ).new +# commandircipc: serv, chan, user, msg +commandircipc = Channel( Tuple( String, FastIRC::Message ) ).new +commandipc = Channel( String ).new +# t2sipc: voice, text +t2sipc = Channel( Tuple( String, String ) ).new +twitchipc = Channel( Tuple( String, String ) ).new +bbscliipc = Channel( String ).new +bbssrvipc = Channel( String ).new +waitgroup = Channel( String ).new + + +fiberipc = Channel( Fiber ).new +fibers = Hash( String, Fiber ).new + +evchan = Channel( JSON::Any ).new +obs : Nil | OBS::WebSocket = nil +if config.obs_connect + obs = OBS::WebSocket.new( "ws://#{config.obs_connect}/" ) + # OBS event thread + spawn name: "obs_event_thread" do + fiberipc.send( Fiber.current ) + obs.scenes["meta-foreground"].to_h.each_key do | key | + if key =~ /^media-temporary-/ + obs.inputs[key].delete! + end + end + obs.eventsub_add( evchan ) + while json = evchan.receive + # A Fiber.yield occurs after this to make sure "json" doesn't get overwritten before we can use it. + spawn do + d = json # Copy *immediately* + case d["eventType"].as_s + when "CurrentProgramSceneChanged" + say( twitchipc, config.chat_user.not_nil!.twitch.not_nil!, "| obs: switched scene to " + ( d["eventData"]["sceneName"]?.as_s? || "unknown" ) ) + when "MediaInputPlaybackEnded" + if d["eventData"]["inputName"].as_s =~ /^media-temporary-/ + obs.send( OBS.req( "RemoveInput", JSON.parse({ "inputName" => d["eventData"]["inputName"].as_s }.to_json) ) ) + elsif d["eventData"]["inputName"].as_s =~ /^media-/ + obs.scenes.current.metascene[d["eventData"]["inputName"].as_s][0].disable! + end + when "SceneItemEnableStateChanged" + edata = d["eventData"] + name = obs.scenes[ edata["sceneName"].as_s ][ edata["sceneItemId"].as_i64 ].name + if name !~ /media-temporary/ + say( twitchipc, config.chat_user.not_nil!.twitch.not_nil!, "| obs: source #{name} visibility is now #{edata["sceneItemEnabled"].as_bool}" ) + end + when "SceneItemTransformChanged" + edata = d["eventData"] + sceneitem = obs.scenes[edata["sceneName"].as_s][edata["sceneItemId"].as_i64] + t = edata["sceneItemTransform"] + if ( sceneitem.name =~ /^media-temporary-/ ) + spx = t["positionX" ].as_f.to_i64 + spy = t["positionY" ].as_f.to_i64 + sdx = t["sourceHeight"].as_f.to_i64 + sdy = t["sourceWidth" ].as_f.to_i64 + if ( spx == 0 && spy == 0 && sdx != 0 && sdy != 0 ) + # source position randomizer + bx = obs.video.to_h["baseWidth" ].as(Int64 | Float64).to_i64 + by = obs.video.to_h["baseHeight"].as(Int64 | Float64).to_i64 + spx = ( rand(bx) - (sdx / 2) ) + spy = ( rand(by) - (sdy / 2) ) + sceneitem.transform( { "positionX" => spx, "positionY" => spy } ) + end + end + when "SourceFilterEnableStateChanged" + edata = d["eventData"] + say( twitchipc, config.chat_user.not_nil!.twitch.not_nil!, "| obs: source #{edata["sourceName"].as_s} filter #{edata["filterName"].as_s} visibility is currently #{edata["filterEnabled"].as_bool}" ) + end + end + Fiber.yield + end + rescue ex + puts ex + ensure + waitgroup.send( Fiber.current.name.not_nil! ) + end + fiber = fiberipc.receive + fibers[fiber.name.not_nil!] = fiber +end + # enable effects? #effects = Hash( String, String ).new #if File.exists?( config.configdir + "/effects.txt" ) @@ -166,6 +324,50 @@ end # end #end +def urbandef( term : String ) +#{ +# "list": [ +# { +# "definition": "An overactive, small-proportioned homosexual [gentleman] who will [launch] at anything in [sight].", +# "permalink": "http://bungmonkey.urbanup.com/83517", +# "thumbs_up": 6, +# "author": "fishbear", +# "word": "bungmonkey", +# "defid": 83517, +# "current_vote": "", +# "written_on": "2003-04-04T11:55:12.000Z", +# "example": "\"That [chap] [in the corner] is a [proper] little bungmonkey. Look at him go!\"", +# "thumbs_down": 1 +# } +# ] +#} + ssl_context = OpenSSL::SSL::Context::Client.new + #{% if flag?(:windows) %} + #ssl_context.verify_mode = OpenSSL::SSL::VerifyMode::NONE + #{% end %} + #https://api.urbandictionary.com/v0/define?term=waifu + response = HTTP::Client.exec( "GET", "https://api.urbandictionary.com/v0/define?term=#{term}", tls: ssl_context ) + puts response.status_code + json = JSON.parse( response.body ) + return json["list"][0]["definition"].to_s.gsub( /[\[\]]/, "" ).gsub( /(\r|\n)/, " " ) +end + +def getvoice( configdir : String, userdir : String, chatuser : String ) + if File.exists?( userdir + "/voice" ) + voice_output = File.read( userdir + "/voice" ).chomp + voice_setting = voice_output + else + voice_output = File.read( configdir + "/voicelist.txt" ).chomp.split( "\n" ).sample( 1 )[0].chomp + voice_setting = "random" + end + if File.exists?( userdir + "/voicesub" ) + namesub = File.read( userdir + "/voicesub" ).chomp + else + namesub = chatuser + end + return( [namesub, voice_setting, voice_output ] ) +end + def generatevoicelistaws( ) voices = Array(String).new JSON.parse( `aws polly describe-voices` )["Voices"].as_a.each do | v | @@ -230,16 +432,676 @@ def regeneratevoicelist( defaultsettings : Hash( String, String ), aws : Bool, g return voices end -# channel message subscriptions: { service, chan } => [ client, client ] -channelsubs = Hash( Tuple( String, String ), Array( OpenSSL::SSL::Socket::Server ) ).new -# Unencrypted -#connections = Hash(TCPSocket, Hash(String, String)).new -# Encrypted -connections = Hash(OpenSSL::SSL::Socket::Server, Hash(String, String)).new +def playaudiofile( filepath : String ) + p = Process.new( + "powershell.exe", + [ "-Command", "#Set-PSDebug -Trace 1; + Add-Type -AssemblyName presentationCore; + $player = New-Object system.windows.media.mediaplayer; + $player.open(\"#{filepath}\"); + $player.volume = .99; + $player.play(); + Start-Sleep -Milliseconds 1000; + $duration = $player.NaturalDuration.TimeSpan.TotalMilliseconds; + Start-Sleep -Milliseconds ($duration - 1000 ); + "], + output: STDOUT, error: STDERR + ) + # https://geekeefy.wordpress.com/2016/07/19/powershellmediaplayer/ has some ideas + p.wait +end + +def userlog( ircipc : Channel, config : BungmoBott::Config, message : FastIRC::Message ) + unless ( ( prefix = message.prefix ) && ( chatuser = prefix.source ) && ( uid = message.tags["user-id"]? ) ) + return nil + end + basedir = config.statedir + userdir = basedir + "/uids/" + uid + if File.directory?( userdir ) + lastseen = File.info( userdir ).modification_time.to_unix + else + lastseen = 0 + end + Dir.mkdir_p( basedir + "/names" ) + Dir.mkdir_p( userdir + "/names" ) + File.touch( userdir ) + unless testrefuser2uid( userdir + "/names/" + chatuser ) + namelatest = "" + datelatest = Time::UNIX_EPOCH + Dir.each_child( userdir + "/names/" ) do |name| + namedate = File.info( userdir + "/names/" + name ).modification_time + if namedate > datelatest + namelatest = name + datelatest = namedate + end + end + unless namelatest.empty? + ircipc.send( { "##{config.chat_user.not_nil!.twitch}", "Rename detected: #{uid}: #{namelatest} -> #{chatuser}" } ) + end + genrefuser2uid( userdir + "/names/" + chatuser, uid, 3 ) + end + unless testrefuser2uid( basedir + "/names/" + chatuser ) + genrefuser2uid( basedir + "/names/" + chatuser, uid, 1 ) + end + unless ( message.params[0] == "##{config.chat_user.not_nil!.twitch}" ) + return nil + end + return ( { chatuser, uid, userdir, lastseen } ) +rescue ex + puts ex +end + +# IRC say +# does this function have a reason to exist? +def say( ipc : Channel( Tuple( String, String ) ), channel : String, text : String ) + ipc.send( { "#" + channel, text } ) +end + +# Currently only used in flag?(:unix) +def t2smsg( config : BungmoBott::Config, msg : String) + if File.exists?( config.rundir + "/.t2s.sock" ) + sock = Socket.unix + sock.connect Socket::UNIXAddress.new( config.rundir + "/.t2s.sock" ) + sock.puts( msg ) + sock.close + end +rescue ex + puts ex +end + +def t2s( t2sipc : Channel, config : BungmoBott::Config, userdir : String, chatuser : String, text : String ) + if ( text !~ /^ *(!|\|)/ ) + namesub, voice_setting, voice = getvoice( config.voice_list.not_nil!, userdir, chatuser ) + subs = Array( Tuple( Regex, String ) ){ + { /http(s|):\/\/([a-z0-9.-]+)\/[a-zA-Z0-9\/&=%-_]+/, "link to \\2" }, + { /([^a-zA-Z0-9])-/, "\\1 dash "}, + { /\|/, " vertical bar "}, + { /\`/, " grave accent "}, + { /\+/, " plus "}, + { /×/, " multiplied by "}, + { /=/, " equals "}, + { /\//, " slash "}, + { /\\/, " backslash "}, + { /@/, " at "}, + { /&/, " and "}, + { />/, " greater than "}, + { /</, " less than "}, + { /_/, " underscore "}, + { /\.\.\./, " dot dot dot "}, + { /\^/, " circumflex accent "}, + { /\#/, " octothorpe "}, + { /:([^ ])/, " colon \\1"}, + { /;([^ ])/, " semicolon \\1"}, + { /\.([^ ])/, " dot \\1"}, + { /\%([^ ])/, " percent sign \\1"}, + { /!([^ ])/, " tchik \\1"}, + { /([^ ])\$/, "\\1 dollar sign "}, + { /\(/, " open paren "}, + { /\)/, " close paren "}, + { /\{/, " open curly bracket "}, + { /\}/, " close curly bracket "}, + { /\[/, " open square bracket "}, + { /\]/, " close square bracket "}, + { /0/, " zero " }, + { /1/, " one " }, + { /2/, " two " }, + { /3/, " three " }, + { /4/, " four " }, + { /5/, " five " }, + { /6/, " six " }, + { /7/, " seven " }, + { /8/, " eight " }, + { /9/, " nine " }, + { /rrr.+/, "rr" }, + }.each do | subtuple | + text = text.gsub( subtuple[0], subtuple[1] ) + end + {% if flag?(:windows) %} + t2sipc.send( { voice, "#{namesub} #{text}" } ) + {% else %} + t2smsg( config, "#{voice} #{namesub} #{text}" ) + {% end %} + return( voice ) + else + return( nil ) + end +end + +spawn name: "command_dispatch" do + fiberipc.send( Fiber.current ) + loop do + while commandmsg : Tuple( String, FastIRC::Message ) = commandircipc.receive + spawn do + service = String.new + local_commandmsg = commandmsg + if local_commandmsg.is_a?( Tuple( String, FastIRC::Message ) ) && local_commandmsg[0].is_a?( String ) + service = local_commandmsg[0] + message : FastIRC::Message = local_commandmsg[1] + ircchannel = message.params[0] + unless service.empty? + if config.bungmobott_listen && ! ircchannel.empty? + # Do we send to the bungmobott_listen fiber? Probably no need. + #bbssrvipc.send( "#{message.to_s}" ) + if channelsubs[ { service, ircchannel } ]? + channelsubs[ { service, ircchannel } ].each do |channelsub| + if channelsub.is_a? OpenSSL::SSL::Socket::Server + channelsub.puts( "msg twitch #{message.to_s}" ) + # don't think this is ever useful + #else # client.is_a? Channel( Tuple( String, FastIRC::Message ) ) + # client.send( { "twitch", message } ) + end + end + end + end + + next unless ( userlogreturn = userlog( twitchipc, config, message ) ) + chatuser, uid, userdir, lastseen = userlogreturn + if config.voice_list + if ( t2sreturn = t2s( t2sipc, config, userdir, chatuser, message.params[1] ) ) + lastvoice.insert( 0, t2sreturn ) + lastvoice = lastvoice[0..4] + end + else + STDERR.puts "WARNING: config.voice_list empty" + end + # Have we seen this user lately? + if ( ( Time.utc.to_unix - lastseen ) >= 14400 ) + twitchipc.send( { "get_user", uid.to_s } ) + twitchipc.send( { "get_followers", uid.to_s } ) + prevnames = Array( String ).new + if ( prevnames = Dir.children( config.statedir + "/uids/" + uid + "/names" ) ) && ( prevnames.size > 1 ) + prevnames.delete( chatuser ) + puts "\033[38;5;14m#{chatuser} previous names: #{prevnames.join(", ")}\033[0m" + end + # play random fanfare if available. + {% if flag?(:windows) %} + # This file hierarchy gets manually set up for now. + # Maybe someday let mods do something like: + # !fanfare add pipne https://pip.ne/sniff.mp3 + if File.exists?( userdir + "/fanfare/" ) + playaudiofile( userdir + "/fanfare/" + Dir.children( userdir + "/fanfare/" ).sample ) + end + {% else %} + t2smsg( config, "fanfare #{uid} #{chatuser}" ) + {% end %} + end + # FIXME: Generalize this across Twitch/IRC? Mods are +o? vips are +v? + # FIXME: Add configuration interface for this + own = ( message.tags["room-id"] == message.tags["user-id"] ) + vip = ( message.tags["badges"].to_s.matches?( /(^|,)vip\// ) ) + mod = ( message.tags["mod"] == "1" ) + sub = ( message.tags["subscriber"] == "1" ) + # Emote-triggered effects: + # [ { 301501910, "farts" }, + # { 322820, "explosions" } ].each do | fx | + # emoteid = fx[0] + # fxname = fx[1] + # if ( message.tags["emotes"]? ) && + # ( message.tags["emotes"] ) && + # ( fxemotes = message.tags["emotes"].not_nil!.split("/").select( /^#{emoteid}[:_]/ ).join(",").split(",") ) && + # ( ! fxemotes[0].empty? ) && + # ( effects.values.select(/^#{fxname}/).size > 0 ) + # effects.values.select(/^#{fxname}/).sample( fxemotes.size ).each do | filepath | + # obstemporarymediacreate( obs, "meta-foreground", filepath.gsub(/[\/ ]/, '_').downcase, "C:/cygwin64/home/user/effects/#{filepath}" ) + # end + # end + # end + config.commands && config.commands.not_nil!.each do | commandregex, command | # Hash( String, Array ) + if Regex.new( commandregex ).match( message.params[1] ) + command.each do |exec| # Array + if ( + ( own || ( exec.perm && exec.perm.not_nil!.includes?("any") ) ) || + ( mod && ( exec.perm && exec.perm.not_nil!.includes?("mod") ) ) || + ( sub && ( exec.perm && exec.perm.not_nil!.includes?("sub") ) ) || + ( vip && ( exec.perm && exec.perm.not_nil!.includes?("vip") ) ) + ) + if obs + # FIXME: better validate args + ( exec.func == "obs_random_source_enable" ) && obsrandommediaenable( obs, exec.arg.not_nil![0].not_nil! ) && next + # ( exec.func == "obs_stats" ) && obs_stats( obs ) + end + if text2speech + if ( exec.func == "text_to_speech" ) + if ( t2sreturn = t2s( t2sipc, config, userdir, chatuser, message.params[1] ) ) + lastvoice.insert( 0, t2sreturn ) + lastvoice = lastvoice[0..4] + end + next + end + end + # FIXME: add gamesurge support + ( exec.func == "say" ) && say( twitchipc, config.chat_user.not_nil!.twitch.not_nil!, exec.arg.not_nil![0].not_nil! ) && next + STDERR.puts "WARNING: unhandled function for /#{commandregex}/: #{exec.func}" + else + STDOUT.print "DENIED: " + ppe command + end + end + end + end + end + else # String + case local_commandmsg + when "testchannelsubs" + pp channelsubs + end + end +# next unless ( ( match = message.params[1].match(/^ *!([A-Za-z]+) (([a-zA-Z0-9= _\:,.&'\/?;\\\(\)\[\]+\-]|!)+)/) || message.params[1].match(/^ *!([A-Za-z]+)/) ) ) +# cmd = match[1] +# if ( ( cmd =~ /^(substitute|voicesub)$/ ) && ( mod || sub ) ) +# case message.params[1].split( " " ).size +# when 1 +# if File.exists?( userdir + "/voicesub" ) +# bot.message( "##{settings["channel"]}", "| Current name substitution is \"#{File.read( userdir + "/voicesub" )}\"." ) +# else +# bot.message( "##{settings["channel"]}", "| Current name substitution is disabled." ) +# end +# else +# if match[2]? +# voicesub = match[2].downcase +# if voicesub =~ /^(disabled|null|disable|none)$/ +# if File.exists?( userdir + "/voicesub" ) +# File.delete( userdir + "/voicesub" ) +# bot.message( "##{settings["channel"]}", "| Name substitution for #{chatuser} is now disabled." ) +# else +# bot.message( "##{settings["channel"]}", "| Name substitution for #{chatuser} is already disabled." ) +# end +# else +# Dir.mkdir_p( userdir ) +# File.write( userdir + "/voicesub", voicesub ) +# bot.message( "##{settings["channel"]}", "| Name substitution for #{chatuser} is now \"#{File.read( userdir + "/voicesub" )}\"." ) +# end +# end +# end +# elsif ( ( cmd == "lastvoice" ) && ( mod || sub ) ) +# unless lastvoice.empty? +# bot.message( "##{settings["channel"]}", "| Last voices were " + lastvoice.join( ", " ) ) +# else +# bot.message( "##{settings["channel"]}", "| No voices used so far." ) +# end +# elsif ( ( cmd == "regeneratevoicelist" ) && ( own ) ) +# voices = regeneratevoicelist( settings, aws, gcloud ) +# ircipc.send( { "##{settings["channel"]}", "| Regenerated voicelist." } ) +# elsif ( ( cmd =~ /^(setvoice|voice)$/ ) && ( mod || sub ) ) +# case message.params[1].split( " " ).size +# when 1 +# namesub, voice_setting, voice_output = getvoice( config.voice_list_file, userdir, chatuser ) +# bot.message( "##{settings["channel"]}", "| Current voice is #{voice_setting}" ) +# when 2 +# if match[2]? +# voice = match[2].downcase +# if voice =~ /disabled|null|disable|none|random/ +# if File.exists?( userdir + "/voice" ) +# File.delete( userdir + "/voice" ) +# bot.message( "##{settings["channel"]}", "| Voice for #{chatuser} is now random." ) +# else +# bot.message( "##{settings["channel"]}", "| Voice for #{chatuser} is already random." ) +# end +# elsif voices.has_key?( voice ) +# csvoice = voices[voice] +# Dir.mkdir_p( userdir ) +# File.write( userdir + "/voice", csvoice ) +# pp userdir +# bot.message( "##{settings["channel"]}", "| Voice for #{chatuser} is now #{File.read( userdir + "/voice" )}." ) +# else +# pp ( match ) +# bot.message( "##{settings["channel"]}", "| Invalid voice. To see list, use !voices" ) +# end +# end +# when 3 +# else +# end +# elsif ( cmd =~ /^uptime$/ ) +# stats = obs.stats.to_h +# ostatus = obs.outputs["adv_stream"].status.to_h +# ircipc.send( { "##{settings["channel"]}", "| #{ostatus["outputTimecode"].to_s[0..7]} #{stats["activeFps"].to_s[0,2]}fps Usage: #{stats["cpuUsage"].as(Float64).to_i64}% #{stats["memoryUsage"].as(Float64).to_i64}MiB Frame losses: #{stats["outputSkippedFrames"].as(Int64)} #{stats["renderSkippedFrames"].as(Int64)}" } ) +# # !newimage [name] [url] (random|top|bottom|left|right|center) +# # download url, verify mimetype with libmagic, duplicate existing medialoop source, change "file" SourceSetting +# elsif ( ( cmd =~ /^inputsetting(|s)$/ ) && ( mod || own || vip ) ) +# if ( match[2]? && match[2] =~ /^[a-zA-Z0-9-_]+$/ ) +# ircipc.send( { "##{settings["channel"]}", "| #{obs.inputs[match[2]].settings.to_h.to_s} " } ) +# end +# elsif ( ( cmd =~ /^input(|s)$/ ) && ( mod || own || vip ) ) +# ircipc.send( { "##{settings["channel"]}", "| inputs: #{obs.inputs.to_h.keys.join(" ")}" } ) +# elsif ( ( cmd =~ /^scene(|s)$/ ) && ( mod || own || vip ) ) +# if ( match[2]? && match[2] =~ /^[a-zA-Z0-9-_]+$/ ) +# obs.scenes[match[2]].program! +# else +# ircipc.send( { "##{settings["channel"]}", "| scenes: #{obs.scenes.to_h.keys.join(" ")}" } ) +# end +# elsif ( ( cmd =~ /^source(|s)$/ ) && ( mod || own || vip ) ) +# request = Hash( String, String | Bool ).new +# if ( match[2]? && match[2] =~ /^[a-zA-Z0-9-_]+$/ ) +# obs.scenes.current.metascene[match[2]][0].toggle! +# # in studio mode, direct Scene->SceneItem toggles require a transition +# obs.scenes.current.preview! +# obs.transition! +# else +# ircipc.send( { "##{settings["channel"]}", "| current sources: #{obs.scenes.current.metascene.keys.join(" ")}" } ) +# end +# elsif ( ( cmd =~ /^filter(|s)$/ ) && ( mod || own ) ) +# if ( match[2]? ) && ( filterargs = match[2].match( /^([a-zA-Z0-9-_]+) +([a-zA-Z0-9-_]+)/ ) ) +# obs.sources.to_h[filterargs[1]].filters[filterargs[2]].toggle! +# elsif ( match[2]? && match[2] =~ /^[a-zA-Z0-9-_]+$/ ) +# ircipc.send( { "##{settings["channel"]}", "| #{match[2]} filters: #{obs.sources.to_h[match[2]].filters.to_h.keys.join(" ")}" } ) +# else +# ircipc.send( { "##{settings["channel"]}", "Must provide at least one source name as argument, and optionally one filter name to toggle on or off." } ) +# end +# elsif ( cmd == "create" && ( mod || own || vip ) ) +# if ( match[2]? ) && ( match[2] =~ /^([\/a-zA-Z0-9-_]+)/ ) +# obstemporarymediacreate( obs, "meta-foreground", match[2], "C:/cygwin64/home/user/effects/#{match[2]}.webm" ) +# else +# ircipc.send( { "##{settings["channel"]}", "Must provide at least one source name as argument." } ) +# end +# elsif ( cmd =~ /^(metaminute|youdied)$/ ) +# obsrandommediaenable( obs, "media-#{cmd}" ) +# elsif ( cmd =~ /^fart(s|)$/ ) && ( sub || mod || own || vip ) +# if effects.values.select( /^farts/ ).size > 0 +# if ( match[2]? ) && ( match[2].match( /^([0-9]+)/ ) && ( match[2].to_i > 1 ) && ( match[2].to_i <= 32 ) ) +# count = match[2].to_i +# else +# count = 1 +# end +# effects.values.select( /^farts/ ).sample( count ).each do | effect | +# obstemporarymediacreate( obs, "meta-foreground", effect.gsub(/[\/ ]/, '_').downcase, "C:/cygwin64/home/user/effects/#{effect}" ) +# end +# else +# puts "farts undefined" +# end +# elsif ( cmd =~ /^explosion(s|)$/ ) && ( sub || mod || own || vip ) +# if effects.values.select( /^explosions/ ).size > 0 +# if ( match[2]? ) && ( match[2].match( /^([0-9]+)/ ) && ( match[2].to_i > 1 ) && ( match[2].to_i <= 32 ) ) +# count = match[2].to_i +# else +# count = 1 +# end +# effects.values.select( /^explosions/ ).sample( count ).each do | effect | +# obstemporarymediacreate( obs, "meta-foreground", effect.gsub(/[\/ ]/, '_').downcase, "C:/cygwin64/home/user/effects/#{effect}" ) +# end +# else +# puts "explosions undefined" +# end +# # FIXME: This is only half-implemented +# elsif ( ( cmd =~ /^(user)$/ ) && ( mod || own ) ) +# if match[2]? && match[2] =~ /[a-z][a-z0-9_]+/ +# twitchipc.send( { "get_user", match[2] } ) +# elsif match[2]? && match[2] =~ /[0-9]+/ +# twitchipc.send( { "get_user", match[2].to_u64 } ) +# else +# twitchipc.send( { "get_user", settings["channel_id"].to_u64 } ) +# end +# elsif ( ( cmd =~ /^(status|title)$/ ) && ( mod || own ) ) +# if match[2]? +# client.put_channel!( settings["channel_id"].to_u64, title: match[2] ) +# json = JSON.parse( client.get_channel( settings["channel_id"].to_u64 ) ) +# ircipc.send( { "##{settings["channel"]}", "Title is now \"#{ json["data"][0]["title"] }\""} ) +# else +# json = JSON.parse( client.get_channel( settings["channel_id"].to_u64 ) ) +# ircipc.send( { "##{settings["channel"]}", "| Title is currently \"#{ json["data"][0]["title"] }\""} ) +# end +# elsif ( ( cmd =~ /^(game|category)$/ ) && ( mod || own ) ) +# if match[2]? +# puts "2 matches" +# client.put_channel!( settings["channel_id"].to_u64, game: match[2] ) +# json = JSON.parse( client.get_channel( settings["channel_id"].to_u64 ) ) +# ircipc.send( { "##{settings["channel"]}", "Game is now \"#{ json["data"][0]["game_name"] }\""} ) +# else +# puts "1 matches" +# json = JSON.parse( client.get_channel( settings["channel_id"].to_u64 ) ) +# ircipc.send( { "##{settings["channel"]}", "| Game is currently \"#{ json["data"][0]["game_name"] }\""} ) +# end +# elsif ( ( cmd == "urban" ) && ( mod || own || sub || vip ) ) +# if match[2]? && match[2] =~ /^([a-zA-Z0-9 -])+$/ +# definition = urbandef( match[2] ) +# ircipc.send( { "##{settings["channel"]}", definition[0,400] } ) +# t2s( t2sipc, settings, userdir, chatuser, definition[0,400] ) +# else +# ircipc.send( { "##{settings["channel"]}", "| Urban Dictionary search term should consist of letters, numbers, spaces, and/or hyphens." } ) +# end +# elsif ( cmd == "matrix" ) +# effectsmsg( settings, "overlay glmatrix" ) +# elsif ( cmd =~ /juggle|juggler/ ) +# effectsmsg( settings, "overlay juggler3d" ) +# elsif ( cmd =~ /fireworks|firework/ ) +# effectsmsg( settings, "overlay fireworkx" ) +# elsif ( cmd == "pipes" ) +# if match[2]? && match[2] =~ /^(fast|faster)$/ +# effectsmsg( settings, "overlay pipes " + match[2] ) +# else +# effectsmsg( settings, "overlay pipes" ) +# end +# elsif ( cmd == "jellyfish" ) +# effectsmsg( settings, "overlay hydrostat" ) +# elsif ( cmd == "gluten" ) +# effectsmsg( settings, "overlay flyingtoasters" ) +# elsif ( cmd =~ /^(glsnake|glmatrix|gibson|xmatrix|flyingtoasters|moebiusgears|fireworkx|hydrostat|hypertorus|jigsaw|juggler3d|kaleidocycle|kumppa|molecule|noof|polyhedra)$/ ) +# effectsmsg( settings, "overlay " + cmd ) +# elsif ( cmd =~ /gltext|cowsay|xcowsay|cowfuscious/ ) +# ( cmd == "cowfuscious" ) && ( cmd = "xcowsay" ) +# if ( match[2]? ) && ( gltextargs = match[2].match( /^([0-9]+) +(.+)$/ ) ) +# seconds=UInt64.new( 1 ) +# seconds=gltextargs[1].to_u64 +# if ( own || mod || vip ) +# effectsmsg( settings, "overlay #{cmd} #{match[2]}" ) +# puts "matched #{cmd} #{match[2]}" +# elsif ( sub ) +# if ( seconds > 20 ) +# seconds=20 +# end +# effectsmsg( settings, "overlay #{cmd} #{seconds} #{gltextargs[2]}" ) +# puts "matched #{cmd} #{seconds} #{gltextargs[2]}" +# else +# if ( seconds > 5 ) +# seconds=5 +# end +# effectsmsg( settings, "overlay #{cmd} #{seconds} #{gltextargs[2]}" ) +# puts "matched #{cmd} #{seconds} #{gltextargs[2]}" +# end +# elsif match[2]? && match[2] =~ /^.+$/ +# effectsmsg( settings, "overlay #{cmd} #{match[2]}" ) +# puts "matched #{cmd} #{match[2]}" +# else +# effectsmsg( settings, "overlay #{cmd}" ) +# puts "failed to match gltext" +# end +# elsif ( cmd =~ /^(cow(s|)|cowabunga|holycow$)/ ) +# if match[2]? && match[2] =~ /^([0-9])+$/ +# effectsmsg( settings, "overlay bouncingcow #{match[2]}" ) +# else +# effectsmsg( settings, "overlay bouncingcow" ) +# end +# elsif ( cmd == "overlay" ) +# if match[2]? && match[2] =~ /^[a-z]+$/ +# ircipc.send( { "##{settings["channel"]}", "| overlay requires an argument consisting wholly of lower case characters."} ) +# effectsmsg( settings, "overlay #{match[2]}" ) +# end +# elsif ( cmd =~ /^(shout|shoutout)$/ ) +# if match[2]? && match[2] =~ /^[a-z]+$/ +# ircipc.send( { "##{settings["channel"]}", "| Go check out twitch.tv/#{match[2]}"} ) +# effectsmsg( settings, "overlay gltext 5 Go follow #{match[2]}" ) +# else +# ircipc.send( { "##{settings["channel"]}", "| Missing argument."} ) +# end +# elsif ( cmd =~ /^(system|dxdiag|computer)$/ ) && ( Crystal::DESCRIPTION =~ /linux/ ) +# ircipc.send( { "##{settings["channel"]}", "| https://bungmonkey.omgwallhack.org/tmp/DxDiag.txt" } ) +# elsif ( cmd == "hackerman" ) +# ircipc.send( { "##{settings["channel"]}", "| https://bungmonkey.omgwallhack.org/img/hackerman.jpg" } ) +# elsif ( cmd =~ /^(songrequest|sr)$/ ) && match[2]? +# puts ("song detected: #{match[2]}") +# if ( ( match[2] =~ /list=/ ) && ( match[2] !~ /v=/ ) ) +# ircipc.send( { "##{settings["channel"]}", "| Lists are not accepted.\n" } ) +# elsif Process.run( "sraddsong.sh", {match[2]} ) +# m = MPD::Client.new +# currentsong = m.currentsong +# if ( currentsong ) && ( currentsong["file"].to_s == "http://music/music.ogg" ) +# m.next +# end +# if ( status = m.status ) && ( playlistinfo = m.playlistinfo ) +# ircipc.send( { "##{settings["channel"]}", "| " + playlistinfo[ status["playlistlength"].to_i - 1 ]["file"].to_s + " added in position " + status["playlistlength"].to_s } ) +# else +# ircipc.send( { "##{settings["channel"]}", "| A failure occured." } ) +# end +# m.disconnect +# else +# end +# elsif ( cmd =~ /^current(|song)$/ ) +# m = MPD::Client.new +# if ( currentsong = m.currentsong ) +# ircipc.send( { "##{settings["channel"]}", "| Currently playing: " + currentsong["file"].to_s } ) +# else +# ircipc.send( { "##{settings["channel"]}", "| A failure occured." } ) +# end +# m.disconnect +# elsif ( cmd =~ /^seek$/ ) +# if ( ( match[2] ) && ( match[2] =~ /([+-]|)[0-9]/ ) ) +# m = MPD::Client.new +# m.seekcur( match[2] ) +# if ( ( musicstatus = m.status ) && ( pos = musicstatus["elapsed"].to_f.to_u64 ) ) +# min=( pos / 60 ).to_u64 +# sec=( pos % 60 ).to_u64 +# ircipc.send( { "##{settings["channel"]}", "| " + sprintf( "2%d:2%d", min, sec ) } ) +# else +# ircipc.send( { "##{settings["channel"]}", "| An error occurred. " } ) +# end +# m.disconnect +# else +# ircipc.send( { "##{settings["channel"]}", "| Seek requires an argument of an absolute position in integer number of seconds, or a relative position in in signed integer number of seconds such as +60" } ) +# end +# elsif ( cmd =~ /^next(|song)$/ ) +# m = MPD::Client.new +# m.next +# if ( status = m.status ) && ( status["playlistlength"].to_i > 0 ) +# if ( currentsong = m.nextsong ) +# ircipc.send( { "##{settings["channel"]}", "| Currently playing: " + currentsong["file"].to_s } ) +# else +# ircipc.send( { "##{settings["channel"]}", "| A failure occured." } ) +# end +# else +# ircipc.send( { "##{settings["channel"]}", "| Playlist is now empty." } ) +# end +# m.disconnect +# elsif ( cmd == "followage" ) +# if match[2]? +# args = match[2].split(/\s/) +# if args[1]? +# json = JSON.parse( client.get_user_follows( from: client.user_id( args[0] ).to_u64 , to: client.user_id( args[1] ).to_u64 ) ) +# puts client.user_id( args[0] ).to_s +# puts client.user_id( args[1] ).to_s +# puts json +# ircipc.send( { "##{settings["channel"]}", "| " + json["data"][0]["followed_at"].to_s } ) +# elsif args[0]? +# json = JSON.parse( client.get_user_follows( from: client.user_id( args[0] ).to_u64 , to: settings["channel_id"].to_u64 ) ) +# puts client.user_id( args[0] ).to_s +# puts json +# ircipc.send( { "##{settings["channel"]}", "| " + json["data"][0]["followed_at"].to_s } ) +# end +# else +# json = JSON.parse( client.get_user_follows( from: uid.to_u64 , to: settings["channel_id"].to_u64 ) ) +# puts json +# ircipc.send( { "##{settings["channel"]}", "| " + json["data"][0]["followed_at"].to_s } ) +# end +# end + rescue ex + puts ex + puts ex.backtrace + if service == "twitch" + say( twitchipc, config.chat_user.not_nil!.twitch.not_nil!, "An error occurred! " + ex.message.to_s ) + elsif service == "gamesurge" + say( ircipc, config.chat_user.not_nil!.gamesurge.not_nil!, "An error occurred! " + ex.message.to_s ) + else + puts "...also, the chat service is undefined." + end + end + + end + end +ensure + waitgroup.send( Fiber.current.name.not_nil! ) +end +fiber = fiberipc.receive +fibers[fiber.name.not_nil!] = fiber + + +# Put tts stuff into the same thread so each playback blocks the next +spawn name: "text2speech" do + fiberipc.send( Fiber.current ) + loop do + begin + while t2stuple = t2sipc.receive + voice, text = [ *t2stuple ] + if ( match = voice.match( /^Microsoft-([A-Za-z]+)/ ) ) + if ( match[1] =~ /Lili|Mary|Mike|Sam|Anna/ ) + msttsvoice="Microsoft #{match[1]}" + else + msttsvoice="Microsoft #{match[1]} Desktop" + end + p = Process.new( + "powershell.exe", + [ "-Command", " + Add-Type -AssemblyName System.Speech; + $speak = New-Object System.Speech.Synthesis.SpeechSynthesizer; + $speak.SelectVoice(\"#{msttsvoice}\"); + $speak.Speak($Input); + $speak.Finalize; + "], + input: Process::Redirect::Pipe, output: STDOUT + ) + p.input.puts text + p.input.close + p.wait + elsif gcloud && ( match = voice.match( /^([a-zA-Z]{2,3}-[a-zA-Z]{2})/ ) ) # Google cloud voice + request = Hash( String, Hash( String, String ) ){ + "input" => { "text" => text }, + "audioConfig" => { "audioEncoding" => "MP3" }, + "voice" => { + "name" => voice, + "languageCode" => match[1], + }, + } + ssl_context = OpenSSL::SSL::Context::Client.new + #ssl_context.verify_mode = OpenSSL::SSL::VerifyMode::NONE + + headers = HTTP::Headers.new + headers["Content-Type"] = "application/json; charset=utf-8" + + response = HTTP::Client.exec( "POST", "https://texttospeech.googleapis.com/v1/text:synthesize?key=#{secrets.gcloud_token}", headers, request.to_json, tls: ssl_context ) + + response.body + + filepath="#{config.tempdir}#{Time.utc.to_unix_ms}.mp3" + json=JSON.parse(response.body) + File.write( filepath, Base64.decode_string( json["audioContent"].as_s ) ) + playaudiofile( filepath ) + File.delete( filepath ) + elsif aws # AWS polly voices + filepath="#{config.tempdir}#{Time.utc.to_unix_ms}.mp3" + p = Process.new( + "aws.exe", [ + "polly", "synthesize-speech", + "--output-format", "mp3", + "--voice-id", voice, + "--text", text, + filepath + ], output: STDOUT, error: STDERR + ) + p.wait + playaudiofile( filepath ) + File.delete( filepath ) + else # unknown + STDERR.puts "Voice not recognized or available." + end + end + rescue ex + puts ex + end + end +ensure + waitgroup.send( Fiber.current.name.not_nil! ) +end +fiber = fiberipc.receive +fibers[fiber.name.not_nil!] = fiber + -ircipc = Channel( Tuple( String, String ) ).new -t2sipc = Channel( Tuple( String, String ) ).new -twitchipc = Channel( Tuple( String, Union( String, UInt64 ) ) ).new # Twitch API request handling thread #spawn do @@ -271,8 +1133,9 @@ twitchipc = Channel( Tuple( String, Union( String, UInt64 ) ) ).new # if ( secrets.twitch_access_token && config.chat_user.not_nil!.twitch && config.join_channels.not_nil!.twitch ) - # IRC thread - spawn do + # Twitch::IRC thread + spawn name: "Twitch::IRC" do + fiberipc.send( Fiber.current ) loop do begin bot = Twitch::IRC::Client.new( nick: config.chat_user.not_nil!.twitch.not_nil!, token: "oauth:" + secrets.twitch_access_token.not_nil!, log_mode: true ) @@ -282,7 +1145,7 @@ if ( secrets.twitch_access_token && config.chat_user.not_nil!.twitch && config.j # "Most IRC servers limit messages to 512 bytes in length, including the trailing CR-LF characters." # PRIVMSG #channel message\r\n spawn do - while tuple = ircipc.receive # why does this need to be a tuple? + while tuple = twitchipc.receive # why does this need to be a tuple? sizelimit=( 512 - ( tuple[0].size + 12 ) ) if ( tuple[0] == "JOIN" ) if ( tuple[0] =~ regextwitchuser ) @@ -299,7 +1162,7 @@ if ( secrets.twitch_access_token && config.chat_user.not_nil!.twitch && config.j # Create a handler to process incoming messages bot.on_message do |message| spawn do - #Message( + #FastIRC::Message( # @tags={ # "badge-info" => "", # "badges" => "moderator/1,bits/100", @@ -330,11 +1193,17 @@ if ( secrets.twitch_access_token && config.chat_user.not_nil!.twitch && config.j # ] #) - channelsubs[{ "twitch", message.params[0] }].each do | client | - if ( ( prefix = message.prefix ) && ( chatuser = prefix.source ) ) # && ( uid = message.tags["user-id"]? ) - client.puts "msg twitch #{message.params[0]} #{chatuser} #{message.params[1]}" - end - end +# channelsubs[{ "twitch", message.params[0] }].each do | client | +# if ( ( prefix = message.prefix ) && ( chatuser = prefix.source ) ) # && ( uid = message.tags["user-id"]? ) +# if client.is_a? OpenSSL::SSL::Socket::Server +# client.puts( "msg twitch #{message.params[0]} #{chatuser} #{message.params[1]}" ) +# else # client.is_a? Channel( Tuple( String, FastIRC::Message ) ) +# client.send( { "twitch", message } ) +# end +# end +# end + + commandircipc.send( { "twitch", message } ) pp message pp message.params own = ( message.tags["room-id"] == message.tags["user-id"] ) @@ -343,13 +1212,13 @@ if ( secrets.twitch_access_token && config.chat_user.not_nil!.twitch && config.j sub = ( message.tags["subscriber"] == "1" ) rescue ex puts ex - #ircipc.send( { "##{config.channel}", "An error occurred! " + ex.message.to_s } ) + #twitchipc.send( { "##{config.channel}", "An error occurred! " + ex.message.to_s } ) # Maybe send all error messages out through the API? Have to do channel->client mappings, though. end end rooms = Array( String ).new - rooms = config.join_channels.not_nil!.twitch.not_nil! + #rooms = config.join_channels.not_nil!.twitch.not_nil! # Connect to Twitch bot.run( rooms.map{ | room | room.sub( /^#/, "") } ) @@ -366,12 +1235,65 @@ if ( secrets.twitch_access_token && config.chat_user.not_nil!.twitch && config.j exit 1 end end + ensure + waitgroup.send( Fiber.current.name.not_nil! ) end + fiber = fiberipc.receive + fibers[fiber.name.not_nil!] = fiber end -if config.listen - begin - ip, port = config.listen.not_nil!.split(":") +# BungmoBott::Socket client thread +if config.bungmobott_connect + bbscli_host, bbscli_port = config.bungmobott_connect.not_nil!.split(":") + puts "spawning BungmoBott::Socket client" + spawn name: "BungmoBott::Socket client" do + loop do + puts "looping BungmoBott::Socket client" + user = config.chat_user.not_nil!.twitch.not_nil! + bungmobott_key = secrets.bungmobott_key.not_nil! + fiberipc.send( Fiber.current ) + socket = TCPSocket.new( bbscli_host, bbscli_port.to_u16 ) + context = OpenSSL::SSL::Context::Client.new + ssl_socket = OpenSSL::SSL::Socket::Client.new( socket, context ) + ssl_socket.sync = true + negotiated = false + spawn do + while input = bbscliipc.receive + # ssl_socket gets redefined in the event of I/O errors, so we deal with it here. + #if ( climsg = input.match( /^irc +twitch +JOIN \#+([a-zA-Z0-9_]+) *$/ ) ) + #end + ssl_socket.puts( input ) + end + end + ssl_socket.puts( "auth #{user} #{bungmobott_key}" ) + while message = ssl_socket.gets + puts "BungmoBott::Socket cli recv: " + message.gsub( bungmobott_key, "CENSORED" ) + case message + when /^error/ + raise Exception.new("BungmoBott::Socket Error: #{message}") + when /^authed/ + negotiated = true + ssl_socket.puts( "say twitch #{user} test" ) + when /^msg twitch$/ + commandircipc.send( { "twitch", FastIRC.parse_line( message.split(" ")[2..].join(" ") ) } ) + end + end + end + rescue ex + pp ex + ensure + waitgroup.send( Fiber.current.name.not_nil! ) + sleep 2 + end + fiber = fiberipc.receive + fibers[fiber.name.not_nil!] = fiber +end + +# BungmoBott::Socket thread +if config.bungmobott_listen + spawn name: "BungmoBott::Socket server" do + fiberipc.send( Fiber.current ) + ip, port = config.bungmobott_listen.not_nil!.split(":") tcp_server = TCPServer.new( ip, port.to_i ) ssl_context = OpenSSL::SSL::Context::Server.new ssl_context.private_key=(configdir + "/privkey.pem" ) @@ -385,6 +1307,7 @@ if config.listen # bungmobott protocol server #while tcp_server.accept? do | clientsocket | + while clientsocket = tcp_server.accept? spawn do client = OpenSSL::SSL::Socket::Server.new(clientsocket, ssl_context) @@ -396,20 +1319,26 @@ if config.listen connections[client]["authed"] = "false" while message = client.gets - puts message - client.puts message + if ( match = message.match( /^auth (#{regexuser}) (#{regexb64})$/i ) ) + puts "auth #{match[1]} CENSORED" + else + puts message + end + client.puts "RECEIVED " + message if ( connections[client]["authed"] == "true" ) # irc - if ( match = message.match( /^irc (#{regexservice}) (#{regexuser})$/i ) ) - ircservice = match[1] + if ( match = message.match( /^irc (#{regexservice}) JOIN \#(#{regexuser}) *$/i ) ) + ircservice = match[2] # regexservice has some parens, too ircchannel = match[3] - client.puts "joining #{ircservice} #{ircchannel}" - ircipc.send( { "JOIN", ircchannel } ) - unless channelsubs[ { ircservice, ircchannel } ]? - channelsubs[ { ircservice, "#" + ircchannel } ] = Array( OpenSSL::SSL::Socket::Server ).new + if ircservice == "twitch" + client.puts "joining #{ircservice} \##{ircchannel}" + twitchipc.send( { "JOIN", ircchannel } ) + unless channelsubs[ { ircservice, ircchannel } ]? + channelsubs[ { ircservice, "#" + ircchannel } ] = Array( OpenSSL::SSL::Socket::Server ).new + end + channelsubs[ { ircservice, "#" + ircchannel } ].push( client ) + pp channelsubs end - channelsubs[ { ircservice, "#" + ircchannel } ].push( client ) - pp channelsubs elsif ( match = message.match( /^awst2s (#{regexvoice}) (.+)/i ) ) # FIXME # powershell doesn't take bytestreams; maybe use http file hosting for this? elsif ( match = message.match( /^gcst2s (#{regexvoice}) (.+)/i ) ) @@ -418,12 +1347,15 @@ if config.listen client.puts "awsvoicelist " + generatevoicelistaws().join(" ") elsif ( match = message.match( /^gcsvoicelist$/i ) ) client.puts "gcsvoicelist " + generatevoicelistgcs( secrets.gcloud_token ).join(" ") + elsif ( match = message.match( /^say twitch (.+)/i ) ) + say( twitchipc, connections[client]["user"], match[1] ) + elsif ( message =~ /testchannelsubs/ ) + #commandircipc.send( "testchannelsubs" ) end else # auth if ( match = message.match( /^auth (#{regexuser}) (#{regexb64})$/i ) ) - pp match remoteuser = match[1] remotekey = match[2] if File.exists?( config.statedir + "apikeys/" + remoteuser ) @@ -431,6 +1363,7 @@ if config.listen puts "comparing #{localkey} to #{remotekey}" if ( localkey == remotekey ) connections[client]["authed"] = "true" + puts "authed #{ remoteuser }" client.puts "authed #{ remoteuser }" connections[client]["user"] = remoteuser connections[client]["key"] = remotekey @@ -463,6 +1396,45 @@ if config.listen end rescue ex puts ex + ensure + waitgroup.send( Fiber.current.name.not_nil! ) end + fiber = fiberipc.receive + fibers[fiber.name.not_nil!] = fiber +end + +if config.join_channels && config.join_channels.not_nil!.twitch + spawn name: "join_channels" do + fiberipc.send( Fiber.current ) + if fibers["Twitch::IRC"]? + ircservice = "twitch" + config.join_channels.not_nil!.twitch.not_nil!.each do |ircchannel| + twitchipc.send( { "JOIN", ircchannel } ) + unless channelsubs[ { ircservice, ircchannel } ]? + channelsubs[ { ircservice, "#" + ircchannel } ] = Array( OpenSSL::SSL::Socket::Server ).new + # Do we ever care about this? + #channelsubs[ { ircservice, "#" + ircchannel } ] = Array( OpenSSL::SSL::Socket::Server | Channel( Tuple( String, FastIRC::Message ) ) ).new + end + end + elsif fibers["BungmoBott::Socket client"]? + ircservice = "twitch" + config.join_channels.not_nil!.twitch.not_nil!.each do |ircchannel| + bbscliipc.send( "irc twitch JOIN \#" + ircchannel ) + end + end + ensure + waitgroup.send( Fiber.current.name.not_nil! ) + end + fiber = fiberipc.receive + fibers[fiber.name.not_nil!] = fiber +end + +puts "Spawned fibers:" +pp fibers + +fibers.size.times do + fiber = waitgroup.receive + fibers.delete( fiber ) + puts "Fiber ended: " + fiber end |