Class: Yus::Session

Inherits:
Object
  • Object
show all
Includes:
DRb::DRbUndumped
Defined in:
lib/yus/session.rb

Direct Known Subclasses

AutoSession, EntitySession, RootSession

Instance Method Summary collapse

Constructor Details

#initialize(needle) ⇒ Session

Returns a new instance of Session.



20
21
22
23
24
25
# File 'lib/yus/session.rb', line 20

def initialize(needle)
  @needle = needle
  @timeout = needle.config.session_timeout
  @mutex = Mutex.new
  touch!
end

Instance Method Details

#affiliate(name, groupname) ⇒ Object



26
27
28
29
30
31
32
33
34
35
36
# File 'lib/yus/session.rb', line 26

def affiliate(name, groupname)
  info("affiliate(name=#{name}, group=#{groupname})")
  @mutex.synchronize {
    allow_or_fail('edit', 'yus.entities')
    user = find_or_fail(name)
    group = find_or_fail(groupname)
    user.join(group)
    save(user, group)
  }
  touch!
end

#create_entity(name, valid_until = nil, valid_from = Time.now) ⇒ Object



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
# File 'lib/yus/session.rb', line 58

def create_entity(name, valid_until=nil, valid_from=Time.now)
  info("create_entity(name=#{name}, valid_until=#{valid_until}, valid_from=#{valid_from})")
  entity = nil
  @mutex.synchronize {
    allow_or_fail('edit', 'yus.entities')
    if(@needle.persistence.find_entity(name))
      debug("create_entity: Duplicate Name: '#{name}'")
      raise DuplicateNameError, "Duplicate name: #{name}"
    end
    entity = Entity.new(name, valid_until, valid_from)
    entity.grant('set_password', name)
    @needle.persistence.add_entity(entity)
  }
  touch!
  entity
end

#delete_entity(name) ⇒ Object



74
75
76
77
78
79
80
# File 'lib/yus/session.rb', line 74

def delete_entity(name)
  info("delete_entity(name=#{name})")
  allow_or_fail 'edit', 'yus.entities'
  entity = find_or_fail name
  @needle.persistence.delete_entity name
  touch!
end

#destroy!Object



81
82
83
84
# File 'lib/yus/session.rb', line 81

def destroy!
  @needle = @user = nil
  @timeout = -1
end

#disaffiliate(name, groupname) ⇒ Object



85
86
87
88
89
90
91
92
93
94
# File 'lib/yus/session.rb', line 85

def disaffiliate(name, groupname)
  info("disaffiliate(name=#{name}, group=#{groupname})")
  @mutex.synchronize {
    allow_or_fail('edit', 'yus.entities')
    user = find_or_fail(name)
    group = find_or_fail(groupname)
    save(user, group)
  }
  touch!
end

#dump_to_yaml(yaml_name = nil) ⇒ Object



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# File 'lib/yus/session.rb', line 37

def dump_to_yaml(yaml_name=nil)
  yaml_name ||= File.expand_path(File.join(__FILE__, '..', '..', '..', 'data', 'yus_dump.yml'))
  ::FileUtils.makedirs(File.dirname(yaml_name))
  if entities.is_a?(Hash) # when running unit tests, where MockPersistence uses a Hash
    File.open(yaml_name, 'w') { |f| YAML.dump(@needle.persistence, f) }
  else
    File.open(yaml_name, 'w') {
      |fh|
          ids = entities.collect { |item| item.odba_id }
          ids.each { |odba_id|
          begin
            yaml = YAML.dump(ODBA.cache.fetch(odba_id, nil))
            fh.puts yaml
            fh.puts
          rescue
          end
        }
    }
    info "dumped #{entities.size} entities to #{yaml_name}"
  end
end

#entitiesObject



98
99
100
101
102
# File 'lib/yus/session.rb', line 98

def entities
  allow_or_fail('edit', 'yus.entities')
  touch!
  @needle.persistence.entities
end

#expired?Boolean

Returns:

  • (Boolean)


95
96
97
# File 'lib/yus/session.rb', line 95

def expired?
  Time.now > (@last_access + @timeout)
end

#find_entity(name) ⇒ Object



103
104
105
106
107
# File 'lib/yus/session.rb', line 103

def find_entity(name)
  allow_or_fail('edit', 'yus.entities')
  touch!
  @needle.persistence.find_entity(name)
end

#grant(name, action, item = nil, expires = nil) ⇒ Object



108
109
110
111
112
113
114
115
116
117
# File 'lib/yus/session.rb', line 108

def grant(name, action, item=nil, expires=nil)
  info("grant(name=#{name}, action=#{action}, item=#{item}, expires=#{expires})")
  @mutex.synchronize {
    allow_or_fail('grant', action)
    user = find_or_fail(name)
    user.grant(action, item || :everything, expires || :never)
    save(user)
  }
  touch!
end

#last_login(name, domain = @domain) ⇒ Object



118
119
120
121
122
# File 'lib/yus/session.rb', line 118

def (name, domain=@domain)
  if(user = find_entity(name))
    user.(domain)
  end
end

#remove_token(token) ⇒ Object



123
124
125
126
127
# File 'lib/yus/session.rb', line 123

def remove_token(token)
  @user.remove_token token
  save @user
  nil
end

#rename(oldname, newname) ⇒ Object



128
129
130
131
132
133
134
135
136
137
138
139
140
141
# File 'lib/yus/session.rb', line 128

def rename(oldname, newname)
  info("rename(#{oldname}, #{newname})")
  @mutex.synchronize {
    allow_or_fail('edit', 'yus.entities')
    user = find_or_fail(oldname)
    if((other = @needle.persistence.find_entity(newname)) && other != user)
      raise DuplicateNameError, "Duplicate name: #{newname}"
    end
    user.revoke('set_password', oldname)
    user.rename(newname)
    user.grant('set_password', newname)
    save(user)
  }
end

#revoke(name, action, item = nil, time = nil) ⇒ Object



142
143
144
145
146
147
148
149
150
151
# File 'lib/yus/session.rb', line 142

def revoke(name, action, item=nil, time=nil)
  info("revoke(name=#{name}, action=#{action}, item=#{item}, time=#{time})")
  @mutex.synchronize {
    allow_or_fail('grant', action)
    user = find_or_fail(name)
    user.revoke(action, item || :everything, time)
    save(user)
  }
  touch!
end

#set_entity_preference(name, key, value, domain = @domain) ⇒ Object



161
162
163
164
165
166
167
168
169
170
# File 'lib/yus/session.rb', line 161

def set_entity_preference(name, key, value, domain=@domain)
  debug("set_entity_preference(name=#{name}, key=#{key}, value=#{value}, domain=#{domain})")
  @mutex.synchronize {
    allow_or_fail('edit', 'yus.entities')
    user = find_or_fail(name)
    user.set_preference(key, value, domain)
    save(user)
  }
  touch!
end

#set_password(name, pass) ⇒ Object



152
153
154
155
156
157
158
159
160
# File 'lib/yus/session.rb', line 152

def set_password(name, pass)
  @mutex.synchronize {
    allow_or_fail('set_password', name)
    user = find_or_fail(name)
    user.passhash = @needle.config.digest.hexdigest(pass)
    save(user)
  }
  touch!
end