murmur 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cf54fdf3d0238dca3cc88e4ffd0663fc464c7e5c
+  data.tar.gz: 153bd7feb7f55fa3f32b4ab1da9539156b97dc53
+SHA512:
+  metadata.gz: d9b2c535c51452eac44fa62e3d4ed26158b39ca68d1b558163fac66c282ae362755c62f8c6c7fdbd21174494611adebe69c5b789691ffecaf3c81164d6b0bc58
+  data.tar.gz: f47502072b62d787fc8664f8132e2636c5c0e171423f06197353d3994d49f2ed1418e4897c15060de451e144026ee2b2267af4c73a35bb805356db107fb4484b

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+pkg
+.bundle
+vendor/ruby

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,62 @@
+# Murmur
+
+A ruby client for controlling and querying the Mumble server (Murmur)
+
+## Installation
+
+Install it from RubyGems:
+
+```
+gem install murmur
+```
+
+Or add it to a Gemfile:
+
+```
+gem 'murmur'
+```
+
+## Usage
+
+Configuration:
+
+```
+require 'murmur'
+
+Murmur.client(
+    :host => '127.0.0.1', # The host of the Murmur server.
+    :port => '6502', # The port of the Murmur server.
+    :glacier_user => '', # The user (if using Glacier2)
+    :glacier_pass => '', # The password (if using Glacier2)
+    :ice_secret => '') # The Ice secret.
+```
+
+Examples:
+
+```
+# Get a server
+Murmur.server 1
+
+# Create a new server
+Murmur.new_server(:registername => "Server name")
+
+# Get the channels of a server
+server = Murmur.server 1
+server.channels
+
+# Get a specific channel of a server
+server = Murmur.server 1
+server.channel 1
+
+# Change the name of a channel
+server = Murmur.server 1
+channel = server.channel 1
+channel.name = "New name!"
+
+# Get the clients of a server
+server = Murmur.server 1
+users = server.users
+```
+
+The #raw function on Murmur::API objects will return the raw Murmur object, allowing calling of unimplemented functions.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/murmur.rb

@@ -0,0 +1,22 @@
+require 'murmur/version'
+require 'murmur/ice_interface'
+require 'murmur/server'
+require 'murmur/channel'
+require 'murmur/user'
+
+module Murmur
+
+    def self.client(options={})
+        @client = Murmur::API::Meta.new(options)
+    end
+
+    def self.method_missing(method, *args, &block)
+        return super unless @client.respond_to?(method)
+        @client.send(method, *args, &block)
+    end
+
+    def self.respond_to?(method)
+        return @client.respond_to?(method) || super
+    end
+
+end

data/lib/murmur/channel.rb

@@ -0,0 +1,87 @@
+module Murmur
+    module API
+        class Channel
+
+            def initialize(host, meta, server, channel)
+                @host = host
+                @meta = meta
+                @server = server
+                @channel = channel
+            end
+
+            def id
+                @channel.id
+            end
+
+            def name
+                @channel.name
+            end
+
+            def name=(name)
+                @channel.name = name
+                update
+            end
+
+            def server
+                @server
+            end
+
+            def parent
+                @server.channel(@channel.parent)
+            end
+
+            def parent=(id)
+                @channel.parent = id
+                update
+            end
+
+            def links
+                @channel.links
+            end
+
+            def temporary?
+                @channel.temporary
+            end
+            alias :temporary :temporary?
+
+            def temporary=(temp)
+                @channel.temporary = temp
+                update
+            end
+
+            def description
+                @channel.description
+            end
+
+            def description=(description)
+                @channel.description = description
+                update
+            end
+
+            def position
+                @channel.position
+            end
+
+            def position=(id)
+                @channel.position = id
+                update
+            end
+
+            private
+
+            def update
+                channel_state = @server.getChannelState(id)
+
+                ["name", "description", "temporary", "position"].each do |func|
+                    channel_state.send("#{func}=", send(func))
+                end
+
+                # Set 'parent' normally.
+                channel_state.parent = parent.id
+
+                @server.setChannelState(channel_state)
+            end
+
+        end
+    end
+end

data/lib/murmur/ice_interface.rb

@@ -0,0 +1,94 @@
+require 'Glacier2'
+require File.join(File.expand_path(File.dirname(__FILE__)), "../../vendor/ice/Murmur.rb")
+require 'murmur/server'
+
+module Murmur
+    module API
+        class Meta
+
+            def initialize(options = {})
+                # Default options
+                options = {:host => '127.0.0.1', :port => 6502}.merge(options)
+
+                if options[:ice_secret]
+                    props = ::Ice::createProperties
+                    props.setProperty "Ice.ImplicitContext", "Shared"
+                    props.setProperty "Ice.Default.EncodingVersion", "1.0"
+
+                    ice_init_data = ::Ice::InitializationData.new
+                    ice_init_data.properties = props
+
+                    ice_context = ::Ice::initialize ice_init_data
+                    ice_context.getImplicitContext.put("secret", options[:ice_secret])
+                else
+                    props = ::Ice::createProperties
+                    props.setProperty "Ice.Default.EncodingVersion", "1.0"
+
+                    ice_init_data = ::Ice::InitializationData.new
+                    ice_init_data.properties = props
+
+                    ice_context = ::Ice::initialize ice_init_data
+                end
+
+                if options[:glacier_host]
+                    prx = ice_context.stringToProxy("Glacier2/router:tcp -h #{options[:glacier_host]} -p #{options[:glacier_port]}")
+                    @router = ::Glacier2::RouterPrx::uncheckedCast(prx).ice_router(nil)
+                    @session = @router.createSession(options[:glacier_user], options[:glacier_pass])
+                end
+
+                conn = "tcp -h #{options[:host]} -p #{options[:port]}"
+                proxy = ice_context.stringToProxy("Meta:#{conn}")
+                @meta = add_proxy_router(Murmur::MetaPrx::checkedCast(proxy))
+                raise "Invalid proxy" unless @meta
+
+                @servers = {}
+            end
+
+            def destroy
+                begin
+                    @router.destroySession @session unless @router.nil?
+                rescue ::Ice::ConnectionLostException
+                end
+
+                nil
+            end
+
+            def add_proxy_router(prx)
+                @router ? prx.ice_router(@router) : prx
+            end
+
+            def server(id)
+                @servers[id] ||= Server.new(self, @meta, {:id => id})
+            end
+
+            def uncache_server(id)
+                @servers[id] = nil
+            end
+
+            def servers
+                @meta.send(:getAllServers).collect do |server|
+                    server = add_proxy_router server
+                    @servers[server.id] ||= Server.new(self, @meta, {:interface => server})
+                end
+            end
+
+            def new_server_interface
+                server = @meta.newServer
+            end
+
+            def new_server(options = {})
+                Server.new(self, @meta, options)
+            end
+
+            def validate
+                @meta.getVersion
+                true
+            end
+
+            def meta
+                @meta
+            end
+
+        end
+    end
+end

