tinyirc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f53a83ec7e535488a81897bb2d3d5cfa50aa0f61ecc975e102602be4d8dfe1ff
+  data.tar.gz: 631e9d17e0f40eedfb0613814f732ca80b9244c6432a739a59764d35a0bc3006
+SHA512:
+  metadata.gz: ccc01076e7c3751b070b231adb11fb1adcd0cc2715e503617c7eb058cebd8c6233daf4149b46e69e6dbcc9ba5614e50330e726278a630b902099781bb88dc88c
+  data.tar.gz: 55ded6b6debcdaa5b29763a01ad72ee4ba3e7703525a874e8a70061b706ece5a8a6ea757ef934925fd162c698da6a5bc4e13a7e6064c0b3a5c802fd3758e4c18

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/tinyirc.yaml
+/tinyirc.db

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in tinyirc.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    tinyirc (0.1.0)
+      particlecmd (~> 0.1)
+      particlelog (~> 0.1)
+      sinatra (~> 2.0)
+      sqlite3 (~> 1.3)
+      thin (~> 1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    daemons (1.2.6)
+    eventmachine (1.2.5)
+    mustermann (1.0.2)
+    particlecmd (0.1.4)
+    particlelog (0.1.1)
+    rack (2.0.4)
+    rack-protection (2.0.1)
+      rack
+    rake (10.5.0)
+    sinatra (2.0.1)
+      mustermann (~> 1.0)
+      rack (~> 2.0)
+      rack-protection (= 2.0.1)
+      tilt (~> 2.0)
+    sqlite3 (1.3.13)
+    thin (1.7.2)
+      daemons (~> 1.0, >= 1.0.9)
+      eventmachine (~> 1.0, >= 1.0.4)
+      rack (>= 1, < 3)
+    tilt (2.0.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  rake (~> 10.0)
+  tinyirc!
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Nickolay Ilyushin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# Tinyirc
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'particlecmd'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install particlecmd
+```
+
+## Usage
+
+Sample config file:
+
+```yaml
+plugins:
+  path/to/plugin: # The same path as in the `require` function
+    # This table can be empty if you want to load the plugin without configuring it
+    # Plugins may require some values from this table though
+    # You can always load plugins from installed gems (if you are using bundler)
+    foo: bar
+
+groups:
+  world: # All users belong to this group
+    include: # Includes permissions from listed groups into the current one
+      - plugin/world
+    perms:
+      - core/flushq
+  admin: # Admins have this group
+    include:
+      - world
+      - plugin/admin
+  owner: # Owners have this group
+    include:
+      - admin
+      - plugin/owner
+
+cooldowns:
+  plugin: 30 # Sets cooldown for plugin/*/* commands to 30 seconds
+  plugin/command: 20 # Sets cooldown for plugin/command/* commands to 20 seconds
+  plugin/command/branch: 10 # Sets cooldown for plugin/command/branch command to 10 seconds
+
+servers:
+  freenode:
+    host: irc.freenode.net
+    port: 6667
+
+    nick: YourNicknameHere
+    user: YourUsernameHere
+    pass: YourPasswordHere
+    rnam: YourRealnameHere
+
+    prefix: '@'
+
+    autojoin:
+      - '#botters-test'
+```
+
+To start the bot, simply execute:
+
+```bash
+$ bundler exec tinyirc -c /path/to/config.yaml -d /path/to/db.db # both options are optional
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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/handicraftsman/tinyirc.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

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

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'tinyirc'
+require 'optparse'
+
+options = {
+  :cfg => './tinyirc.yaml',
+  :db => './tinyirc.db'
+}
+
+OptionParser.new do |o|
+  o.banner = 'Usage: tinyirc [OPTIONS]'
+
+  o.on '-cFILE', '--config=FILE', 'Path to the config list' do |p|
+    options[:cfg] = p
+  end
+
+  o.on '-dFILE', '--db=FILE', 'Path to the database file' do |p|
+    options[:db] = p
+  end
+end.parse!
+
+bot = TinyIRC::Bot.new(options[:cfg], options[:db])
+bot.start

data/lib/tinyirc/app.rb

@@ -0,0 +1,77 @@
+class TinyIRC::AppLogger
+  class << self
+    attr_accessor :log
+  end
+
+  @log = ParticleLog.new('web', ParticleLog::IO)
+  @log.level_table[ParticleLog::IO] = 'REQ'
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    @start = Time.now
+    @status, @headers, @body = @app.call(env)
+    @duration = ((Time.now - @start).to_f * 1000).round(2)
+
+    TinyIRC::AppLogger.log.io "#{env['REMOTE_ADDR']} --- #{env['REQUEST_METHOD']} #{env['REQUEST_PATH']} --- #{@duration} ms"
+
+    [@status, @headers, @body]
+  end
+end
+
+class TinyIRC::App < Sinatra::Application
+  class << self
+    attr_accessor :bot
+  end
+
+  use TinyIRC::AppLogger
+
+  def self.cfg(bot)
+    TinyIRC::App.bot = bot
+    configure do
+      disable :show_exceptions
+
+      set :clean_trace, true
+
+      set :public_folder, File.dirname(__FILE__) + '/public'
+      set :views, File.dirname(__FILE__) + '/views'
+
+      set :bind, ENV['HOST'] || '0.0.0.0'
+      set :port, (ENV['PORT'] || 8080).to_i
+    
+      disable :logging
+    end
+  end
+
+  helpers do
+    def h(text)
+      Rack::Utils.escape_html(text)
+    end
+  end
+
+  get '/' do
+    @pagename = 'Groups'
+    erb :index, layout: :layout
+  end
+
+  get '/favicon.ico' do 404 end
+
+  get '/:plugin' do
+    @pagename = params['plugin']
+    @plugin = TinyIRC::App.bot.plugins[params['plugin']]
+    raise RuntimeError, "Cannot find plugin `#{params['plugin']}`" unless @plugin
+    erb :plugin, layout: :layout
+  end
+
+  error 404 do
+    @page = '404'
+    erb :'404', layout: :layout
+  end
+
+  error do
+    @page = '500'
+    erb :'500', layout: :layout
+  end
+end

data/lib/tinyirc/bot.rb

@@ -0,0 +1,363 @@
+class TinyIRC::Bot
+  class << self
+    attr_accessor :log
+  end
+
+  attr_accessor(
+    :config_file,
+    :config,
+    :sockets,
+    :plugins,
+    :groups,
+    :prefix,
+    :db,
+    :config_mtx,
+    :log
+  )
+
+  def initialize(config_file, db_file)
+    @config_file = config_file
+    
+    @sockets = {}
+    @plugins = {}
+    @groups  = {}
+
+    @log = ParticleLog.new 'bot', ParticleLog::INFO
+    @log.important 'Hello, IRC!'
+    
+    @db = SQLite3::Database.open db_file
+    @db.execute <<~SQL
+      CREATE TABLE IF NOT EXISTS groupinfo (
+        server VARCHAR(32),
+        host VARCHAR(64),
+        name VARCHAR(32)
+      );
+    SQL
+    @log.info "db = #{db_file}"
+
+    @config_mtx = Mutex.new
+
+    load_config
+  end
+
+  def load_config
+    @config_mtx.synchronize do
+      @config = YAML.parse_file(@config_file).to_ruby
+      @prefix = @config['prefix'] || '!'
+      @log.info "prefix = #{@prefix}"
+
+      load_plugin_config
+      load_group_config
+      load_cooldown_config
+      load_server_config
+    end
+  end
+
+  def reload
+    @config_mtx.synchronize do
+      @plugins = {}
+      @config = YAML.parse_file(@config_file).to_ruby
+      @prefix = @config['prefix'] || '!'
+      @log.info "prefix = #{@prefix}"
+
+      load_plugin_config
+      load_group_config
+      load_cooldown_config
+      load_server_config
+    end
+  end
+
+  def load_plugin_config
+    plugin_config = { "tinyirc/plugins/core" => nil }.merge(@config['plugins'] || {})
+
+    def add(full, name)
+      n = File.basename(name)
+      if @plugins.include? n
+        @log.error "Cannot have multiple plugins with same basename (#{n})"
+      else
+        @plugins[n] = TinyIRC::Plugin.new self, full
+      end
+    end
+
+    def remove(name)
+      @plugins.delete name
+    end
+
+    pkeys = {}
+    plugin_config.keys.each do |k|
+      pkeys[File.basename(k)] = k
+    end
+    
+    (@plugins.keys - pkeys.keys).each do |k|
+      @plugins[k].log.info 'Destroying...'
+      remove k
+    end
+
+    (pkeys.keys - @plugins.keys).each do |k|
+      add pkeys[k], k
+    end
+
+    @plugins.each_pair do |k, v|
+      cfg = plugin_config[k] || {}
+      raise RuntimeError, 'Invalid config type' if cfg.class != Hash
+      v._l_config(cfg)
+      unless v.loaded
+        v._l_postinit
+      end
+    end
+  end
+
+  def load_group_config
+    @groups = {}
+
+    group_config = {
+      "world" => {},
+      "admin" => {}
+    }.merge(@config['groups'] || {})
+
+    def add_group(name, group_config)
+      raise RuntimeError, 'User-defined group names cannot contain slashes!' if name.index '/'
+      g = TinyIRC::Group.new name
+      (group_config[name]['include'] || []).each do |g2|
+        if g2.index '/'
+          g2p, _ = *g2.split('/', 2)
+          unless @plugins.include? g2p
+            @log.error "There's no plugin called `#{g2p}`"
+            next
+          end
+          unless @plugins[g2p].groups.include? g2
+            @log.error "Plugin `#{g2p}` does not have group `#{g2}`"
+            next
+          end
+          @plugins[g2p].groups[g2].perms.each do |perm|
+            g.perm(perm.plugin, perm.command, perm.branch)
+          end
+        else
+          unless @groups.include? g2
+            @log.error "There's no group called `#{g2}`"
+            next
+          end
+          @groups[g2].perms.each do |perm|
+            g.perm(perm.plugin, perm.command, perm.branch)
+          end
+        end 
+      end
+      (group_config[name]['perms'] || []).each do |perm|
+        g.perm *TinyIRC::Permission.parse(perm)
+      end
+      @groups[name] = g
+    end
+
+    def add(name, group_config)
+      add_group(name, group_config)
+    end
+
+    def remove(name)
+      @groups.delete name
+    end
+
+    (@groups.keys & group_config.keys).each do |k|
+      add_group(k, group_config)
+    end
+
+    (@groups.keys - group_config.keys).each do |k|
+      remove k
+    end
+
+    (group_config.keys - @groups.keys).each do |k|
+      add(k, group_config)
+    end
+  end
+
+  def load_cooldown_config
+    cooldown_config = @config['cooldowns'] || {}
+
+    l = ParticleLog.new('cooldowns', ParticleLog::INFO)
+
+    cooldown_config.each_pair do |cmd, cld|
+      cld = cld.to_i
+      a = cmd.split('/', 3)
+      if !a[0] || !a[1] && a[2]
+        l.error "Invalid command entry: #{cld}"
+        next
+      end
+      pname = a[0]
+      command = a[1] || :all
+      branch = a[2] || :all
+      unless @plugins.include? pname
+        l.error "There's no plugin called `#{pname}`"
+        next
+      end
+      plugin = @plugins[pname]
+      upd = lambda do |command|
+        if branch == :all
+          command.branches.each_pair do |_, b|
+            b.cooldown = cld
+            l.info "#{pname}/#{command.name}/#{b.id} <- #{cld}s"
+          end
+        else
+          unless command.branches.include? branch
+            l.error "`#{pname}/#{command.name}` command does not have branch called `#{branch}`"
+            next
+          end
+          command.branches[branch].cooldown = cld
+          l.info "#{pname}/#{command.name}/#{branch} <- #{cld}s"
+        end
+      end
+      if command == :all
+        plugin.commands.each_pair do |_, cmd|
+          upd.(cmd)
+        end
+      else
+        unless plugin.commands.include? command
+          l.error "`#{pname}/#{command}` command does not have branch called `#{branch}`"
+          next
+        end
+        upd.(plugin.commands[command])
+      end
+    end
+  end
+
+  def load_server_config
+    server_config = @config['servers'] || {}
+
+    def add(name, cfg)
+      s = TinyIRC::IRCSocket.new(self, name, cfg)
+      Thread.new { s.connect }
+      @sockets[name] = s
+    end
+
+    def remove(name)
+      @sockets[name].mtx.synchronize do
+        @sockets.delete(name).disconnect
+      end
+    end
+
+    (@sockets.keys & server_config.keys).each do |k|
+      s = @sockets[k]
+      c = server_config[k]
+      Thread.new do
+        #s.mtx.synchronize do
+          should_restart = false
+          should_restart = true if s.host != c['host']
+          should_restart = true if s.port != c['port']
+          should_restart = true if s.user != c['user']
+          should_restart = true if s.rnam != c['rnam']
+
+          s.disconnect if should_restart
+          
+          s.host = c['host']
+          s.port = c['port']
+          s.nick = c['nick']
+          s.user = c['user']
+          s.pass = c['pass']
+          s.rnam = c['rnam']
+
+          s.connect if should_restart
+      end
+    end
+
+    (@sockets.keys - server_config.keys).each do |k|
+      remove k
+    end
+
+    (server_config.keys - @sockets.keys).each do |k|
+      add(k, server_config[k])
+    end
+  end
+
+  def handle_command(h, cmd_info)
+    @plugins.each_pair do |name, plugin|
+      return true if plugin.handle_command(h, cmd_info)
+    end
+    false
+  end
+
+  def handle_event(e)
+    TinyIRC.define_event_methods(e)
+    Thread.new do
+      @plugins['core'].handle_event(e)
+    end
+  end
+
+  def start
+    Thread.new do
+      ioloop
+    end
+
+    TinyIRC::App.cfg self
+    TinyIRC::App.run!
+  end
+
+  def ioloop
+    def _read_line(socket)
+      res = IO.select([socket.sock], nil, nil, 0.001)
+      return nil unless res
+      socket.mtx.synchronize do
+        begin
+          return socket.sock.readline("\r\n", chomp: true).force_encoding("UTF-8")
+        rescue => e
+          socket.log.error "#{e.class.name} - #{e.message}"
+          socket.running = false
+          handle_event(type: :disconnect, socket: socket)
+          return nil
+        end
+      end
+    end
+
+    def read_line(socket)
+      return unless socket.running
+      msg = _read_line(socket)
+      return unless msg
+      socket.log.io "R> #{msg}"
+      handle_event(type: :raw, raw_data: msg, socket: socket, bot: self)
+    end
+
+    def write_line(socket)
+      return unless socket.running
+      
+      previous = socket.last_write
+      current = Time.now
+      diff = current - previous
+      return if diff < 0.7 && diff > 0
+      # todo - implement bursts
+
+      msg = begin
+        socket.queue.pop true
+      rescue ThreadError
+        nil
+      end
+      
+      return unless msg
+      socket.mtx.synchronize do
+        begin
+          socket.direct_write msg.force_encoding("UTF-8")
+        rescue => e
+          socket.log.error "#{e.class.name} - #{e.message}"
+          socket.running = false
+          handle_event(type: :disconnect, socket: socket)
+          return nil
+        end
+      end
+
+      socket.last_write = current
+    end
+
+    while true do
+      sleep 0.001
+
+      @sockets.each_pair do |sname, socket|
+        sleep 0.001
+
+        next unless socket.running
+
+        read_line(socket)
+        write_line(socket)
+      end
+    end
+  end
+
+  def inspect
+    '#<TinyIRC::Bot>'
+  end
+end