murmur-ice 0.0.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (4) hide show
  1. data/lib/murmur-ice.rb +193 -0
  2. data/murmur_test.rb +22 -0
  3. data/slice/Murmur123.rb +1700 -0
  4. metadata +67 -0
@@ -0,0 +1,193 @@
1
+ require "timeout"
2
+ require "socket"
3
+ require "Ice"
4
+ require File.join(File.expand_path(File.dirname(__FILE__)), "..", "slice", "Murmur123.rb")
5
+
6
+ module MurmurIce
7
+
8
+ class Meta
9
+ def initialize(options = {})
10
+ host = options[:host] || "127.0.0.1"
11
+ port = options[:port] || 6502
12
+ ice_secret = options[:ice_secret] || nil
13
+
14
+ unless ice_secret.nil?
15
+ props = Ice::createProperties
16
+ props.setProperty "Ice.ImplicitContext", "Shared"
17
+ idd = Ice::InitializationData.new
18
+ idd.properties = props
19
+ ic = Ice::initialize idd
20
+ ic.getImplicitContext.put("secret", ice_secret)
21
+ else
22
+ raise MurmurIce::IceSecretException
23
+ end
24
+
25
+ validate_host(host, port)
26
+
27
+ @meta = Murmur::MetaPrx::checkedCast(ic.stringToProxy("Meta: tcp -h #{host} -p #{port}"))
28
+ end
29
+
30
+ #
31
+ # Check if the host is running Ice.
32
+ #
33
+ def validate_host(host,port)
34
+ begin
35
+ Timeout::timeout(2) do
36
+ begin
37
+ s = TCPSocket.new(host,port)
38
+ s.close
39
+ rescue
40
+ raise MurmurIce::InvalidMetaException
41
+ end
42
+ end
43
+ rescue Timeout::Error
44
+ raise MurmurIce::InvalidMetaException
45
+ end
46
+ end
47
+
48
+ #
49
+ # Return murmur version
50
+ #
51
+ def get_version
52
+ return @meta.getVersion
53
+ end
54
+
55
+ #
56
+ # Return murmur uptime
57
+ #
58
+ def get_uptime
59
+ return @meta.getUptime
60
+ end
61
+
62
+ #
63
+ # Return virtual servers
64
+ #
65
+ def list_servers(only_running=false)
66
+ method = only_running ? :getBootedServers : :getAllServers
67
+ @meta.send(method).collect do |server|
68
+ Server.new(self, @meta, nil, server)
69
+ end
70
+ end
71
+
72
+ #
73
+ # Initialize a virtual server
74
+ #
75
+ def get_server(id)
76
+ Server.new(self, @meta, id)
77
+ end
78
+
79
+ #
80
+ # Create a new virtual server
81
+ #
82
+ def create_server!
83
+ server = @meta.newServer
84
+ return Server.new(self, @meta, nil, server)
85
+ end
86
+
87
+ #
88
+ # Destroy a virtual server
89
+ #
90
+ def destroy_server!(id)
91
+ server = Server.new(self, @meta, id)
92
+ server.stop if server.is_running?
93
+ puts server.interface.delete
94
+ end
95
+
96
+ end # Meta
97
+
98
+ class Server
99
+ attr_reader :id, :interface
100
+
101
+ def initialize(host, meta, id=nil, interface=nil)
102
+ @host,@meta = host,meta
103
+ raise "You need to specify a server ID or an interface" if id.nil? && interface.nil?
104
+
105
+ unless interface.nil?
106
+ @interface = interface
107
+ else
108
+ @interface = @meta.getServer(id)
109
+ raise MurmurIce::InvalidServerException if @interface.nil?
110
+ end
111
+
112
+ @id = @interface.id
113
+ end
114
+
115
+ #
116
+ # Return server status (true or false)
117
+ #
118
+ def is_running?
119
+ return @interface.isRunning
120
+ end
121
+
122
+ #
123
+ # Return server uptime
124
+ #
125
+ def get_uptime
126
+ return @interface.getUptime
127
+ end
128
+
129
+ #
130
+ # Start server
131
+ #
132
+ def start!
133
+ @interface.start
134
+ end
135
+
136
+ #
137
+ # Stop server
138
+ #
139
+ def stop!
140
+ @interface.stop
141
+ end
142
+
143
+ #
144
+ # Restart server
145
+ #
146
+ def restart!
147
+ if is_running? then stop! end
148
+ start!
149
+ end
150
+
151
+ #
152
+ # Return all server config
153
+ #
154
+ def config
155
+ @config = @meta.getDefaultConf.merge(@interface.getAllConf)
156
+ end
157
+
158
+ #
159
+ # Return config key
160
+ #
161
+ def [](key)
162
+ return config[key.to_s]
163
+ end
164
+
165
+ #
166
+ # Set config key
167
+ #
168
+ def []=(key, val)
169
+ @interface.setConf(key.to_s, val.to_s)
170
+ @config = nil
171
+ end
172
+
173
+ #
174
+ # Get users
175
+ #
176
+ def get_users
177
+ return @interface.getUsers
178
+ end
179
+
180
+ #
181
+ # Kick user
182
+ #
183
+ def kick_user!(session_id, reason="Kicked by mysterious admin !")
184
+ @interface.kickUser(session_id, reason.to_s)
185
+ end
186
+
187
+ end # Server
188
+
189
+ class MurmurIce::InvalidServerException < Exception; end
190
+ class MurmurIce::IceSecretException < Exception; end
191
+ class MurmurIce::InvalidMetaException < Exception; end
192
+
193
+ end # MurmurIce
@@ -0,0 +1,22 @@
1
+ require 'lib/murmur-ice'
2
+
3
+ @meta = MurmurIce::Meta.new(:ice_secret => "wrong ice secret")
4
+
5
+ # Can be accessed read-only ?!
6
+ puts "#######################################"
7
+ puts "# Read only tests with bad Ice secret #"
8
+ puts "#######################################"
9
+
10
+ uptime = @meta.get_uptime
11
+ uptime = [uptime/3600, uptime/60%60, uptime%60].map {|time| time.to_s.rjust(2,'0')}.join(":")
12
+
13
+ puts "Uptime of murmur: #{uptime}"
14
+ puts "Number of servers: #{@meta.list_servers.count}"
15
+ @meta.list_servers.each do |server|
16
+ puts "------------------------------------"
17
+ puts "Server #{server[:port]} - #{server.get_users.count} users"
18
+ server.get_users.each do |user|
19
+ puts "- User #{user[1].name}"
20
+ end
21
+ puts "------------------------------------"
22
+ end
@@ -0,0 +1,1700 @@
1
+ # **********************************************************************
2
+ #
3
+ # Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
4
+ #
5
+ # This copy of Ice is licensed to you under the terms described in the
6
+ # ICE_LICENSE file included in this distribution.
7
+ #
8
+ # **********************************************************************
9
+ #
10
+ # Ice version 3.4.2
11
+ #
12
+ # <auto-generated>
13
+ #
14
+ # Generated from file `Murmur.ice'
15
+ #
16
+ # Warning: do not edit this file.
17
+ #
18
+ # </auto-generated>
19
+ #
20
+
21
+ require 'Ice'
22
+ require 'Ice/SliceChecksumDict.rb'
23
+
24
+ module Murmur
25
+
26
+ if not defined?(::Murmur::T_NetAddress)
27
+ T_NetAddress = ::Ice::__defineSequence('::Murmur::NetAddress', ::Ice::T_byte)
28
+ end
29
+
30
+ if not defined?(::Murmur::User)
31
+ class User
32
+ def initialize(session=0, userid=0, mute=false, deaf=false, suppress=false, prioritySpeaker=false, selfMute=false, selfDeaf=false, recording=false, channel=0, name='', onlinesecs=0, bytespersec=0, version=0, release='', os='', osversion='', identity='', context='', comment='', address=nil, tcponly=false, idlesecs=0)
33
+ @session = session
34
+ @userid = userid
35
+ @mute = mute
36
+ @deaf = deaf
37
+ @suppress = suppress
38
+ @prioritySpeaker = prioritySpeaker
39
+ @selfMute = selfMute
40
+ @selfDeaf = selfDeaf
41
+ @recording = recording
42
+ @channel = channel
43
+ @name = name
44
+ @onlinesecs = onlinesecs
45
+ @bytespersec = bytespersec
46
+ @version = version
47
+ @release = release
48
+ @os = os
49
+ @osversion = osversion
50
+ @identity = identity
51
+ @context = context
52
+ @comment = comment
53
+ @address = address
54
+ @tcponly = tcponly
55
+ @idlesecs = idlesecs
56
+ end
57
+
58
+ def hash
59
+ _h = 0
60
+ _h = 5 * _h + @session.hash
61
+ _h = 5 * _h + @userid.hash
62
+ _h = 5 * _h + @mute.hash
63
+ _h = 5 * _h + @deaf.hash
64
+ _h = 5 * _h + @suppress.hash
65
+ _h = 5 * _h + @prioritySpeaker.hash
66
+ _h = 5 * _h + @selfMute.hash
67
+ _h = 5 * _h + @selfDeaf.hash
68
+ _h = 5 * _h + @recording.hash
69
+ _h = 5 * _h + @channel.hash
70
+ _h = 5 * _h + @name.hash
71
+ _h = 5 * _h + @onlinesecs.hash
72
+ _h = 5 * _h + @bytespersec.hash
73
+ _h = 5 * _h + @version.hash
74
+ _h = 5 * _h + @release.hash
75
+ _h = 5 * _h + @os.hash
76
+ _h = 5 * _h + @osversion.hash
77
+ _h = 5 * _h + @identity.hash
78
+ _h = 5 * _h + @context.hash
79
+ _h = 5 * _h + @comment.hash
80
+ _h = 5 * _h + @address.hash
81
+ _h = 5 * _h + @tcponly.hash
82
+ _h = 5 * _h + @idlesecs.hash
83
+ _h % 0x7fffffff
84
+ end
85
+
86
+ def ==(other)
87
+ return false if
88
+ @session != other.session or
89
+ @userid != other.userid or
90
+ @mute != other.mute or
91
+ @deaf != other.deaf or
92
+ @suppress != other.suppress or
93
+ @prioritySpeaker != other.prioritySpeaker or
94
+ @selfMute != other.selfMute or
95
+ @selfDeaf != other.selfDeaf or
96
+ @recording != other.recording or
97
+ @channel != other.channel or
98
+ @name != other.name or
99
+ @onlinesecs != other.onlinesecs or
100
+ @bytespersec != other.bytespersec or
101
+ @version != other.version or
102
+ @release != other.release or
103
+ @os != other.os or
104
+ @osversion != other.osversion or
105
+ @identity != other.identity or
106
+ @context != other.context or
107
+ @comment != other.comment or
108
+ @address != other.address or
109
+ @tcponly != other.tcponly or
110
+ @idlesecs != other.idlesecs
111
+ true
112
+ end
113
+
114
+ def eql?(other)
115
+ return other.class == self.class && other == self
116
+ end
117
+
118
+ def inspect
119
+ ::Ice::__stringify(self, T_User)
120
+ end
121
+
122
+ attr_accessor :session, :userid, :mute, :deaf, :suppress, :prioritySpeaker, :selfMute, :selfDeaf, :recording, :channel, :name, :onlinesecs, :bytespersec, :version, :release, :os, :osversion, :identity, :context, :comment, :address, :tcponly, :idlesecs
123
+ end
124
+
125
+ T_User = ::Ice::__defineStruct('::Murmur::User', User, [
126
+ ["session", ::Ice::T_int],
127
+ ["userid", ::Ice::T_int],
128
+ ["mute", ::Ice::T_bool],
129
+ ["deaf", ::Ice::T_bool],
130
+ ["suppress", ::Ice::T_bool],
131
+ ["prioritySpeaker", ::Ice::T_bool],
132
+ ["selfMute", ::Ice::T_bool],
133
+ ["selfDeaf", ::Ice::T_bool],
134
+ ["recording", ::Ice::T_bool],
135
+ ["channel", ::Ice::T_int],
136
+ ["name", ::Ice::T_string],
137
+ ["onlinesecs", ::Ice::T_int],
138
+ ["bytespersec", ::Ice::T_int],
139
+ ["version", ::Ice::T_int],
140
+ ["release", ::Ice::T_string],
141
+ ["os", ::Ice::T_string],
142
+ ["osversion", ::Ice::T_string],
143
+ ["identity", ::Ice::T_string],
144
+ ["context", ::Ice::T_string],
145
+ ["comment", ::Ice::T_string],
146
+ ["address", ::Murmur::T_NetAddress],
147
+ ["tcponly", ::Ice::T_bool],
148
+ ["idlesecs", ::Ice::T_int]
149
+ ])
150
+ end
151
+
152
+ if not defined?(::Murmur::T_IntList)
153
+ T_IntList = ::Ice::__defineSequence('::Murmur::IntList', ::Ice::T_int)
154
+ end
155
+
156
+ if not defined?(::Murmur::Channel)
157
+ class Channel
158
+ def initialize(id=0, name='', parent=0, links=nil, description='', temporary=false, position=0)
159
+ @id = id
160
+ @name = name
161
+ @parent = parent
162
+ @links = links
163
+ @description = description
164
+ @temporary = temporary
165
+ @position = position
166
+ end
167
+
168
+ def hash
169
+ _h = 0
170
+ _h = 5 * _h + @id.hash
171
+ _h = 5 * _h + @name.hash
172
+ _h = 5 * _h + @parent.hash
173
+ _h = 5 * _h + @links.hash
174
+ _h = 5 * _h + @description.hash
175
+ _h = 5 * _h + @temporary.hash
176
+ _h = 5 * _h + @position.hash
177
+ _h % 0x7fffffff
178
+ end
179
+
180
+ def ==(other)
181
+ return false if
182
+ @id != other.id or
183
+ @name != other.name or
184
+ @parent != other.parent or
185
+ @links != other.links or
186
+ @description != other.description or
187
+ @temporary != other.temporary or
188
+ @position != other.position
189
+ true
190
+ end
191
+
192
+ def eql?(other)
193
+ return other.class == self.class && other == self
194
+ end
195
+
196
+ def inspect
197
+ ::Ice::__stringify(self, T_Channel)
198
+ end
199
+
200
+ attr_accessor :id, :name, :parent, :links, :description, :temporary, :position
201
+ end
202
+
203
+ T_Channel = ::Ice::__defineStruct('::Murmur::Channel', Channel, [
204
+ ["id", ::Ice::T_int],
205
+ ["name", ::Ice::T_string],
206
+ ["parent", ::Ice::T_int],
207
+ ["links", ::Murmur::T_IntList],
208
+ ["description", ::Ice::T_string],
209
+ ["temporary", ::Ice::T_bool],
210
+ ["position", ::Ice::T_int]
211
+ ])
212
+ end
213
+
214
+ if not defined?(::Murmur::Group)
215
+ class Group
216
+ def initialize(name='', inherited=false, inherit=false, inheritable=false, add=nil, remove=nil, members=nil)
217
+ @name = name
218
+ @inherited = inherited
219
+ @inherit = inherit
220
+ @inheritable = inheritable
221
+ @add = add
222
+ @remove = remove
223
+ @members = members
224
+ end
225
+
226
+ def hash
227
+ _h = 0
228
+ _h = 5 * _h + @name.hash
229
+ _h = 5 * _h + @inherited.hash
230
+ _h = 5 * _h + @inherit.hash
231
+ _h = 5 * _h + @inheritable.hash
232
+ _h = 5 * _h + @add.hash
233
+ _h = 5 * _h + @remove.hash
234
+ _h = 5 * _h + @members.hash
235
+ _h % 0x7fffffff
236
+ end
237
+
238
+ def ==(other)
239
+ return false if
240
+ @name != other.name or
241
+ @inherited != other.inherited or
242
+ @inherit != other.inherit or
243
+ @inheritable != other.inheritable or
244
+ @add != other.add or
245
+ @remove != other.remove or
246
+ @members != other.members
247
+ true
248
+ end
249
+
250
+ def eql?(other)
251
+ return other.class == self.class && other == self
252
+ end
253
+
254
+ def inspect
255
+ ::Ice::__stringify(self, T_Group)
256
+ end
257
+
258
+ attr_accessor :name, :inherited, :inherit, :inheritable, :add, :remove, :members
259
+ end
260
+
261
+ T_Group = ::Ice::__defineStruct('::Murmur::Group', Group, [
262
+ ["name", ::Ice::T_string],
263
+ ["inherited", ::Ice::T_bool],
264
+ ["inherit", ::Ice::T_bool],
265
+ ["inheritable", ::Ice::T_bool],
266
+ ["add", ::Murmur::T_IntList],
267
+ ["remove", ::Murmur::T_IntList],
268
+ ["members", ::Murmur::T_IntList]
269
+ ])
270
+ end
271
+
272
+ PermissionWrite = 1
273
+
274
+ PermissionTraverse = 2
275
+
276
+ PermissionEnter = 4
277
+
278
+ PermissionSpeak = 8
279
+
280
+ PermissionWhisper = 256
281
+
282
+ PermissionMuteDeafen = 16
283
+
284
+ PermissionMove = 32
285
+
286
+ PermissionMakeChannel = 64
287
+
288
+ PermissionMakeTempChannel = 1024
289
+
290
+ PermissionLinkChannel = 128
291
+
292
+ PermissionTextMessage = 512
293
+
294
+ PermissionKick = 65536
295
+
296
+ PermissionBan = 131072
297
+
298
+ PermissionRegister = 262144
299
+
300
+ PermissionRegisterSelf = 524288
301
+
302
+ if not defined?(::Murmur::ACL)
303
+ class ACL
304
+ def initialize(applyHere=false, applySubs=false, inherited=false, userid=0, group='', allow=0, deny=0)
305
+ @applyHere = applyHere
306
+ @applySubs = applySubs
307
+ @inherited = inherited
308
+ @userid = userid
309
+ @group = group
310
+ @allow = allow
311
+ @deny = deny
312
+ end
313
+
314
+ def hash
315
+ _h = 0
316
+ _h = 5 * _h + @applyHere.hash
317
+ _h = 5 * _h + @applySubs.hash
318
+ _h = 5 * _h + @inherited.hash
319
+ _h = 5 * _h + @userid.hash
320
+ _h = 5 * _h + @group.hash
321
+ _h = 5 * _h + @allow.hash
322
+ _h = 5 * _h + @deny.hash
323
+ _h % 0x7fffffff
324
+ end
325
+
326
+ def ==(other)
327
+ return false if
328
+ @applyHere != other.applyHere or
329
+ @applySubs != other.applySubs or
330
+ @inherited != other.inherited or
331
+ @userid != other.userid or
332
+ @group != other.group or
333
+ @allow != other.allow or
334
+ @deny != other.deny
335
+ true
336
+ end
337
+
338
+ def eql?(other)
339
+ return other.class == self.class && other == self
340
+ end
341
+
342
+ def inspect
343
+ ::Ice::__stringify(self, T_ACL)
344
+ end
345
+
346
+ attr_accessor :applyHere, :applySubs, :inherited, :userid, :group, :allow, :deny
347
+ end
348
+
349
+ T_ACL = ::Ice::__defineStruct('::Murmur::ACL', ACL, [
350
+ ["applyHere", ::Ice::T_bool],
351
+ ["applySubs", ::Ice::T_bool],
352
+ ["inherited", ::Ice::T_bool],
353
+ ["userid", ::Ice::T_int],
354
+ ["group", ::Ice::T_string],
355
+ ["allow", ::Ice::T_int],
356
+ ["deny", ::Ice::T_int]
357
+ ])
358
+ end
359
+
360
+ if not defined?(::Murmur::Ban)
361
+ class Ban
362
+ def initialize(address=nil, bits=0, name='', _hash='', reason='', start=0, duration=0)
363
+ @address = address
364
+ @bits = bits
365
+ @name = name
366
+ @_hash = _hash
367
+ @reason = reason
368
+ @start = start
369
+ @duration = duration
370
+ end
371
+
372
+ def hash
373
+ _h = 0
374
+ _h = 5 * _h + @address.hash
375
+ _h = 5 * _h + @bits.hash
376
+ _h = 5 * _h + @name.hash
377
+ _h = 5 * _h + @_hash.hash
378
+ _h = 5 * _h + @reason.hash
379
+ _h = 5 * _h + @start.hash
380
+ _h = 5 * _h + @duration.hash
381
+ _h % 0x7fffffff
382
+ end
383
+
384
+ def ==(other)
385
+ return false if
386
+ @address != other.address or
387
+ @bits != other.bits or
388
+ @name != other.name or
389
+ @_hash != other._hash or
390
+ @reason != other.reason or
391
+ @start != other.start or
392
+ @duration != other.duration
393
+ true
394
+ end
395
+
396
+ def eql?(other)
397
+ return other.class == self.class && other == self
398
+ end
399
+
400
+ def inspect
401
+ ::Ice::__stringify(self, T_Ban)
402
+ end
403
+
404
+ attr_accessor :address, :bits, :name, :_hash, :reason, :start, :duration
405
+ end
406
+
407
+ T_Ban = ::Ice::__defineStruct('::Murmur::Ban', Ban, [
408
+ ["address", ::Murmur::T_NetAddress],
409
+ ["bits", ::Ice::T_int],
410
+ ["name", ::Ice::T_string],
411
+ ["_hash", ::Ice::T_string],
412
+ ["reason", ::Ice::T_string],
413
+ ["start", ::Ice::T_int],
414
+ ["duration", ::Ice::T_int]
415
+ ])
416
+ end
417
+
418
+ if not defined?(::Murmur::LogEntry)
419
+ class LogEntry
420
+ def initialize(timestamp=0, txt='')
421
+ @timestamp = timestamp
422
+ @txt = txt
423
+ end
424
+
425
+ def hash
426
+ _h = 0
427
+ _h = 5 * _h + @timestamp.hash
428
+ _h = 5 * _h + @txt.hash
429
+ _h % 0x7fffffff
430
+ end
431
+
432
+ def ==(other)
433
+ return false if
434
+ @timestamp != other.timestamp or
435
+ @txt != other.txt
436
+ true
437
+ end
438
+
439
+ def eql?(other)
440
+ return other.class == self.class && other == self
441
+ end
442
+
443
+ def inspect
444
+ ::Ice::__stringify(self, T_LogEntry)
445
+ end
446
+
447
+ attr_accessor :timestamp, :txt
448
+ end
449
+
450
+ T_LogEntry = ::Ice::__defineStruct('::Murmur::LogEntry', LogEntry, [
451
+ ["timestamp", ::Ice::T_int],
452
+ ["txt", ::Ice::T_string]
453
+ ])
454
+ end
455
+
456
+ if not defined?(::Murmur::T_Tree)
457
+ T_Tree = ::Ice::__declareClass('::Murmur::Tree')
458
+ T_TreePrx = ::Ice::__declareProxy('::Murmur::Tree')
459
+ end
460
+
461
+ if not defined?(::Murmur::T_TreeList)
462
+ T_TreeList = ::Ice::__defineSequence('::Murmur::TreeList', ::Murmur::T_Tree)
463
+ end
464
+
465
+ if not defined?(::Murmur::ChannelInfo)
466
+ class ChannelInfo
467
+ include Comparable
468
+
469
+ def initialize(val)
470
+ fail("invalid value #{val} for ChannelInfo") unless(val >= 0 and val < 2)
471
+ @val = val
472
+ end
473
+
474
+ def ChannelInfo.from_int(val)
475
+ raise IndexError, "#{val} is out of range 0..1" if(val < 0 || val > 1)
476
+ @@_values[val]
477
+ end
478
+
479
+ def to_s
480
+ @@_names[@val]
481
+ end
482
+
483
+ def to_i
484
+ @val
485
+ end
486
+
487
+ def <=>(other)
488
+ other.is_a?(ChannelInfo) or raise ArgumentError, "value must be a ChannelInfo"
489
+ @val <=> other.to_i
490
+ end
491
+
492
+ def hash
493
+ @val.hash
494
+ end
495
+
496
+ def inspect
497
+ @@_names[@val] + "(#{@val})"
498
+ end
499
+
500
+ def ChannelInfo.each(&block)
501
+ @@_values.each(&block)
502
+ end
503
+
504
+ @@_names = ['ChannelDescription', 'ChannelPosition']
505
+ @@_values = [ChannelInfo.new(0), ChannelInfo.new(1)]
506
+
507
+ ChannelDescription = @@_values[0]
508
+ ChannelPosition = @@_values[1]
509
+
510
+ private_class_method :new
511
+ end
512
+
513
+ T_ChannelInfo = ::Ice::__defineEnum('::Murmur::ChannelInfo', ChannelInfo, [ChannelInfo::ChannelDescription, ChannelInfo::ChannelPosition])
514
+ end
515
+
516
+ if not defined?(::Murmur::UserInfo)
517
+ class UserInfo
518
+ include Comparable
519
+
520
+ def initialize(val)
521
+ fail("invalid value #{val} for UserInfo") unless(val >= 0 and val < 6)
522
+ @val = val
523
+ end
524
+
525
+ def UserInfo.from_int(val)
526
+ raise IndexError, "#{val} is out of range 0..5" if(val < 0 || val > 5)
527
+ @@_values[val]
528
+ end
529
+
530
+ def to_s
531
+ @@_names[@val]
532
+ end
533
+
534
+ def to_i
535
+ @val
536
+ end
537
+
538
+ def <=>(other)
539
+ other.is_a?(UserInfo) or raise ArgumentError, "value must be a UserInfo"
540
+ @val <=> other.to_i
541
+ end
542
+
543
+ def hash
544
+ @val.hash
545
+ end
546
+
547
+ def inspect
548
+ @@_names[@val] + "(#{@val})"
549
+ end
550
+
551
+ def UserInfo.each(&block)
552
+ @@_values.each(&block)
553
+ end
554
+
555
+ @@_names = ['UserName', 'UserEmail', 'UserComment', 'UserHash', 'UserPassword', 'UserLastActive']
556
+ @@_values = [UserInfo.new(0), UserInfo.new(1), UserInfo.new(2), UserInfo.new(3), UserInfo.new(4), UserInfo.new(5)]
557
+
558
+ UserName = @@_values[0]
559
+ UserEmail = @@_values[1]
560
+ UserComment = @@_values[2]
561
+ UserHash = @@_values[3]
562
+ UserPassword = @@_values[4]
563
+ UserLastActive = @@_values[5]
564
+
565
+ private_class_method :new
566
+ end
567
+
568
+ T_UserInfo = ::Ice::__defineEnum('::Murmur::UserInfo', UserInfo, [UserInfo::UserName, UserInfo::UserEmail, UserInfo::UserComment, UserInfo::UserHash, UserInfo::UserPassword, UserInfo::UserLastActive])
569
+ end
570
+
571
+ if not defined?(::Murmur::T_UserMap)
572
+ T_UserMap = ::Ice::__defineDictionary('::Murmur::UserMap', ::Ice::T_int, ::Murmur::T_User)
573
+ end
574
+
575
+ if not defined?(::Murmur::T_ChannelMap)
576
+ T_ChannelMap = ::Ice::__defineDictionary('::Murmur::ChannelMap', ::Ice::T_int, ::Murmur::T_Channel)
577
+ end
578
+
579
+ if not defined?(::Murmur::T_ChannelList)
580
+ T_ChannelList = ::Ice::__defineSequence('::Murmur::ChannelList', ::Murmur::T_Channel)
581
+ end
582
+
583
+ if not defined?(::Murmur::T_UserList)
584
+ T_UserList = ::Ice::__defineSequence('::Murmur::UserList', ::Murmur::T_User)
585
+ end
586
+
587
+ if not defined?(::Murmur::T_GroupList)
588
+ T_GroupList = ::Ice::__defineSequence('::Murmur::GroupList', ::Murmur::T_Group)
589
+ end
590
+
591
+ if not defined?(::Murmur::T_ACLList)
592
+ T_ACLList = ::Ice::__defineSequence('::Murmur::ACLList', ::Murmur::T_ACL)
593
+ end
594
+
595
+ if not defined?(::Murmur::T_LogList)
596
+ T_LogList = ::Ice::__defineSequence('::Murmur::LogList', ::Murmur::T_LogEntry)
597
+ end
598
+
599
+ if not defined?(::Murmur::T_BanList)
600
+ T_BanList = ::Ice::__defineSequence('::Murmur::BanList', ::Murmur::T_Ban)
601
+ end
602
+
603
+ if not defined?(::Murmur::T_IdList)
604
+ T_IdList = ::Ice::__defineSequence('::Murmur::IdList', ::Ice::T_int)
605
+ end
606
+
607
+ if not defined?(::Murmur::T_NameList)
608
+ T_NameList = ::Ice::__defineSequence('::Murmur::NameList', ::Ice::T_string)
609
+ end
610
+
611
+ if not defined?(::Murmur::T_NameMap)
612
+ T_NameMap = ::Ice::__defineDictionary('::Murmur::NameMap', ::Ice::T_int, ::Ice::T_string)
613
+ end
614
+
615
+ if not defined?(::Murmur::T_IdMap)
616
+ T_IdMap = ::Ice::__defineDictionary('::Murmur::IdMap', ::Ice::T_string, ::Ice::T_int)
617
+ end
618
+
619
+ if not defined?(::Murmur::T_Texture)
620
+ T_Texture = ::Ice::__defineSequence('::Murmur::Texture', ::Ice::T_byte)
621
+ end
622
+
623
+ if not defined?(::Murmur::T_ConfigMap)
624
+ T_ConfigMap = ::Ice::__defineDictionary('::Murmur::ConfigMap', ::Ice::T_string, ::Ice::T_string)
625
+ end
626
+
627
+ if not defined?(::Murmur::T_GroupNameList)
628
+ T_GroupNameList = ::Ice::__defineSequence('::Murmur::GroupNameList', ::Ice::T_string)
629
+ end
630
+
631
+ if not defined?(::Murmur::T_CertificateDer)
632
+ T_CertificateDer = ::Ice::__defineSequence('::Murmur::CertificateDer', ::Ice::T_byte)
633
+ end
634
+
635
+ if not defined?(::Murmur::T_CertificateList)
636
+ T_CertificateList = ::Ice::__defineSequence('::Murmur::CertificateList', ::Murmur::T_CertificateDer)
637
+ end
638
+
639
+ if not defined?(::Murmur::T_UserInfoMap)
640
+ T_UserInfoMap = ::Ice::__defineDictionary('::Murmur::UserInfoMap', ::Murmur::T_UserInfo, ::Ice::T_string)
641
+ end
642
+
643
+ if not defined?(::Murmur::Tree_mixin)
644
+ module Tree_mixin
645
+ include ::Ice::Object_mixin
646
+
647
+ def ice_ids(current=nil)
648
+ ['::Ice::Object', '::Murmur::Tree']
649
+ end
650
+
651
+ def ice_id(current=nil)
652
+ '::Murmur::Tree'
653
+ end
654
+
655
+ def inspect
656
+ ::Ice::__stringify(self, T_Tree)
657
+ end
658
+
659
+ attr_accessor :c, :children, :users
660
+ end
661
+ class Tree
662
+ include Tree_mixin
663
+
664
+ def Tree.ice_staticId()
665
+ '::Murmur::Tree'
666
+ end
667
+
668
+ def initialize(c=::Murmur::Channel.new, children=nil, users=nil)
669
+ @c = c
670
+ @children = children
671
+ @users = users
672
+ end
673
+ end
674
+ module TreePrx_mixin
675
+ end
676
+ class TreePrx < ::Ice::ObjectPrx
677
+ include TreePrx_mixin
678
+
679
+ def TreePrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
680
+ ice_checkedCast(proxy, '::Murmur::Tree', facetOrCtx, _ctx)
681
+ end
682
+
683
+ def TreePrx.uncheckedCast(proxy, facet=nil)
684
+ ice_uncheckedCast(proxy, facet)
685
+ end
686
+ end
687
+
688
+ if not defined?(::Murmur::T_Tree)
689
+ T_Tree = ::Ice::__declareClass('::Murmur::Tree')
690
+ T_TreePrx = ::Ice::__declareProxy('::Murmur::Tree')
691
+ end
692
+
693
+ T_Tree.defineClass(Tree, false, nil, [], [
694
+ ['c', ::Murmur::T_Channel],
695
+ ['children', ::Murmur::T_TreeList],
696
+ ['users', ::Murmur::T_UserList]
697
+ ])
698
+ Tree_mixin::ICE_TYPE = T_Tree
699
+
700
+ T_TreePrx.defineProxy(TreePrx, T_Tree)
701
+ TreePrx::ICE_TYPE = T_TreePrx
702
+ end
703
+
704
+ if not defined?(::Murmur::MurmurException)
705
+ class MurmurException < Ice::UserException
706
+ def initialize
707
+ end
708
+
709
+ def to_s
710
+ 'Murmur::MurmurException'
711
+ end
712
+ end
713
+
714
+ T_MurmurException = ::Ice::__defineException('::Murmur::MurmurException', MurmurException, nil, [])
715
+ MurmurException::ICE_TYPE = T_MurmurException
716
+ end
717
+
718
+ if not defined?(::Murmur::InvalidSessionException)
719
+ class InvalidSessionException < ::Murmur::MurmurException
720
+ def initialize
721
+ end
722
+
723
+ def to_s
724
+ 'Murmur::InvalidSessionException'
725
+ end
726
+ end
727
+
728
+ T_InvalidSessionException = ::Ice::__defineException('::Murmur::InvalidSessionException', InvalidSessionException, ::Murmur::T_MurmurException, [])
729
+ InvalidSessionException::ICE_TYPE = T_InvalidSessionException
730
+ end
731
+
732
+ if not defined?(::Murmur::InvalidChannelException)
733
+ class InvalidChannelException < ::Murmur::MurmurException
734
+ def initialize
735
+ end
736
+
737
+ def to_s
738
+ 'Murmur::InvalidChannelException'
739
+ end
740
+ end
741
+
742
+ T_InvalidChannelException = ::Ice::__defineException('::Murmur::InvalidChannelException', InvalidChannelException, ::Murmur::T_MurmurException, [])
743
+ InvalidChannelException::ICE_TYPE = T_InvalidChannelException
744
+ end
745
+
746
+ if not defined?(::Murmur::InvalidServerException)
747
+ class InvalidServerException < ::Murmur::MurmurException
748
+ def initialize
749
+ end
750
+
751
+ def to_s
752
+ 'Murmur::InvalidServerException'
753
+ end
754
+ end
755
+
756
+ T_InvalidServerException = ::Ice::__defineException('::Murmur::InvalidServerException', InvalidServerException, ::Murmur::T_MurmurException, [])
757
+ InvalidServerException::ICE_TYPE = T_InvalidServerException
758
+ end
759
+
760
+ if not defined?(::Murmur::ServerBootedException)
761
+ class ServerBootedException < ::Murmur::MurmurException
762
+ def initialize
763
+ end
764
+
765
+ def to_s
766
+ 'Murmur::ServerBootedException'
767
+ end
768
+ end
769
+
770
+ T_ServerBootedException = ::Ice::__defineException('::Murmur::ServerBootedException', ServerBootedException, ::Murmur::T_MurmurException, [])
771
+ ServerBootedException::ICE_TYPE = T_ServerBootedException
772
+ end
773
+
774
+ if not defined?(::Murmur::ServerFailureException)
775
+ class ServerFailureException < ::Murmur::MurmurException
776
+ def initialize
777
+ end
778
+
779
+ def to_s
780
+ 'Murmur::ServerFailureException'
781
+ end
782
+ end
783
+
784
+ T_ServerFailureException = ::Ice::__defineException('::Murmur::ServerFailureException', ServerFailureException, ::Murmur::T_MurmurException, [])
785
+ ServerFailureException::ICE_TYPE = T_ServerFailureException
786
+ end
787
+
788
+ if not defined?(::Murmur::InvalidUserException)
789
+ class InvalidUserException < ::Murmur::MurmurException
790
+ def initialize
791
+ end
792
+
793
+ def to_s
794
+ 'Murmur::InvalidUserException'
795
+ end
796
+ end
797
+
798
+ T_InvalidUserException = ::Ice::__defineException('::Murmur::InvalidUserException', InvalidUserException, ::Murmur::T_MurmurException, [])
799
+ InvalidUserException::ICE_TYPE = T_InvalidUserException
800
+ end
801
+
802
+ if not defined?(::Murmur::InvalidTextureException)
803
+ class InvalidTextureException < ::Murmur::MurmurException
804
+ def initialize
805
+ end
806
+
807
+ def to_s
808
+ 'Murmur::InvalidTextureException'
809
+ end
810
+ end
811
+
812
+ T_InvalidTextureException = ::Ice::__defineException('::Murmur::InvalidTextureException', InvalidTextureException, ::Murmur::T_MurmurException, [])
813
+ InvalidTextureException::ICE_TYPE = T_InvalidTextureException
814
+ end
815
+
816
+ if not defined?(::Murmur::InvalidCallbackException)
817
+ class InvalidCallbackException < ::Murmur::MurmurException
818
+ def initialize
819
+ end
820
+
821
+ def to_s
822
+ 'Murmur::InvalidCallbackException'
823
+ end
824
+ end
825
+
826
+ T_InvalidCallbackException = ::Ice::__defineException('::Murmur::InvalidCallbackException', InvalidCallbackException, ::Murmur::T_MurmurException, [])
827
+ InvalidCallbackException::ICE_TYPE = T_InvalidCallbackException
828
+ end
829
+
830
+ if not defined?(::Murmur::InvalidSecretException)
831
+ class InvalidSecretException < ::Murmur::MurmurException
832
+ def initialize
833
+ end
834
+
835
+ def to_s
836
+ 'Murmur::InvalidSecretException'
837
+ end
838
+ end
839
+
840
+ T_InvalidSecretException = ::Ice::__defineException('::Murmur::InvalidSecretException', InvalidSecretException, ::Murmur::T_MurmurException, [])
841
+ InvalidSecretException::ICE_TYPE = T_InvalidSecretException
842
+ end
843
+
844
+ if not defined?(::Murmur::ServerCallback_mixin)
845
+ module ServerCallback_mixin
846
+ include ::Ice::Object_mixin
847
+
848
+ def ice_ids(current=nil)
849
+ ['::Ice::Object', '::Murmur::ServerCallback']
850
+ end
851
+
852
+ def ice_id(current=nil)
853
+ '::Murmur::ServerCallback'
854
+ end
855
+
856
+ #
857
+ # Operation signatures.
858
+ #
859
+ # def userConnected(state, current=nil)
860
+ # def userDisconnected(state, current=nil)
861
+ # def userStateChanged(state, current=nil)
862
+ # def channelCreated(state, current=nil)
863
+ # def channelRemoved(state, current=nil)
864
+ # def channelStateChanged(state, current=nil)
865
+
866
+ def inspect
867
+ ::Ice::__stringify(self, T_ServerCallback)
868
+ end
869
+ end
870
+ class ServerCallback
871
+ include ServerCallback_mixin
872
+
873
+ def ServerCallback.ice_staticId()
874
+ '::Murmur::ServerCallback'
875
+ end
876
+ end
877
+ module ServerCallbackPrx_mixin
878
+
879
+ def userConnected(state, _ctx=nil)
880
+ ServerCallback_mixin::OP_userConnected.invoke(self, [state], _ctx)
881
+ end
882
+
883
+ def userDisconnected(state, _ctx=nil)
884
+ ServerCallback_mixin::OP_userDisconnected.invoke(self, [state], _ctx)
885
+ end
886
+
887
+ def userStateChanged(state, _ctx=nil)
888
+ ServerCallback_mixin::OP_userStateChanged.invoke(self, [state], _ctx)
889
+ end
890
+
891
+ def channelCreated(state, _ctx=nil)
892
+ ServerCallback_mixin::OP_channelCreated.invoke(self, [state], _ctx)
893
+ end
894
+
895
+ def channelRemoved(state, _ctx=nil)
896
+ ServerCallback_mixin::OP_channelRemoved.invoke(self, [state], _ctx)
897
+ end
898
+
899
+ def channelStateChanged(state, _ctx=nil)
900
+ ServerCallback_mixin::OP_channelStateChanged.invoke(self, [state], _ctx)
901
+ end
902
+ end
903
+ class ServerCallbackPrx < ::Ice::ObjectPrx
904
+ include ServerCallbackPrx_mixin
905
+
906
+ def ServerCallbackPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
907
+ ice_checkedCast(proxy, '::Murmur::ServerCallback', facetOrCtx, _ctx)
908
+ end
909
+
910
+ def ServerCallbackPrx.uncheckedCast(proxy, facet=nil)
911
+ ice_uncheckedCast(proxy, facet)
912
+ end
913
+ end
914
+
915
+ if not defined?(::Murmur::T_ServerCallback)
916
+ T_ServerCallback = ::Ice::__declareClass('::Murmur::ServerCallback')
917
+ T_ServerCallbackPrx = ::Ice::__declareProxy('::Murmur::ServerCallback')
918
+ end
919
+
920
+ T_ServerCallback.defineClass(ServerCallback, true, nil, [], [])
921
+ ServerCallback_mixin::ICE_TYPE = T_ServerCallback
922
+
923
+ T_ServerCallbackPrx.defineProxy(ServerCallbackPrx, T_ServerCallback)
924
+ ServerCallbackPrx::ICE_TYPE = T_ServerCallbackPrx
925
+
926
+ ServerCallback_mixin::OP_userConnected = ::Ice::__defineOperation('userConnected', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Murmur::T_User], [], nil, [])
927
+ ServerCallback_mixin::OP_userDisconnected = ::Ice::__defineOperation('userDisconnected', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Murmur::T_User], [], nil, [])
928
+ ServerCallback_mixin::OP_userStateChanged = ::Ice::__defineOperation('userStateChanged', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Murmur::T_User], [], nil, [])
929
+ ServerCallback_mixin::OP_channelCreated = ::Ice::__defineOperation('channelCreated', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Murmur::T_Channel], [], nil, [])
930
+ ServerCallback_mixin::OP_channelRemoved = ::Ice::__defineOperation('channelRemoved', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Murmur::T_Channel], [], nil, [])
931
+ ServerCallback_mixin::OP_channelStateChanged = ::Ice::__defineOperation('channelStateChanged', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Murmur::T_Channel], [], nil, [])
932
+ end
933
+
934
+ ContextServer = 1
935
+
936
+ ContextChannel = 2
937
+
938
+ ContextUser = 4
939
+
940
+ if not defined?(::Murmur::ServerContextCallback_mixin)
941
+ module ServerContextCallback_mixin
942
+ include ::Ice::Object_mixin
943
+
944
+ def ice_ids(current=nil)
945
+ ['::Ice::Object', '::Murmur::ServerContextCallback']
946
+ end
947
+
948
+ def ice_id(current=nil)
949
+ '::Murmur::ServerContextCallback'
950
+ end
951
+
952
+ #
953
+ # Operation signatures.
954
+ #
955
+ # def contextAction(action, usr, session, channelid, current=nil)
956
+
957
+ def inspect
958
+ ::Ice::__stringify(self, T_ServerContextCallback)
959
+ end
960
+ end
961
+ class ServerContextCallback
962
+ include ServerContextCallback_mixin
963
+
964
+ def ServerContextCallback.ice_staticId()
965
+ '::Murmur::ServerContextCallback'
966
+ end
967
+ end
968
+ module ServerContextCallbackPrx_mixin
969
+
970
+ def contextAction(action, usr, session, channelid, _ctx=nil)
971
+ ServerContextCallback_mixin::OP_contextAction.invoke(self, [action, usr, session, channelid], _ctx)
972
+ end
973
+ end
974
+ class ServerContextCallbackPrx < ::Ice::ObjectPrx
975
+ include ServerContextCallbackPrx_mixin
976
+
977
+ def ServerContextCallbackPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
978
+ ice_checkedCast(proxy, '::Murmur::ServerContextCallback', facetOrCtx, _ctx)
979
+ end
980
+
981
+ def ServerContextCallbackPrx.uncheckedCast(proxy, facet=nil)
982
+ ice_uncheckedCast(proxy, facet)
983
+ end
984
+ end
985
+
986
+ if not defined?(::Murmur::T_ServerContextCallback)
987
+ T_ServerContextCallback = ::Ice::__declareClass('::Murmur::ServerContextCallback')
988
+ T_ServerContextCallbackPrx = ::Ice::__declareProxy('::Murmur::ServerContextCallback')
989
+ end
990
+
991
+ T_ServerContextCallback.defineClass(ServerContextCallback, true, nil, [], [])
992
+ ServerContextCallback_mixin::ICE_TYPE = T_ServerContextCallback
993
+
994
+ T_ServerContextCallbackPrx.defineProxy(ServerContextCallbackPrx, T_ServerContextCallback)
995
+ ServerContextCallbackPrx::ICE_TYPE = T_ServerContextCallbackPrx
996
+
997
+ ServerContextCallback_mixin::OP_contextAction = ::Ice::__defineOperation('contextAction', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_string, ::Murmur::T_User, ::Ice::T_int, ::Ice::T_int], [], nil, [])
998
+ end
999
+
1000
+ if not defined?(::Murmur::ServerAuthenticator_mixin)
1001
+ module ServerAuthenticator_mixin
1002
+ include ::Ice::Object_mixin
1003
+
1004
+ def ice_ids(current=nil)
1005
+ ['::Ice::Object', '::Murmur::ServerAuthenticator']
1006
+ end
1007
+
1008
+ def ice_id(current=nil)
1009
+ '::Murmur::ServerAuthenticator'
1010
+ end
1011
+
1012
+ #
1013
+ # Operation signatures.
1014
+ #
1015
+ # def authenticate(name, pw, certificates, certhash, certstrong, current=nil)
1016
+ # def getInfo(id, current=nil)
1017
+ # def nameToId(name, current=nil)
1018
+ # def idToName(id, current=nil)
1019
+ # def idToTexture(id, current=nil)
1020
+
1021
+ def inspect
1022
+ ::Ice::__stringify(self, T_ServerAuthenticator)
1023
+ end
1024
+ end
1025
+ class ServerAuthenticator
1026
+ include ServerAuthenticator_mixin
1027
+
1028
+ def ServerAuthenticator.ice_staticId()
1029
+ '::Murmur::ServerAuthenticator'
1030
+ end
1031
+ end
1032
+ module ServerAuthenticatorPrx_mixin
1033
+
1034
+ def authenticate(name, pw, certificates, certhash, certstrong, _ctx=nil)
1035
+ ServerAuthenticator_mixin::OP_authenticate.invoke(self, [name, pw, certificates, certhash, certstrong], _ctx)
1036
+ end
1037
+
1038
+ def getInfo(id, _ctx=nil)
1039
+ ServerAuthenticator_mixin::OP_getInfo.invoke(self, [id], _ctx)
1040
+ end
1041
+
1042
+ def nameToId(name, _ctx=nil)
1043
+ ServerAuthenticator_mixin::OP_nameToId.invoke(self, [name], _ctx)
1044
+ end
1045
+
1046
+ def idToName(id, _ctx=nil)
1047
+ ServerAuthenticator_mixin::OP_idToName.invoke(self, [id], _ctx)
1048
+ end
1049
+
1050
+ def idToTexture(id, _ctx=nil)
1051
+ ServerAuthenticator_mixin::OP_idToTexture.invoke(self, [id], _ctx)
1052
+ end
1053
+ end
1054
+ class ServerAuthenticatorPrx < ::Ice::ObjectPrx
1055
+ include ServerAuthenticatorPrx_mixin
1056
+
1057
+ def ServerAuthenticatorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
1058
+ ice_checkedCast(proxy, '::Murmur::ServerAuthenticator', facetOrCtx, _ctx)
1059
+ end
1060
+
1061
+ def ServerAuthenticatorPrx.uncheckedCast(proxy, facet=nil)
1062
+ ice_uncheckedCast(proxy, facet)
1063
+ end
1064
+ end
1065
+
1066
+ if not defined?(::Murmur::T_ServerAuthenticator)
1067
+ T_ServerAuthenticator = ::Ice::__declareClass('::Murmur::ServerAuthenticator')
1068
+ T_ServerAuthenticatorPrx = ::Ice::__declareProxy('::Murmur::ServerAuthenticator')
1069
+ end
1070
+
1071
+ T_ServerAuthenticator.defineClass(ServerAuthenticator, true, nil, [], [])
1072
+ ServerAuthenticator_mixin::ICE_TYPE = T_ServerAuthenticator
1073
+
1074
+ T_ServerAuthenticatorPrx.defineProxy(ServerAuthenticatorPrx, T_ServerAuthenticator)
1075
+ ServerAuthenticatorPrx::ICE_TYPE = T_ServerAuthenticatorPrx
1076
+
1077
+ ServerAuthenticator_mixin::OP_authenticate = ::Ice::__defineOperation('authenticate', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_string, ::Ice::T_string, ::Murmur::T_CertificateList, ::Ice::T_string, ::Ice::T_bool], [::Ice::T_string, ::Murmur::T_GroupNameList], ::Ice::T_int, [])
1078
+ ServerAuthenticator_mixin::OP_getInfo = ::Ice::__defineOperation('getInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_int], [::Murmur::T_UserInfoMap], ::Ice::T_bool, [])
1079
+ ServerAuthenticator_mixin::OP_nameToId = ::Ice::__defineOperation('nameToId', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_string], [], ::Ice::T_int, [])
1080
+ ServerAuthenticator_mixin::OP_idToName = ::Ice::__defineOperation('idToName', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_int], [], ::Ice::T_string, [])
1081
+ ServerAuthenticator_mixin::OP_idToTexture = ::Ice::__defineOperation('idToTexture', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_int], [], ::Murmur::T_Texture, [])
1082
+ end
1083
+
1084
+ if not defined?(::Murmur::ServerUpdatingAuthenticator_mixin)
1085
+ module ServerUpdatingAuthenticator_mixin
1086
+ include ::Ice::Object_mixin
1087
+
1088
+ def ice_ids(current=nil)
1089
+ ['::Ice::Object', '::Murmur::ServerAuthenticator', '::Murmur::ServerUpdatingAuthenticator']
1090
+ end
1091
+
1092
+ def ice_id(current=nil)
1093
+ '::Murmur::ServerUpdatingAuthenticator'
1094
+ end
1095
+
1096
+ #
1097
+ # Operation signatures.
1098
+ #
1099
+ # def registerUser(info, current=nil)
1100
+ # def unregisterUser(id, current=nil)
1101
+ # def getRegisteredUsers(filter, current=nil)
1102
+ # def setInfo(id, info, current=nil)
1103
+ # def setTexture(id, tex, current=nil)
1104
+
1105
+ def inspect
1106
+ ::Ice::__stringify(self, T_ServerUpdatingAuthenticator)
1107
+ end
1108
+ end
1109
+ class ServerUpdatingAuthenticator
1110
+ include ServerUpdatingAuthenticator_mixin
1111
+
1112
+ def ServerUpdatingAuthenticator.ice_staticId()
1113
+ '::Murmur::ServerUpdatingAuthenticator'
1114
+ end
1115
+ end
1116
+ module ServerUpdatingAuthenticatorPrx_mixin
1117
+ include ::Murmur::ServerAuthenticatorPrx_mixin
1118
+
1119
+ def registerUser(info, _ctx=nil)
1120
+ ServerUpdatingAuthenticator_mixin::OP_registerUser.invoke(self, [info], _ctx)
1121
+ end
1122
+
1123
+ def unregisterUser(id, _ctx=nil)
1124
+ ServerUpdatingAuthenticator_mixin::OP_unregisterUser.invoke(self, [id], _ctx)
1125
+ end
1126
+
1127
+ def getRegisteredUsers(filter, _ctx=nil)
1128
+ ServerUpdatingAuthenticator_mixin::OP_getRegisteredUsers.invoke(self, [filter], _ctx)
1129
+ end
1130
+
1131
+ def setInfo(id, info, _ctx=nil)
1132
+ ServerUpdatingAuthenticator_mixin::OP_setInfo.invoke(self, [id, info], _ctx)
1133
+ end
1134
+
1135
+ def setTexture(id, tex, _ctx=nil)
1136
+ ServerUpdatingAuthenticator_mixin::OP_setTexture.invoke(self, [id, tex], _ctx)
1137
+ end
1138
+ end
1139
+ class ServerUpdatingAuthenticatorPrx < ::Ice::ObjectPrx
1140
+ include ServerUpdatingAuthenticatorPrx_mixin
1141
+
1142
+ def ServerUpdatingAuthenticatorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
1143
+ ice_checkedCast(proxy, '::Murmur::ServerUpdatingAuthenticator', facetOrCtx, _ctx)
1144
+ end
1145
+
1146
+ def ServerUpdatingAuthenticatorPrx.uncheckedCast(proxy, facet=nil)
1147
+ ice_uncheckedCast(proxy, facet)
1148
+ end
1149
+ end
1150
+
1151
+ if not defined?(::Murmur::T_ServerUpdatingAuthenticator)
1152
+ T_ServerUpdatingAuthenticator = ::Ice::__declareClass('::Murmur::ServerUpdatingAuthenticator')
1153
+ T_ServerUpdatingAuthenticatorPrx = ::Ice::__declareProxy('::Murmur::ServerUpdatingAuthenticator')
1154
+ end
1155
+
1156
+ T_ServerUpdatingAuthenticator.defineClass(ServerUpdatingAuthenticator, true, nil, [::Murmur::T_ServerAuthenticator], [])
1157
+ ServerUpdatingAuthenticator_mixin::ICE_TYPE = T_ServerUpdatingAuthenticator
1158
+
1159
+ T_ServerUpdatingAuthenticatorPrx.defineProxy(ServerUpdatingAuthenticatorPrx, T_ServerUpdatingAuthenticator)
1160
+ ServerUpdatingAuthenticatorPrx::ICE_TYPE = T_ServerUpdatingAuthenticatorPrx
1161
+
1162
+ ServerUpdatingAuthenticator_mixin::OP_registerUser = ::Ice::__defineOperation('registerUser', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, [::Murmur::T_UserInfoMap], [], ::Ice::T_int, [])
1163
+ ServerUpdatingAuthenticator_mixin::OP_unregisterUser = ::Ice::__defineOperation('unregisterUser', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, [::Ice::T_int], [], ::Ice::T_int, [])
1164
+ ServerUpdatingAuthenticator_mixin::OP_getRegisteredUsers = ::Ice::__defineOperation('getRegisteredUsers', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_string], [], ::Murmur::T_NameMap, [])
1165
+ ServerUpdatingAuthenticator_mixin::OP_setInfo = ::Ice::__defineOperation('setInfo', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_int, ::Murmur::T_UserInfoMap], [], ::Ice::T_int, [])
1166
+ ServerUpdatingAuthenticator_mixin::OP_setTexture = ::Ice::__defineOperation('setTexture', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, [::Ice::T_int, ::Murmur::T_Texture], [], ::Ice::T_int, [])
1167
+ end
1168
+
1169
+ if not defined?(::Murmur::Server_mixin)
1170
+ module Server_mixin
1171
+ include ::Ice::Object_mixin
1172
+
1173
+ def ice_ids(current=nil)
1174
+ ['::Ice::Object', '::Murmur::Server']
1175
+ end
1176
+
1177
+ def ice_id(current=nil)
1178
+ '::Murmur::Server'
1179
+ end
1180
+
1181
+ #
1182
+ # Operation signatures.
1183
+ #
1184
+ # def isRunning(current=nil)
1185
+ # def start(current=nil)
1186
+ # def stop(current=nil)
1187
+ # def delete(current=nil)
1188
+ # def id(current=nil)
1189
+ # def addCallback(cb, current=nil)
1190
+ # def removeCallback(cb, current=nil)
1191
+ # def setAuthenticator(auth, current=nil)
1192
+ # def getConf(key, current=nil)
1193
+ # def getAllConf(current=nil)
1194
+ # def setConf(key, value, current=nil)
1195
+ # def setSuperuserPassword(pw, current=nil)
1196
+ # def getLog(first, last, current=nil)
1197
+ # def getLogLen(current=nil)
1198
+ # def getUsers(current=nil)
1199
+ # def getChannels(current=nil)
1200
+ # def getCertificateList(session, current=nil)
1201
+ # def getTree(current=nil)
1202
+ # def getBans(current=nil)
1203
+ # def setBans(bans, current=nil)
1204
+ # def kickUser(session, reason, current=nil)
1205
+ # def getState(session, current=nil)
1206
+ # def setState(state, current=nil)
1207
+ # def sendMessage(session, text, current=nil)
1208
+ # def hasPermission(session, channelid, perm, current=nil)
1209
+ # def addContextCallback(session, action, text, cb, ctx, current=nil)
1210
+ # def removeContextCallback(cb, current=nil)
1211
+ # def getChannelState(channelid, current=nil)
1212
+ # def setChannelState(state, current=nil)
1213
+ # def removeChannel(channelid, current=nil)
1214
+ # def addChannel(name, parent, current=nil)
1215
+ # def sendMessageChannel(channelid, tree, text, current=nil)
1216
+ # def getACL(channelid, current=nil)
1217
+ # def setACL(channelid, acls, groups, inherit, current=nil)
1218
+ # def addUserToGroup(channelid, session, group, current=nil)
1219
+ # def removeUserFromGroup(channelid, session, group, current=nil)
1220
+ # def redirectWhisperGroup(session, source, target, current=nil)
1221
+ # def getUserNames(ids, current=nil)
1222
+ # def getUserIds(names, current=nil)
1223
+ # def registerUser(info, current=nil)
1224
+ # def unregisterUser(userid, current=nil)
1225
+ # def updateRegistration(userid, info, current=nil)
1226
+ # def getRegistration(userid, current=nil)
1227
+ # def getRegisteredUsers(filter, current=nil)
1228
+ # def verifyPassword(name, pw, current=nil)
1229
+ # def getTexture(userid, current=nil)
1230
+ # def setTexture(userid, tex, current=nil)
1231
+ # def getUptime(current=nil)
1232
+
1233
+ def inspect
1234
+ ::Ice::__stringify(self, T_Server)
1235
+ end
1236
+ end
1237
+ class Server
1238
+ include Server_mixin
1239
+
1240
+ def Server.ice_staticId()
1241
+ '::Murmur::Server'
1242
+ end
1243
+ end
1244
+ module ServerPrx_mixin
1245
+
1246
+ def isRunning(_ctx=nil)
1247
+ Server_mixin::OP_isRunning.invoke(self, [], _ctx)
1248
+ end
1249
+
1250
+ def start(_ctx=nil)
1251
+ Server_mixin::OP_start.invoke(self, [], _ctx)
1252
+ end
1253
+
1254
+ def stop(_ctx=nil)
1255
+ Server_mixin::OP_stop.invoke(self, [], _ctx)
1256
+ end
1257
+
1258
+ def delete(_ctx=nil)
1259
+ Server_mixin::OP_delete.invoke(self, [], _ctx)
1260
+ end
1261
+
1262
+ def id(_ctx=nil)
1263
+ Server_mixin::OP_id.invoke(self, [], _ctx)
1264
+ end
1265
+
1266
+ def addCallback(cb, _ctx=nil)
1267
+ Server_mixin::OP_addCallback.invoke(self, [cb], _ctx)
1268
+ end
1269
+
1270
+ def removeCallback(cb, _ctx=nil)
1271
+ Server_mixin::OP_removeCallback.invoke(self, [cb], _ctx)
1272
+ end
1273
+
1274
+ def setAuthenticator(auth, _ctx=nil)
1275
+ Server_mixin::OP_setAuthenticator.invoke(self, [auth], _ctx)
1276
+ end
1277
+
1278
+ def getConf(key, _ctx=nil)
1279
+ Server_mixin::OP_getConf.invoke(self, [key], _ctx)
1280
+ end
1281
+
1282
+ def getAllConf(_ctx=nil)
1283
+ Server_mixin::OP_getAllConf.invoke(self, [], _ctx)
1284
+ end
1285
+
1286
+ def setConf(key, value, _ctx=nil)
1287
+ Server_mixin::OP_setConf.invoke(self, [key, value], _ctx)
1288
+ end
1289
+
1290
+ def setSuperuserPassword(pw, _ctx=nil)
1291
+ Server_mixin::OP_setSuperuserPassword.invoke(self, [pw], _ctx)
1292
+ end
1293
+
1294
+ def getLog(first, last, _ctx=nil)
1295
+ Server_mixin::OP_getLog.invoke(self, [first, last], _ctx)
1296
+ end
1297
+
1298
+ def getLogLen(_ctx=nil)
1299
+ Server_mixin::OP_getLogLen.invoke(self, [], _ctx)
1300
+ end
1301
+
1302
+ def getUsers(_ctx=nil)
1303
+ Server_mixin::OP_getUsers.invoke(self, [], _ctx)
1304
+ end
1305
+
1306
+ def getChannels(_ctx=nil)
1307
+ Server_mixin::OP_getChannels.invoke(self, [], _ctx)
1308
+ end
1309
+
1310
+ def getCertificateList(session, _ctx=nil)
1311
+ Server_mixin::OP_getCertificateList.invoke(self, [session], _ctx)
1312
+ end
1313
+
1314
+ def getTree(_ctx=nil)
1315
+ Server_mixin::OP_getTree.invoke(self, [], _ctx)
1316
+ end
1317
+
1318
+ def getBans(_ctx=nil)
1319
+ Server_mixin::OP_getBans.invoke(self, [], _ctx)
1320
+ end
1321
+
1322
+ def setBans(bans, _ctx=nil)
1323
+ Server_mixin::OP_setBans.invoke(self, [bans], _ctx)
1324
+ end
1325
+
1326
+ def kickUser(session, reason, _ctx=nil)
1327
+ Server_mixin::OP_kickUser.invoke(self, [session, reason], _ctx)
1328
+ end
1329
+
1330
+ def getState(session, _ctx=nil)
1331
+ Server_mixin::OP_getState.invoke(self, [session], _ctx)
1332
+ end
1333
+
1334
+ def setState(state, _ctx=nil)
1335
+ Server_mixin::OP_setState.invoke(self, [state], _ctx)
1336
+ end
1337
+
1338
+ def sendMessage(session, text, _ctx=nil)
1339
+ Server_mixin::OP_sendMessage.invoke(self, [session, text], _ctx)
1340
+ end
1341
+
1342
+ def hasPermission(session, channelid, perm, _ctx=nil)
1343
+ Server_mixin::OP_hasPermission.invoke(self, [session, channelid, perm], _ctx)
1344
+ end
1345
+
1346
+ def addContextCallback(session, action, text, cb, ctx, _ctx=nil)
1347
+ Server_mixin::OP_addContextCallback.invoke(self, [session, action, text, cb, ctx], _ctx)
1348
+ end
1349
+
1350
+ def removeContextCallback(cb, _ctx=nil)
1351
+ Server_mixin::OP_removeContextCallback.invoke(self, [cb], _ctx)
1352
+ end
1353
+
1354
+ def getChannelState(channelid, _ctx=nil)
1355
+ Server_mixin::OP_getChannelState.invoke(self, [channelid], _ctx)
1356
+ end
1357
+
1358
+ def setChannelState(state, _ctx=nil)
1359
+ Server_mixin::OP_setChannelState.invoke(self, [state], _ctx)
1360
+ end
1361
+
1362
+ def removeChannel(channelid, _ctx=nil)
1363
+ Server_mixin::OP_removeChannel.invoke(self, [channelid], _ctx)
1364
+ end
1365
+
1366
+ def addChannel(name, parent, _ctx=nil)
1367
+ Server_mixin::OP_addChannel.invoke(self, [name, parent], _ctx)
1368
+ end
1369
+
1370
+ def sendMessageChannel(channelid, tree, text, _ctx=nil)
1371
+ Server_mixin::OP_sendMessageChannel.invoke(self, [channelid, tree, text], _ctx)
1372
+ end
1373
+
1374
+ def getACL(channelid, _ctx=nil)
1375
+ Server_mixin::OP_getACL.invoke(self, [channelid], _ctx)
1376
+ end
1377
+
1378
+ def setACL(channelid, acls, groups, inherit, _ctx=nil)
1379
+ Server_mixin::OP_setACL.invoke(self, [channelid, acls, groups, inherit], _ctx)
1380
+ end
1381
+
1382
+ def addUserToGroup(channelid, session, group, _ctx=nil)
1383
+ Server_mixin::OP_addUserToGroup.invoke(self, [channelid, session, group], _ctx)
1384
+ end
1385
+
1386
+ def removeUserFromGroup(channelid, session, group, _ctx=nil)
1387
+ Server_mixin::OP_removeUserFromGroup.invoke(self, [channelid, session, group], _ctx)
1388
+ end
1389
+
1390
+ def redirectWhisperGroup(session, source, target, _ctx=nil)
1391
+ Server_mixin::OP_redirectWhisperGroup.invoke(self, [session, source, target], _ctx)
1392
+ end
1393
+
1394
+ def getUserNames(ids, _ctx=nil)
1395
+ Server_mixin::OP_getUserNames.invoke(self, [ids], _ctx)
1396
+ end
1397
+
1398
+ def getUserIds(names, _ctx=nil)
1399
+ Server_mixin::OP_getUserIds.invoke(self, [names], _ctx)
1400
+ end
1401
+
1402
+ def registerUser(info, _ctx=nil)
1403
+ Server_mixin::OP_registerUser.invoke(self, [info], _ctx)
1404
+ end
1405
+
1406
+ def unregisterUser(userid, _ctx=nil)
1407
+ Server_mixin::OP_unregisterUser.invoke(self, [userid], _ctx)
1408
+ end
1409
+
1410
+ def updateRegistration(userid, info, _ctx=nil)
1411
+ Server_mixin::OP_updateRegistration.invoke(self, [userid, info], _ctx)
1412
+ end
1413
+
1414
+ def getRegistration(userid, _ctx=nil)
1415
+ Server_mixin::OP_getRegistration.invoke(self, [userid], _ctx)
1416
+ end
1417
+
1418
+ def getRegisteredUsers(filter, _ctx=nil)
1419
+ Server_mixin::OP_getRegisteredUsers.invoke(self, [filter], _ctx)
1420
+ end
1421
+
1422
+ def verifyPassword(name, pw, _ctx=nil)
1423
+ Server_mixin::OP_verifyPassword.invoke(self, [name, pw], _ctx)
1424
+ end
1425
+
1426
+ def getTexture(userid, _ctx=nil)
1427
+ Server_mixin::OP_getTexture.invoke(self, [userid], _ctx)
1428
+ end
1429
+
1430
+ def setTexture(userid, tex, _ctx=nil)
1431
+ Server_mixin::OP_setTexture.invoke(self, [userid, tex], _ctx)
1432
+ end
1433
+
1434
+ def getUptime(_ctx=nil)
1435
+ Server_mixin::OP_getUptime.invoke(self, [], _ctx)
1436
+ end
1437
+ end
1438
+ class ServerPrx < ::Ice::ObjectPrx
1439
+ include ServerPrx_mixin
1440
+
1441
+ def ServerPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
1442
+ ice_checkedCast(proxy, '::Murmur::Server', facetOrCtx, _ctx)
1443
+ end
1444
+
1445
+ def ServerPrx.uncheckedCast(proxy, facet=nil)
1446
+ ice_uncheckedCast(proxy, facet)
1447
+ end
1448
+ end
1449
+
1450
+ if not defined?(::Murmur::T_Server)
1451
+ T_Server = ::Ice::__declareClass('::Murmur::Server')
1452
+ T_ServerPrx = ::Ice::__declareProxy('::Murmur::Server')
1453
+ end
1454
+
1455
+ T_Server.defineClass(Server, true, nil, [], [])
1456
+ Server_mixin::ICE_TYPE = T_Server
1457
+
1458
+ T_ServerPrx.defineProxy(ServerPrx, T_Server)
1459
+ ServerPrx::ICE_TYPE = T_ServerPrx
1460
+
1461
+ Server_mixin::OP_isRunning = ::Ice::__defineOperation('isRunning', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Ice::T_bool, [::Murmur::T_InvalidSecretException])
1462
+ Server_mixin::OP_start = ::Ice::__defineOperation('start', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_ServerFailureException, ::Murmur::T_InvalidSecretException])
1463
+ Server_mixin::OP_stop = ::Ice::__defineOperation('stop', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1464
+ Server_mixin::OP_delete = ::Ice::__defineOperation('delete', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1465
+ Server_mixin::OP_id = ::Ice::__defineOperation('id', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Ice::T_int, [::Murmur::T_InvalidSecretException])
1466
+ Server_mixin::OP_addCallback = ::Ice::__defineOperation('addCallback', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Murmur::T_ServerCallbackPrx], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidCallbackException, ::Murmur::T_InvalidSecretException])
1467
+ Server_mixin::OP_removeCallback = ::Ice::__defineOperation('removeCallback', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Murmur::T_ServerCallbackPrx], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidCallbackException, ::Murmur::T_InvalidSecretException])
1468
+ Server_mixin::OP_setAuthenticator = ::Ice::__defineOperation('setAuthenticator', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Murmur::T_ServerAuthenticatorPrx], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidCallbackException, ::Murmur::T_InvalidSecretException])
1469
+ Server_mixin::OP_getConf = ::Ice::__defineOperation('getConf', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_string], [], ::Ice::T_string, [::Murmur::T_InvalidSecretException])
1470
+ Server_mixin::OP_getAllConf = ::Ice::__defineOperation('getAllConf', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Murmur::T_ConfigMap, [::Murmur::T_InvalidSecretException])
1471
+ Server_mixin::OP_setConf = ::Ice::__defineOperation('setConf', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_string, ::Ice::T_string], [], nil, [::Murmur::T_InvalidSecretException])
1472
+ Server_mixin::OP_setSuperuserPassword = ::Ice::__defineOperation('setSuperuserPassword', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_string], [], nil, [::Murmur::T_InvalidSecretException])
1473
+ Server_mixin::OP_getLog = ::Ice::__defineOperation('getLog', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int, ::Ice::T_int], [], ::Murmur::T_LogList, [::Murmur::T_InvalidSecretException])
1474
+ Server_mixin::OP_getLogLen = ::Ice::__defineOperation('getLogLen', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Ice::T_int, [::Murmur::T_InvalidSecretException])
1475
+ Server_mixin::OP_getUsers = ::Ice::__defineOperation('getUsers', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Murmur::T_UserMap, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1476
+ Server_mixin::OP_getChannels = ::Ice::__defineOperation('getChannels', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Murmur::T_ChannelMap, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1477
+ Server_mixin::OP_getCertificateList = ::Ice::__defineOperation('getCertificateList', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int], [], ::Murmur::T_CertificateList, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidSecretException])
1478
+ Server_mixin::OP_getTree = ::Ice::__defineOperation('getTree', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Murmur::T_Tree, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1479
+ Server_mixin::OP_getBans = ::Ice::__defineOperation('getBans', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Murmur::T_BanList, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1480
+ Server_mixin::OP_setBans = ::Ice::__defineOperation('setBans', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Murmur::T_BanList], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1481
+ Server_mixin::OP_kickUser = ::Ice::__defineOperation('kickUser', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Ice::T_int, ::Ice::T_string], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidSecretException])
1482
+ Server_mixin::OP_getState = ::Ice::__defineOperation('getState', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int], [], ::Murmur::T_User, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidSecretException])
1483
+ Server_mixin::OP_setState = ::Ice::__defineOperation('setState', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Murmur::T_User], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1484
+ Server_mixin::OP_sendMessage = ::Ice::__defineOperation('sendMessage', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Ice::T_int, ::Ice::T_string], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidSecretException])
1485
+ Server_mixin::OP_hasPermission = ::Ice::__defineOperation('hasPermission', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Ice::T_int, ::Ice::T_int, ::Ice::T_int], [], ::Ice::T_bool, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1486
+ Server_mixin::OP_addContextCallback = ::Ice::__defineOperation('addContextCallback', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Ice::T_int, ::Ice::T_string, ::Ice::T_string, ::Murmur::T_ServerContextCallbackPrx, ::Ice::T_int], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidCallbackException, ::Murmur::T_InvalidSecretException])
1487
+ Server_mixin::OP_removeContextCallback = ::Ice::__defineOperation('removeContextCallback', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Murmur::T_ServerContextCallbackPrx], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidCallbackException, ::Murmur::T_InvalidSecretException])
1488
+ Server_mixin::OP_getChannelState = ::Ice::__defineOperation('getChannelState', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int], [], ::Murmur::T_Channel, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1489
+ Server_mixin::OP_setChannelState = ::Ice::__defineOperation('setChannelState', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Murmur::T_Channel], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1490
+ Server_mixin::OP_removeChannel = ::Ice::__defineOperation('removeChannel', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Ice::T_int], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1491
+ Server_mixin::OP_addChannel = ::Ice::__defineOperation('addChannel', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Ice::T_string, ::Ice::T_int], [], ::Ice::T_int, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1492
+ Server_mixin::OP_sendMessageChannel = ::Ice::__defineOperation('sendMessageChannel', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Ice::T_int, ::Ice::T_bool, ::Ice::T_string], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1493
+ Server_mixin::OP_getACL = ::Ice::__defineOperation('getACL', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int], [::Murmur::T_ACLList, ::Murmur::T_GroupList, ::Ice::T_bool], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1494
+ Server_mixin::OP_setACL = ::Ice::__defineOperation('setACL', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int, ::Murmur::T_ACLList, ::Murmur::T_GroupList, ::Ice::T_bool], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSecretException])
1495
+ Server_mixin::OP_addUserToGroup = ::Ice::__defineOperation('addUserToGroup', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int, ::Ice::T_int, ::Ice::T_string], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidSecretException])
1496
+ Server_mixin::OP_removeUserFromGroup = ::Ice::__defineOperation('removeUserFromGroup', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int, ::Ice::T_int, ::Ice::T_string], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidChannelException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidSecretException])
1497
+ Server_mixin::OP_redirectWhisperGroup = ::Ice::__defineOperation('redirectWhisperGroup', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int, ::Ice::T_string, ::Ice::T_string], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSessionException, ::Murmur::T_InvalidSecretException])
1498
+ Server_mixin::OP_getUserNames = ::Ice::__defineOperation('getUserNames', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Murmur::T_IdList], [], ::Murmur::T_NameMap, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1499
+ Server_mixin::OP_getUserIds = ::Ice::__defineOperation('getUserIds', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Murmur::T_NameList], [], ::Murmur::T_IdMap, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1500
+ Server_mixin::OP_registerUser = ::Ice::__defineOperation('registerUser', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Murmur::T_UserInfoMap], [], ::Ice::T_int, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidUserException, ::Murmur::T_InvalidSecretException])
1501
+ Server_mixin::OP_unregisterUser = ::Ice::__defineOperation('unregisterUser', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Ice::T_int], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidUserException, ::Murmur::T_InvalidSecretException])
1502
+ Server_mixin::OP_updateRegistration = ::Ice::__defineOperation('updateRegistration', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int, ::Murmur::T_UserInfoMap], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidUserException, ::Murmur::T_InvalidSecretException])
1503
+ Server_mixin::OP_getRegistration = ::Ice::__defineOperation('getRegistration', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int], [], ::Murmur::T_UserInfoMap, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidUserException, ::Murmur::T_InvalidSecretException])
1504
+ Server_mixin::OP_getRegisteredUsers = ::Ice::__defineOperation('getRegisteredUsers', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_string], [], ::Murmur::T_NameMap, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1505
+ Server_mixin::OP_verifyPassword = ::Ice::__defineOperation('verifyPassword', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_string, ::Ice::T_string], [], ::Ice::T_int, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1506
+ Server_mixin::OP_getTexture = ::Ice::__defineOperation('getTexture', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int], [], ::Murmur::T_Texture, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidUserException, ::Murmur::T_InvalidSecretException])
1507
+ Server_mixin::OP_setTexture = ::Ice::__defineOperation('setTexture', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int, ::Murmur::T_Texture], [], nil, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidUserException, ::Murmur::T_InvalidTextureException, ::Murmur::T_InvalidSecretException])
1508
+ Server_mixin::OP_getUptime = ::Ice::__defineOperation('getUptime', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Ice::T_int, [::Murmur::T_ServerBootedException, ::Murmur::T_InvalidSecretException])
1509
+ end
1510
+
1511
+ if not defined?(::Murmur::MetaCallback_mixin)
1512
+ module MetaCallback_mixin
1513
+ include ::Ice::Object_mixin
1514
+
1515
+ def ice_ids(current=nil)
1516
+ ['::Ice::Object', '::Murmur::MetaCallback']
1517
+ end
1518
+
1519
+ def ice_id(current=nil)
1520
+ '::Murmur::MetaCallback'
1521
+ end
1522
+
1523
+ #
1524
+ # Operation signatures.
1525
+ #
1526
+ # def started(srv, current=nil)
1527
+ # def stopped(srv, current=nil)
1528
+
1529
+ def inspect
1530
+ ::Ice::__stringify(self, T_MetaCallback)
1531
+ end
1532
+ end
1533
+ class MetaCallback
1534
+ include MetaCallback_mixin
1535
+
1536
+ def MetaCallback.ice_staticId()
1537
+ '::Murmur::MetaCallback'
1538
+ end
1539
+ end
1540
+ module MetaCallbackPrx_mixin
1541
+
1542
+ def started(srv, _ctx=nil)
1543
+ MetaCallback_mixin::OP_started.invoke(self, [srv], _ctx)
1544
+ end
1545
+
1546
+ def stopped(srv, _ctx=nil)
1547
+ MetaCallback_mixin::OP_stopped.invoke(self, [srv], _ctx)
1548
+ end
1549
+ end
1550
+ class MetaCallbackPrx < ::Ice::ObjectPrx
1551
+ include MetaCallbackPrx_mixin
1552
+
1553
+ def MetaCallbackPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
1554
+ ice_checkedCast(proxy, '::Murmur::MetaCallback', facetOrCtx, _ctx)
1555
+ end
1556
+
1557
+ def MetaCallbackPrx.uncheckedCast(proxy, facet=nil)
1558
+ ice_uncheckedCast(proxy, facet)
1559
+ end
1560
+ end
1561
+
1562
+ if not defined?(::Murmur::T_MetaCallback)
1563
+ T_MetaCallback = ::Ice::__declareClass('::Murmur::MetaCallback')
1564
+ T_MetaCallbackPrx = ::Ice::__declareProxy('::Murmur::MetaCallback')
1565
+ end
1566
+
1567
+ T_MetaCallback.defineClass(MetaCallback, true, nil, [], [])
1568
+ MetaCallback_mixin::ICE_TYPE = T_MetaCallback
1569
+
1570
+ T_MetaCallbackPrx.defineProxy(MetaCallbackPrx, T_MetaCallback)
1571
+ MetaCallbackPrx::ICE_TYPE = T_MetaCallbackPrx
1572
+
1573
+ MetaCallback_mixin::OP_started = ::Ice::__defineOperation('started', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, [::Murmur::T_ServerPrx], [], nil, [])
1574
+ MetaCallback_mixin::OP_stopped = ::Ice::__defineOperation('stopped', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, [::Murmur::T_ServerPrx], [], nil, [])
1575
+ end
1576
+
1577
+ if not defined?(::Murmur::T_ServerList)
1578
+ T_ServerList = ::Ice::__defineSequence('::Murmur::ServerList', ::Murmur::T_ServerPrx)
1579
+ end
1580
+
1581
+ if not defined?(::Murmur::Meta_mixin)
1582
+ module Meta_mixin
1583
+ include ::Ice::Object_mixin
1584
+
1585
+ def ice_ids(current=nil)
1586
+ ['::Ice::Object', '::Murmur::Meta']
1587
+ end
1588
+
1589
+ def ice_id(current=nil)
1590
+ '::Murmur::Meta'
1591
+ end
1592
+
1593
+ #
1594
+ # Operation signatures.
1595
+ #
1596
+ # def getServer(id, current=nil)
1597
+ # def newServer(current=nil)
1598
+ # def getBootedServers(current=nil)
1599
+ # def getAllServers(current=nil)
1600
+ # def getDefaultConf(current=nil)
1601
+ # def getVersion(current=nil)
1602
+ # def addCallback(cb, current=nil)
1603
+ # def removeCallback(cb, current=nil)
1604
+ # def getUptime(current=nil)
1605
+ # def getSlice(current=nil)
1606
+ # def getSliceChecksums(current=nil)
1607
+
1608
+ def inspect
1609
+ ::Ice::__stringify(self, T_Meta)
1610
+ end
1611
+ end
1612
+ class Meta
1613
+ include Meta_mixin
1614
+
1615
+ def Meta.ice_staticId()
1616
+ '::Murmur::Meta'
1617
+ end
1618
+ end
1619
+ module MetaPrx_mixin
1620
+
1621
+ def getServer(id, _ctx=nil)
1622
+ Meta_mixin::OP_getServer.invoke(self, [id], _ctx)
1623
+ end
1624
+
1625
+ def newServer(_ctx=nil)
1626
+ Meta_mixin::OP_newServer.invoke(self, [], _ctx)
1627
+ end
1628
+
1629
+ def getBootedServers(_ctx=nil)
1630
+ Meta_mixin::OP_getBootedServers.invoke(self, [], _ctx)
1631
+ end
1632
+
1633
+ def getAllServers(_ctx=nil)
1634
+ Meta_mixin::OP_getAllServers.invoke(self, [], _ctx)
1635
+ end
1636
+
1637
+ def getDefaultConf(_ctx=nil)
1638
+ Meta_mixin::OP_getDefaultConf.invoke(self, [], _ctx)
1639
+ end
1640
+
1641
+ def getVersion(_ctx=nil)
1642
+ Meta_mixin::OP_getVersion.invoke(self, [], _ctx)
1643
+ end
1644
+
1645
+ def addCallback(cb, _ctx=nil)
1646
+ Meta_mixin::OP_addCallback.invoke(self, [cb], _ctx)
1647
+ end
1648
+
1649
+ def removeCallback(cb, _ctx=nil)
1650
+ Meta_mixin::OP_removeCallback.invoke(self, [cb], _ctx)
1651
+ end
1652
+
1653
+ def getUptime(_ctx=nil)
1654
+ Meta_mixin::OP_getUptime.invoke(self, [], _ctx)
1655
+ end
1656
+
1657
+ def getSlice(_ctx=nil)
1658
+ Meta_mixin::OP_getSlice.invoke(self, [], _ctx)
1659
+ end
1660
+
1661
+ def getSliceChecksums(_ctx=nil)
1662
+ Meta_mixin::OP_getSliceChecksums.invoke(self, [], _ctx)
1663
+ end
1664
+ end
1665
+ class MetaPrx < ::Ice::ObjectPrx
1666
+ include MetaPrx_mixin
1667
+
1668
+ def MetaPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
1669
+ ice_checkedCast(proxy, '::Murmur::Meta', facetOrCtx, _ctx)
1670
+ end
1671
+
1672
+ def MetaPrx.uncheckedCast(proxy, facet=nil)
1673
+ ice_uncheckedCast(proxy, facet)
1674
+ end
1675
+ end
1676
+
1677
+ if not defined?(::Murmur::T_Meta)
1678
+ T_Meta = ::Ice::__declareClass('::Murmur::Meta')
1679
+ T_MetaPrx = ::Ice::__declareProxy('::Murmur::Meta')
1680
+ end
1681
+
1682
+ T_Meta.defineClass(Meta, true, nil, [], [])
1683
+ Meta_mixin::ICE_TYPE = T_Meta
1684
+
1685
+ T_MetaPrx.defineProxy(MetaPrx, T_Meta)
1686
+ MetaPrx::ICE_TYPE = T_MetaPrx
1687
+
1688
+ Meta_mixin::OP_getServer = ::Ice::__defineOperation('getServer', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [::Ice::T_int], [], ::Murmur::T_ServerPrx, [::Murmur::T_InvalidSecretException])
1689
+ Meta_mixin::OP_newServer = ::Ice::__defineOperation('newServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [], [], ::Murmur::T_ServerPrx, [::Murmur::T_InvalidSecretException])
1690
+ Meta_mixin::OP_getBootedServers = ::Ice::__defineOperation('getBootedServers', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Murmur::T_ServerList, [::Murmur::T_InvalidSecretException])
1691
+ Meta_mixin::OP_getAllServers = ::Ice::__defineOperation('getAllServers', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Murmur::T_ServerList, [::Murmur::T_InvalidSecretException])
1692
+ Meta_mixin::OP_getDefaultConf = ::Ice::__defineOperation('getDefaultConf', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Murmur::T_ConfigMap, [::Murmur::T_InvalidSecretException])
1693
+ Meta_mixin::OP_getVersion = ::Ice::__defineOperation('getVersion', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [::Ice::T_int, ::Ice::T_int, ::Ice::T_int, ::Ice::T_string], nil, [])
1694
+ Meta_mixin::OP_addCallback = ::Ice::__defineOperation('addCallback', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Murmur::T_MetaCallbackPrx], [], nil, [::Murmur::T_InvalidCallbackException, ::Murmur::T_InvalidSecretException])
1695
+ Meta_mixin::OP_removeCallback = ::Ice::__defineOperation('removeCallback', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, true, [::Murmur::T_MetaCallbackPrx], [], nil, [::Murmur::T_InvalidCallbackException, ::Murmur::T_InvalidSecretException])
1696
+ Meta_mixin::OP_getUptime = ::Ice::__defineOperation('getUptime', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Ice::T_int, [])
1697
+ Meta_mixin::OP_getSlice = ::Ice::__defineOperation('getSlice', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Ice::T_string, [])
1698
+ Meta_mixin::OP_getSliceChecksums = ::Ice::__defineOperation('getSliceChecksums', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, true, [], [], ::Ice::T_SliceChecksumDict, [])
1699
+ end
1700
+ end