~lazypower/charms/trusty/nexentaedge-swift-gw/metadata-typo

« back to all changes in this revision

Viewing changes to charms/trusty/nedge-swift-gw/hooks/configurationSteps/neadmServiceWrapper.py

  • Committer: anton.skriptsov at nexenta
  • Date: 2015-11-11 22:13:28 UTC
  • Revision ID: anton.skriptsov@nexenta.com-20151111221328-78ddkdelwzq5e410
nedge-swift-gw initial

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#/usr/bin/env python
 
2
 
 
3
import os
 
4
import sys
 
5
import re
 
6
import traceback
 
7
import subprocess
 
8
 
 
9
class NeadmServiceWrapper:
 
10
    _service_list_cmd = ['/opt/nedge/neadm/neadm', 'service', 'list']
 
11
 
 
12
    #_status_cmd = ['/opt/nedge/neadm/fake-neadm-status.sh']
 
13
    _service_list_header = re.compile("^.*TYPE.*NAME.*SERVERID.*STATUS.*$")      
 
14
    _service_list_names  = ['type', 'name', 'sid', 'status']
 
15
 
 
16
    def __init__(self):
 
17
        self.exit_code = 0
 
18
 
 
19
    def get_exit_code(self):
 
20
        return self.exit_code
 
21
 
 
22
    def get_raw_output(self, command):
 
23
        try:
 
24
            output = subprocess.check_output(command, stderr=subprocess.STDOUT)
 
25
            self.exit_code = 0      
 
26
            return output
 
27
        except subprocess.CalledProcessError as ex:
 
28
            self.exit_code = ex.returncode
 
29
            return ex.output
 
30
        except Exception as e:
 
31
            self.exit_code = 1
 
32
            return "Failed to start {} command".format(command)
 
33
 
 
34
    def get_all_services(self):
 
35
        output = self.get_raw_output(NeadmServiceWrapper._service_list_cmd)
 
36
        #print(output)
 
37
        result = NeadmServiceList()
 
38
        #error exit code
 
39
        if self.exit_code:
 
40
            result.exit_code = self.exit_code
 
41
            result.output = output
 
42
            return result
 
43
      
 
44
        output_array = output.split('\n')
 
45
        for line in output_array:
 
46
            #print(line)    
 
47
            if NeadmServiceWrapper._service_list_header.match(line):
 
48
                continue
 
49
 
 
50
            params = line.split()
 
51
            #print(params)
 
52
            #print(len(params))
 
53
            if len(params) < 4:
 
54
                continue
 
55
 
 
56
            service_record = {}
 
57
        
 
58
            for name in NeadmServiceWrapper._service_list_names:
 
59
                service_record[name] = params[NeadmServiceWrapper._service_list_names.index(name)]
 
60
 
 
61
            #print(node)
 
62
            result.append(service_record) 
 
63
            #remove special chars from colored status 
 
64
            #node['status'] = re.sub("([^A-Z]+)", '', node['status'])    
 
65
            #riesult.append(node)
 
66
            #print(status)
 
67
        return result
 
68
 
 
69
    def exec_cmd(self, cmd_name, cmd):
 
70
        try:
 
71
            print("\t{0} cmd is {1}".format(cmd_name, ' '.join(cmd)))
 
72
            subprocess.check_output(cmd)
 
73
 
 
74
        except Exception as ex:
 
75
            raise Exception('in {0}\nMessage:{1}\nTrace: {2}'.format(self.__class__.__name__, ex.message, traceback.format_exc()))
 
76
 
 
77
    #is node included into service nodes list
 
78
    def is_node_exist(self, service_name, sid):
 
79
        services = self.get_all_services()
 
80
        return services.is_already_in_service(service_name, sid)
 
81
 
 
82
    #is iscsi service already created
 
83
    def is_iscsi_service_exist(self, service_name):
 
84
        services = self.get_all_services()
 
85
        return services.is_service_exist('iscsi', service_name)
 
86
 
 
87
    #is swift service already created
 
88
    def is_swift_service_exist(self, service_name):
 
89
        services = self.get_all_services()
 
90
        return services.is_service_exist('swift', service_name)
 
91
 
 
92
    #create new iscsi(cinder) service by name
 
93
    def create_iscsi_service(self, service_name):
 
94
        cmd  = ['/opt/nedge/neadm/neadm', 'service', 'create', 'iscsi', service_name]
 
95
        if not self.is_iscsi_service_exist(service_name):
 
96
            self.exec_cmd('create_iscsi_service', cmd)
 
97
        else:
 
98
            print("create_iscsi_service: Service {} already exist!".format(service_name))
 
99
 
 
100
    #create new swift service by name
 
101
    def create_swift_service(self, service_name):
 
102
        cmd  = ['/opt/nedge/neadm/neadm', 'service', 'create', 'swift', service_name]
 
103
        if not self.is_swift_service_exist(service_name):
 
104
            self.exec_cmd('create_swift_service', cmd)
 
105
        else:
 
106
            print("create_swift_service: Service {} already exist!".format(service_name))
 
107
 
 
108
    #remove iscsi service by name
 