data/lib/murmur/server.rb

@@ -0,0 +1,111 @@
+require 'murmur/channel'
+require 'murmur/user'
+
+module Murmur
+    module API
+        class Server
+
+            def initialize(host, meta, options)
+                @host = host
+                @meta = meta
+
+                if !options[:id] and !options[:interface]
+                    options.delete :id
+                    options.delete :interface
+
+                    server = @host.new_server_interface
+
+                    @interface = host.add_proxy_router(server)
+
+                    options.each do |key, value|
+                        setConf(key, value)
+                    end
+                end
+
+                @interface = @interface || options[:interface] || begin
+                server = @meta.getServer(options[:id])
+                raise ::Murmur::Ice::InvalidServerException if server.nil?
+                host.add_proxy_router(server)
+                end
+
+                @channels = {}
+                @users = {}
+            end
+
+            def id
+                @interface.id
+            end
+
+            def running?
+                @interface.isRunning
+            end
+
+            def channel(id)
+                channels
+
+                @channels[id]
+            end
+
+            def channels
+                @channels = {}
+                @interface.getChannels.each do |_, channel|
+                    @channels[channel.id] = Channel.new(@host, @meta, self, channel)
+                end
+                @channels
+            end
+
+            def users
+                @users = {}
+                @interface.getUsers.each do |_, user|
+                    @users[user.session] = User.new(@host, @meta, self, user)
+                end
+                @users
+            end
+
+            def user(session)
+                users
+
+                @users[:session]
+            end
+
+            def config
+                @config = @meta.getDefaultConf.merge(@interface.getAllConf)
+            end
+
+            def destroy!
+                @interface.stop if running?
+                @host.uncache_server id
+                @interface.delete
+            end
+            alias :delete :destroy!
+
+            def restart!
+                @interface.stop if running?
+                @interface.start
+            end
+
+            def [](key)
+                key = key.to_s
+                config[key]
+            end
+
+            def []=(key, val)
+                key - key.to_s
+                @interface.setConf(key, val.to_s)
+                @config = nil
+            end
+
+            def setConf(key, val)
+                key = key.to_s
+                self[key] = val
+            end
+
+            def method_missing(method, *args)
+                method = method.to_s
+                method.gsub!(/_([a-z])/) { $1.upcase }
+                ret = @interface.send method, *args
+            end
+
+        end
+    end
+end

data/lib/murmur/user.rb

@@ -0,0 +1,119 @@
+module Murmur
+    module API
+        class User
+            
+            def initialize(host, meta, server, user)
+                @host = host
+                @meta = meta
+                @server = server
+                @user = user
+            end
+
+            def session
+                @user.session
+            end
+            alias :id :session
+
+            def userid
+                @user.userid
+            end
+
+            def muted?
+                @user.mute
+            end
+
+            def deafened?
+                @user.deaf
+            end
+
+            def suppressed?
+                @user.suppress
+            end
+
+            def priorityspeaker?
+                @user.prioritySpeaker
+            end
+
+            def clientmuted?
+                @user.selfMute
+            end
+
+            def clientdeafened?
+                @user.selfDeaf
+            end
+
+            def recording?
+                @user.recording
+            end
+
+            def channel
+                @server.channel @user.channel
+            end
+
+            def server
+                @server
+            end
+
+            def name
+                @user.name
+            end
+
+            def seconds_connected
+                @user.onlinesecs 
+            end
+            
+            def seconds_idle
+                @user.idlesecs
+            end
+
+            def bytes_per_sec
+                @user.bytespersec
+            end
+
+            def version
+                @user.version
+            end
+
+            def release
+                @user.release
+            end
+
+            def os
+                @user.os
+            end
+
+            def os_version
+                @user.osversion
+            end
+
+            def identity
+                @user.identity
+            end
+
+            def context
+                @user.context
+            end
+
+            def comment
+                @user.comment
+            end
+
+            def tcponly?
+                @user.tcponly
+            end
+
+            def ping
+                {:udp => @user.udpPing, :tcp => @user.tcpPing}
+            end
+
+            def udpPing
+                ping[:udp]
+            end
+
+            def tcpPing
+                ping[:tcp]
+            end
+
+        end
+    end
+end