Class: CloudFoundry::Perm::V1::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/perm/v1/client.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(hostname:, port: 6283, trusted_cas:, timeout: 15) ⇒ Client

Returns a new instance of Client.

Raises:

  • (ArgumentError) 


12
13
14
15
16
17
18
19
20
 
# File 'lib/perm/v1/client.rb', line 12

def initialize(hostname:, port: 6283, trusted_cas:, timeout: 15)
  raise ArgumentError, 'trusted_cas cannot be empty' if trusted_cas.empty?

  @hostname = hostname
  @port = port
  @url = "#{hostname}:#{port}"
  @trusted_cas = trusted_cas
  @timeout = timeout
end

Instance Attribute Details

#hostname ⇒ Object (readonly)

Returns the value of attribute hostname.



10
11
12
 
# File 'lib/perm/v1/client.rb', line 10

def hostname
  @hostname
end

#port ⇒ Object (readonly)

Returns the value of attribute port.



10
11
12
 
# File 'lib/perm/v1/client.rb', line 10

def port
  @port
end

Instance Method Details

#assign_role(role_name:, actor_id:, namespace:) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
 
# File 'lib/perm/v1/client.rb', line 57

def assign_role(role_name:, actor_id:, namespace:)
  actor = Protos::Actor.new(id: actor_id, namespace: namespace)
  request = Protos::AssignRoleRequest.new(actor: actor, role_name: role_name)

  grpc_role_service.assign_role(request)

  nil
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#create_role(role_name:, permissions: []) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/perm/v1/client.rb', line 22

def create_role(role_name:, permissions: [])
  permission_protos = permissions.map do |p|
    Protos::Permission.new(action: p.action, resource_pattern: p.resource_pattern)
  end
  request = Protos::CreateRoleRequest.new(name: role_name, permissions: permission_protos)

  response = grpc_role_service.create_role(request)
  role = response.role

  Models::Role.new(name: role.name)
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#delete_role(name) ⇒ Object 



47
48
49
50
51
52
53
54
55
 
# File 'lib/perm/v1/client.rb', line 47

def delete_role(name)
  request = Protos::DeleteRoleRequest.new(name: name)

  grpc_role_service.delete_role(request)

  nil
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#get_role(name) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
 
# File 'lib/perm/v1/client.rb', line 36

def get_role(name)
  request = Protos::GetRoleRequest.new(name: name)

  response = grpc_role_service.get_role(request)
  role = response.role

  Models::Role.new(name: role.name)
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#has_permission?(actor_id:, namespace:, action:, resource:) ⇒ Boolean

Returns:

  • (Boolean) 


117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/perm/v1/client.rb', line 117

def has_permission?(actor_id:, namespace:, action:, resource:)
  actor = Protos::Actor.new(id: actor_id, namespace: namespace)
  request = Protos::HasPermissionRequest.new(
    actor: actor,
    action: action,
    resource: resource
  )

  response = grpc_permission_service.has_permission(request)
  response.has_permission
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#has_role?(role_name:, actor_id:, namespace:) ⇒ Boolean

rubocop:disable Naming/PredicateName

Returns:

  • (Boolean) 


80
81
82
83
84
85
86
87
88
 
# File 'lib/perm/v1/client.rb', line 80

def has_role?(role_name:, actor_id:, namespace:)
  actor = Protos::Actor.new(id: actor_id, namespace: namespace)
  request = Protos::HasRoleRequest.new(actor: actor, role_name: role_name)

  response = grpc_role_service.has_role(request)
  response.has_role
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#list_actor_roles(actor_id:, namespace:) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/perm/v1/client.rb', line 90

def list_actor_roles(actor_id:, namespace:)
  actor = Protos::Actor.new(id: actor_id, namespace: namespace)
  request = Protos::ListActorRolesRequest.new(actor: actor)

  response = grpc_role_service.list_actor_roles(request)
  roles = response.roles

  roles.map do |role|
    Models::Role.new(name: role.name)
  end
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#list_resource_patterns(actor_id:, namespace:, action:) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/perm/v1/client.rb', line 131

def list_resource_patterns(actor_id:, namespace:, action:)
  actor = Protos::Actor.new(id: actor_id, namespace: namespace)
  request = Protos::ListResourcePatternsRequest.new(
    actor: actor,
    action: action
  )

  response = grpc_permission_service.list_resource_patterns(request)

  response.resource_patterns
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#list_role_permissions(role_name:) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/perm/v1/client.rb', line 104

def list_role_permissions(role_name:)
  request = Protos::ListRolePermissionsRequest.new(role_name: role_name)

  response = grpc_role_service.list_role_permissions(request)
  permissions = response.permissions

  permissions.map do |permission|
    Models::Permission.new(action: permission.action, resource_pattern: permission.resource_pattern)
  end
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end

#unassign_role(role_name:, actor_id:, namespace:) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
 
# File 'lib/perm/v1/client.rb', line 68

def unassign_role(role_name:, actor_id:, namespace:)
  actor = Protos::Actor.new(id: actor_id, namespace: namespace)
  request = Protos::UnassignRoleRequest.new(actor: actor, role_name: role_name)

  grpc_role_service.unassign_role(request)

  nil
rescue GRPC::BadStatus => e
  raise Errors.from_grpc_error(e)
end