109
    def delete_iscsi_service(self, service_name):
 
110
        cmd  = ['/opt/nedge/neadm/neadm', 'service', 'delete', 'iscsi', service_name]
 
111
        if self.is_iscsi_service_exist(service_name):
 
112
            self.exec_cmd('delete_iscsi_service', cmd)
 
113
        else:
 
114
            print("remove_iscsi_service: {0} service does not exist".format(service_name))
 
115
 
 
116
    #remove swift service by name 
 
117
    def delete_swift_service(self, service_name):
 
118
        cmd  = ['/opt/nedge/neadm/neadm', 'service', 'delete', 'swift', service_name]
 
119
        if self.is_swift_service_exist(service_name):
 
120
            self.exec_cmd('delete_swift_service', cmd)
 
121
        else:
 
122
            print("remove_swift_service: {0} service does not exist".format(service_name))
 
123
 
 
124
 
 
125
    #enable service if exist
 
126
    def enable_service(self, service_name):
 
127
        cmd  = ['/opt/nedge/neadm/neadm', 'service', 'enable', service_name]
 
128
        service_list = self.get_all_services()
 
129
        if service_list.is_service_exist(service_name):
 
130
            self.exec_cmd('enable_service', cmd)
 
131
        else:
 
132
            print("enable_service: Service {} does not exist".format(service_name))
 
133
 
 
134
    def disable_service(self, service_name):    
 
135
        cmd  = ['/opt/nedge/neadm/neadm', 'service', 'disable', service_name]
 
136
        service_list = self.get_all_services()
 
137
        if service_list.is_service_exist(service_name):
 
138
            self.exec_cmd('disable_service', cmd)
 
139
        else:
 
140
            print("disable_service: Service {} does not exist".format(service_name))
 
141
 
 
142
 
 
143
    def add_node_to_service(self, service_name, sid):
 
144
        cmd  = ['/opt/nedge/neadm/neadm', 'service', 'add', service_name, sid]
 
145
        if not self.is_node_exist(service_name, sid):            
 
146
            self.exec_cmd('add_node_to_service', cmd)
 
147
        else:
 
148
            print("\tadd_node_to_service: Node {0} already exist as service node".format(sid))
 
149
 
 
150
    def add_node_to_cinder_service(self, sid):
 
151
        self.add_node_to_service('nedge-cinder', sid)
 
152
 
 
153
 
 
154
    def remove_node_from_service(self, service_name, sid):
 
155
        cmd  = ['/opt/nedge/neadm/neadm', 'service', 'remove', service_name, sid]
 
156
        if self.is_node_exist(service_name, sid):
 
157
            self.exec_cmd('remove_node_from_service', cmd)         
 
158
        else:
 
159
            print("\tremove_node_from_service: Node {} not exist to remove".format(sid))
 
160
 
 
161
    def remove_node_from_cinder_service(self, sid):
 
162
        self.remove_node_from_service('nedge-cinder', sid)
 
163
 
 
164
    def print_services(self):
 
165
        service_list = self.get_all_services()
 
166
        service_list.show()
 
167
 
 
168
 
 
169
class NeadmServiceList:
 
170
    def __init__(self):
 
171
        #service records array
 
172
        self.service_records = []
 
173
        self.exit_code = 0
 
174
        self.output = ""
 
175
 
 
176
    def is_correct(self):
 
177
        return True if self.exit_code == 0 else False 
 
178
 
 
179
    def get_all(self):
 
180
        return self.service_records
 
181
 
 
182
    def get_iscsi_nodes(self):
 
183
        return filter(lambda service: service['type'] == 'iscsi', self.service_records)
 
184
    
 
185
    def get_iscsi_nodes_by_service_name(self, service_name):
 
186
        return filter(lambda service: service['type'] == 'iscsi' and service['name'] == service_name, self.service_records)
 
187
 
 
188
    def get_swift_nodes(self):
 
189
        return filter(lambda service: service['type'] == 'swift', self.service_records)
 
190
 
 
191
    #is node present into whole services list
 
192
    def is_already_listed(self, sid):
 
193
        return True if filter(lambda service: service['sid'] == sid, self.service_records) else False
 
194
 
 
195
    #is node presented in service already
 
196
    def is_already_in_service(self, service_name, sid):
 
197
        return True if filter(lambda service: service['sid'] == sid and service['name'] == service_name, self.service_records) else False
 
198
 
 
199
    def is_service_exist(self, service_type,  service_name):
 
200
        return True if filter(lambda service: service['name'] == service_name and service['type'] == service_type, self.service_records) else False
 
201
 
 
202
    def append(self, service_record):
 
203
        self.service_records.append(service_record)
 
204
 
 
205
    def show(self):
 
206
        print('TYPE\t\tNAME\t\t\tID\t\t\tSTATE')
 
207
        for record in self.service_records:
 
208
            print("{0:<{col0}}{1:<{col1}}{2:<{col2}}{3:<{col3}}".format(record['type'], record['name'], record['sid'], record['status'], col0=8, col1=20, col2=36, col3=12))
 
209