Class: KaseyaWS::Client

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

Constant Summary collapse

HASH_ALGORITHM = 
"SHA-256"

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(username, password, hostname) ⇒ Client

Returns a new instance of Client.



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

def initialize (username,password,hostname)

  @vsa_serviceurl = "https://" + hostname + "/vsaWS/kaseyaWS.asmx?WSDL"
  @client_ip = KaseyaWS::Security.client_ip
  @savon_options={
    wsdl: @vsa_serviceurl,
    convert_request_keys_to: :camelcase,
    env_namespace: :soap,
    open_timeout: 30,
    log: false
  }
  @sessionid = self.authenticate(username,password)

end

Instance Attribute Details

#client ⇒ Object

Returns the value of attribute client.



19
20
21
 
# File 'lib/kaseyaws/client.rb', line 19

def client
  @client
end

Instance Method Details

#add_mach_group_to_scope(group_name, scope_name) ⇒ Object 



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

def add_mach_group_to_scope(group_name,scope_name)

  response = self.client.call(:add_mach_group_to_scope, message: {req:[{
                                                                    group_name: group_name,
                                                                    scope_name: scope_name,
                                                                    browser_ip: @client_ip,
                         session_i_d: @sessionid}]}
                         )
  response.body[:add_mach_group_to_scope_response][:add_mach_group_to_scope_result]
end

#add_org_to_scope(company_id, scope_id) ⇒ Object 



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

def add_org_to_scope(company_id,scope_id)

  response = self.client.call(:add_org_to_scope, message: {req:[{
                                                             company_i_d: company_id,
                                                             scope_i_d: scope_id,
                         session_i_d: @sessionid}]}
                         )
  response.body[:add_org_to_scope_response][:add_org_to_scope_result]
end

#add_user_to_role(username, role_id) ⇒ Object 



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

def add_user_to_role(username,role_id)

  response = self.client.call(:add_user_to_role, message: {req:[{
                                                             user_name: user_name,
                                                             role_i_d: role_id,
                         session_i_d: @sessionid}]}
                         )
  response.body[:add_user_to_role_response][:add_user_to_role_result]
end

#authenticate(username, password) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/kaseyaws/client.rb', line 67

def authenticate(username,password)

  random_number = KaseyaWS::Security.secure_random
  covered_password = KaseyaWS::Security.compute_covered_password(username,password, random_number, HASH_ALGORITHM)
  browser_ip = @client_ip

  self.client = Savon::Client.new(@savon_options)

  response = self.client.call(:authenticate, message: {req:[{
                                                              user_name: username,
                                                              covered_password: covered_password,
                                                              random_number: random_number,
                                                              browser_ip: browser_ip,
                              hashing_algorithm: HASH_ALGORITHM}]}
                              )
  @sessionid = response.body[:authenticate_response][:authenticate_result][:session_id]
end

#close_alarm(monitor_alarm_id, notes) ⇒ Object 



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

def close_alarm (monitor_alarm_id, notes)

  response = self.client.call(:close_alarm, message: {req:[{
                                                        monitor_alarm_i_d: monitor_alarm_id,
                                                        notes: notes,
                                                        browser_ip: @client_ip,
                         session_i_d: @sessionid}]}
                         )
  response.body[:close_alarm_response][:close_alarm_result]
end

#create_machine_group(group_name, org_name, parent_name) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/kaseyaws/client.rb', line 96

def create_machine_group (group_name,org_name,parent_name)

  response = self.client.call(:create_machine_group, message: {req:[{
                                                        group_name: group_name,
                                                        org_name: org_name,
                                                        parent_name: parent_name,
                                                        browser_ip: @client_ip,
                         session_i_d: @sessionid}]}
                         )
  response.body[:create_machine_group_response][:create_machine_group_result]
end

#create_role(role_name, role_type, parent_role_name) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/kaseyaws/client.rb', line 108

def create_role (role_name,role_type,parent_role_name)

  response = self.client.call(:create_role, message: {req:[{
                                                        role_name: role_name,
                                                        role_type: role_type,
                                                        parent_role_name: parent_role_name,
                                                        browser_ip: @client_ip,
                         session_i_d: @sessionid}]}
                         )
  response.body[:create_role_response][:create_role_result]
end

#delete_admin(user_name) ⇒ Object 



120
121
122
123
124
125
126
127
128
 
# File 'lib/kaseyaws/client.rb', line 120

def delete_admin (user_name)

  response = self.client.call(:delete_admin, message: {req:[{
                                                        user_name: user_name,
                                                        browser_ip: @client_ip,
                         session_i_d: @sessionid}]}
                         )
  response.body[:delete_admin_response][:delete_admin_result]
end

#get_alarm(monitor_alarm_id) ⇒ Object 



130
131
132
133
134
135
136
137
138
 
# File 'lib/kaseyaws/client.rb', line 130

def get_alarm (monitor_alarm_id)

  response = self.client.call(:get_alarm, message: {req:[{
                                                           monitor_alarm_i_d: monitor_alarm_id,
                                                           browser_ip: @client_ip,
                              session_i_d: @sessionid}]}
                              )
  response.body[:get_alarm_response][:get_alarm_result]
end

#get_alarm_list(get_all_records = true) ⇒ Object 



140
141
142
143
144
145
146
147
148
 
# File 'lib/kaseyaws/client.rb', line 140

def get_alarm_list (get_all_records=true)

  response = self.client.call(:get_alarm_list, message: {req:[{
                                                                return_all_records: get_all_records,
                                                                browser_ip: @client_ip,
                              session_i_d: @sessionid}]}
                              )
  response.body[:get_alarm_list_response][:get_alarm_list_result]
end

#get_machine(machine_group_id) ⇒ Object 



150
151
152
153
154
155
156
157
158
 
# File 'lib/kaseyaws/client.rb', line 150

def get_machine(machine_group_id)

  response = self.client.call(:get_machine, message: {req:[{
                                                        machine___group_i_d: machine_group_id,
                                                        browser_ip: @client_ip,
                         session_i_d: @sessionid}]}
                         )
  response.body[:get_machine_response][:get_machine_result]
end

#get_machine_group_list ⇒ Object 



160
161
162
163
164
165
166
167
 
# File 'lib/kaseyaws/client.rb', line 160

def get_machine_group_list

  response = self.client.call(:get_machine_group_list, message: {req:[{
                                                                   browser_ip: @client_ip,
                         session_i_d: @sessionid}]}
                         )
  response.body[:get_machine_group_list_response][:get_machine_group_list_result]
end

#get_machine_list(machine_group, machine_collection) ⇒ Object 



169
170
171
172
173
174
175
176
177
178
 
# File 'lib/kaseyaws/client.rb', line 169

def get_machine_list(machine_group,machine_collection)

  response = self.client.call(:get_machine_list, message: {req:[{
                                                             machine_group: machine_group,
                                                             machine_collection: machine_collection,
                                                             browser_ip: @client_ip,
                         session_i_d: @sessionid}]}
                         )
  response.body[:get_machine_list_response][:get_machine_list_result]
end