Class: Norikra::RPC::Handler

Inherits:
Object
  • Object
show all
Defined in:
lib/norikra/rpc/handler.rb

Instance Method Summary collapse

Constructor Details

#initialize(engine) ⇒ Handler

Returns a new instance of Handler.



10
11
12
13
 
# File 'lib/norikra/rpc/handler.rb', line 10

def initialize(engine)
  @engine = engine
  @shut_off_mode = false
end

Instance Method Details

#close(target) ⇒ Object 



53
54
55
56
57
58
 
# File 'lib/norikra/rpc/handler.rb', line 53

def close(target)
  logging(:manage, :close, [target]){
    r = @engine.close(target)
    !!r
  }
end

#deregister(query_name) ⇒ Object 



80
81
82
83
84
85
 
# File 'lib/norikra/rpc/handler.rb', line 80

def deregister(query_name)
  logging(:manage, :deregister, [query_name]){
    r = @engine.deregister(query_name)
    !!r
  }
end

#event(query_name) ⇒ Object 



123
124
125
126
127
 
# File 'lib/norikra/rpc/handler.rb', line 123

def event(query_name)
  logging(:show, :event, [query_name]){
    @engine.output_pool.pop(query_name)
  }
end

#fields(target) ⇒ Object 



101
102
103
104
105
 
# File 'lib/norikra/rpc/handler.rb', line 101

def fields(target)
  logging(:show, :fields, [target]){
    @engine.typedef_manager.field_list(target)
  }
end

#logging(type, handler, args = []) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/norikra/rpc/handler.rb', line 19

def logging(type, handler, args=[])
  if type == :manage
    debug("RPC"){ { handler: handler.to_s, args: args } }
  else
    trace("RPC"){ { handler: handler.to_s, args: args } }
  end

  begin
    yield
  rescue Norikra::ClientError => e
    info "ClientError #{e.class}: #{e.message}"
    raise Norikra::RPC::ClientError, e.message
  rescue => e
    error "Exception #{e.class}: #{e.message}"
    e.backtrace.each do |t|
      error "  " + t
    end
    raise Norikra::RPC::ServerError, "#{e.class}, #{e.message}"
  end
end

#logs ⇒ Object 



141
142
143
144
145
 
# File 'lib/norikra/rpc/handler.rb', line 141

def logs
  logging(:show, :logs){
    Norikra::Log.logger.buffer
  }
end

#modify(target, auto_field) ⇒ Object 



60
61
62
63
64
65
 
# File 'lib/norikra/rpc/handler.rb', line 60

def modify(target, auto_field)
  logging(:manage, :modify, [target, auto_field]){
    r = @engine.modify(target, auto_field)
    !!r
  }
end

#open(target, fields, auto_field) ⇒ Object 



46
47
48
49
50
51
 
# File 'lib/norikra/rpc/handler.rb', line 46

def open(target, fields, auto_field)
  logging(:manage, :open, [target, fields]){
    r = @engine.open(target, fields, auto_field)
    !!r
  }
end

#queries ⇒ Object 



67
68
69
70
71
 
# File 'lib/norikra/rpc/handler.rb', line 67

def queries
  logging(:show, :queries){
    @engine.queries.map(&:to_hash) + @engine.suspended_queries.map(&:to_hash)
  }
end

#register(query_name, query_group, expression) ⇒ Object 



73
74
75
76
77
78
 
# File 'lib/norikra/rpc/handler.rb', line 73

def register(query_name, query_group, expression)
  logging(:manage, :register, [query_name, query_group, expression]){
    r = @engine.register(Norikra::Query.new(name: query_name, group: query_group, expression: expression))
    !!r
  }
end

#reserve(target, fieldname, type) ⇒ Object 



107
108
109
110
111
112
 
# File 'lib/norikra/rpc/handler.rb', line 107

def reserve(target, fieldname, type)
  logging(:manage, :reserve, [target, fieldname, type]){
    r = @engine.reserve(target, fieldname, type)
    !!r
  }
end

#resume(query_name) ⇒ Object 



94
95
96
97
98
99
 
# File 'lib/norikra/rpc/handler.rb', line 94

def resume(query_name)
  logging(:manage, :suspend, [query_name]){
    r = @engine.resume(query_name)
    !!r
  }
end

#see(query_name) ⇒ Object 



129
130
131
132
133
 
# File 'lib/norikra/rpc/handler.rb', line 129

def see(query_name)
  logging(:show, :see, [query_name]){
    @engine.output_pool.fetch(query_name)
  }
end

#send(target, events) ⇒ Object

Raises:



114
115
116
117
118
119
120
121
 
# File 'lib/norikra/rpc/handler.rb', line 114

def send(target, events)
  raise Norikra::RPC::ServiceUnavailableError if @shut_off_mode

  logging(:data, :send, [target, events]){
    r = @engine.send(target, events)
    !!r
  }
end

#shut_off(mode) ⇒ Object 



15
16
17
 
# File 'lib/norikra/rpc/handler.rb', line 15

def shut_off(mode)
  @shut_off_mode = true
end

#suspend(query_name) ⇒ Object 



87
88
89
90
91
92
 
# File 'lib/norikra/rpc/handler.rb', line 87

def suspend(query_name)
  logging(:manage, :suspend, [query_name]){
    r = @engine.suspend(query_name)
    !!r
  }
end

#sweep(query_group = nil) ⇒ Object 



135
136
137
138
139
 
# File 'lib/norikra/rpc/handler.rb', line 135

def sweep(query_group=nil)
  logging(:show, :sweep){
    @engine.output_pool.sweep(query_group)
  }
end

#targets ⇒ Object 



40
41
42
43
44
 
# File 'lib/norikra/rpc/handler.rb', line 40

def targets
  logging(:show, :targets){
    @engine.targets.map(&:to_hash)
  }
end