OrionBaseAction.__init__() - Code Metrics - Inspection of "Additional actions, aliases, rule and testing for..." - StackStorm/st2contrib - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#487)

unknown

created 2016-05-03 16:29 UTC

OrionBaseAction.init() A

↳ Parent: OrionBaseAction

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
c	1
b	0
f	0
dl	0
loc	7
rs	9.4285

# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import time

from st2actions.runners.pythonrunner import Action
from orionsdk import SwisClient


class OrionBaseAction(Action):
    def __init__(self, config):
        super(OrionBaseAction, self).__init__(config)

        self.client = None

        if "orion" not in self.config:
            raise ValueError("Orion host details not in the config.yaml")

    def connect(self, platform):
        """
        Connect to an Orion platform from the packs config.yaml.
        """
        try:
            self.client = SwisClient(
                self.config['orion'][platform]['host'],
                self.config['orion'][platform]['user'],
                self.config['orion'][platform]['password'])
        except KeyError:
            raise ValueError("Orion host details not in the config.yaml")

    def query(self, swql, **kargs):
        """
        Run SWQL against the Orion Platform.
        """
        return self.client.query(swql, **kargs)

    def invoke(self, entity, verb, *args):
        """
        Run an Invoke against the Orion Platform.
        """
        return self.client.invoke(entity, verb, *args)

    def create(self, entity, **kargs):
        """
        Run an Create against the Orion Platform.
        """
        return self.client.create(entity, **kargs)

    def node_exists(self, caption, ip_address):
        """
        Check if an Node exists (caption and or ip) on the Orion platform.

        Returns: True or False.
        """
        swql = """SELECT NodeID, IPAddress FROM Orion.Nodes
                  WHERE Caption=@caption"""
        kargs = {'caption': caption}
        caption_data = self.query(swql, **kargs)

        if len(caption_data['results']) >= 1:
            self.logger.debug(
                "One (or more) Nodes match '{}' Caption.".format(caption))
            return True

        swql = """SELECT NodeID, IPAddress FROM Orion.Nodes
                  WHERE IPAddress=@ip_address"""
        kargs = {'ip_address': ip_address}
        ip_data = self.query(swql, **kargs)

        if len(ip_data['results']) >= 1:
            self.logger.debug(
                "One (or more) Nodes match '{}' IP.".format(ip_address))
            return True
        else:
            return False

    def get_snmp_community(self, community, std_community):
        """
        Return the correct SNMP comminity to use.
        """
        if community is not None:
            return community
        elif std_community is not None:
            try:
                return self.config['defaults']['snmp'][std_community]
            except KeyError:
                raise ValueError("Invalid standard community")
        elif std_community is None:
            raise ValueError("Need one of community or std_community")

    def get_snmp_cred_id(self, community):
        """
        Look up an SNMP community in the config and then look up
        the Orion ID for the Credential.
        """

        # Check if community is a know standard, otherwise
        # use it as the community.
        try:
            name = self.get_snmp_community(None, community)
        except ValueError:
            name = community

        swql = """SELECT ID FROM Orion.Credential
        WHERE CredentialType=@CredentialType and Name=@name"""

        kargs = {'CredentialType':
                 'SolarWinds.Orion.Core.Models.Credentials.SnmpCredentialsV2',
                 'name': name}
        orion_data = self.query(swql, **kargs)

        if len(orion_data['results']) == 1:
            return orion_data['results'][0]['ID']
        else:
            raise ValueError(
                "Failed to lookup community in Orion.Credential!")

    def get_node_id(self, caption):
        """
        Gets an NodeID from the Orion platform.

        Raises: ValueError on muliple or no matching caption.

        Returns: the NodeID (int)
        """
        swql = "SELECT NodeID FROM Orion.Nodes WHERE Caption=@caption"
        kargs = {'caption': caption}
        data = self.query(swql, **kargs)

        if len(data['results']) == 1:
            try:
                return data['results'][0]['NodeID']
            except IndexError:
                raise ValueError("Invalid Node")
        elif len(data['results']) >= 2:
            self.logger.debug(
                "Muliple Nodes match '{}' Caption: {}".format(
                    caption, data))
            raise ValueError("Muliple Nodes match '{}' Caption".format(
                caption))
        elif len(data['results']) == 0:
            self.logger.debug(
                "No Nodes match '{}' Caption: {}".format(
                    caption, data))
            raise ValueError("No matching Caption for '{}'".format(
                caption))

    def get_engine_id(self, poller):
        """
        Takes a poller name (or primary) and returns the EngineID for
        the poller.

        Raises: ValueError on an invaild poller.

        Returns: The EngineID (int)
        """

        if poller == "primary":
            return 1
        else:
            swql = """SELECT EngineID, ServerName, IP, ServerType
            FROM Orion.Engines
            WHERE ServerName=@poller"""
            kargs = {'poller': poller}
            data = self.query(swql, **kargs)

            if len(data['results']) == 1:
                return data['results'][0]['EngineID']
            else:
                self.send_user_error("Invalid poller name")
                raise ValueError("Invalid poller name")

    def get_ncm_node_id(self, caption):
        """
        Queries the Network configuration Manager nodes table on the Orion
        platform for the NodeID of a given node name (aka NodeCaption).

        Raises: IndexError on Invalid number of nodes (e.g. 0 or 2+).

        Returns: A single node id.
        """

        swql = "SELECT NodeID FROM Cirrus.Nodes WHERE NodeCaption=@node"
        kargs = {'node': caption}
        data = self.query(swql, **kargs)

        if len(data['results']) == 1:
            try:
                return data['results'][0]['NodeID']
            except IndexError:
                raise IndexError("Invalid Node")
        elif len(data['results']) >= 2:
            raise IndexError("Muliple Nodes match '{}' NodeCaption".format(
                caption))
        elif len(data['results']) == 0:
            raise IndexError("No matching NodeCaption for '{}'".format(
                caption))

    def get_ncm_transfer_results(self, transfer_id, sleep_delay=10):
        """
        Gets the completed (waits until finished). NCM job transfer status
        from Orion.

        Retruns: The completed status.
        """
        ts = {}
        while True:
            swql = """SELECT TransferID, Action, Status, ErrorMessage,
            DeviceOutput FROM NCM.TransferResults
            WHERE TransferID=@transfer_id"""
            kargs = {'transfer_id': transfer_id}

            transfer_data = self.query(swql, **kargs)
            status = transfer_data['results'][0]['Status']

            if status == 1:
                time.sleep(sleep_delay)
            elif status == 2:
                ts['status'] = "Complete"
                break
            elif status == 3:
                ts['status'] = "Error"
                ts['ErrorMessage'] = transfer_data['results'][0][
                    'ErrorMessage']
                break
            else:
                ts['status'] = "Unknown"
                ts['ErrorMessage'] = "Invalid stauts: {}".format(status)
                break

        return ts

    def status_code_to_text(self, status):
        """
        Takes an Solarwinds Orion status code and translates it to
        human text and also a colour that can be used in Slack.
        """

        if status == 0:
            return ("Unknown", "grey")  # aka slack 'grey'
        elif status == 1:
            return ("Up", "good")  # slack 'good'
        elif status == 2:
            return ("Down", "#7CD197")  # slack 'danger'
        elif status == 3:
            return ("Warning", "warning")  # slack 'warning'
        elif status == 14:
            return ("Critical", "#7CD197")  # slack 'danger'

    def send_user_error(self, message):
        """
        Prints an user error message.
        """
        print(message)


1			# Licensed to the StackStorm, Inc ('StackStorm') under one or more
2			# contributor license agreements. See the NOTICE file distributed with
3			# this work for additional information regarding copyright ownership.
4			# The ASF licenses this file to You under the Apache License, Version 2.0
5			# (the "License"); you may not use this file except in compliance with
6			# the License. You may obtain a copy of the License at
7			#
8			# http://www.apache.org/licenses/LICENSE-2.0
9			#
10			# Unless required by applicable law or agreed to in writing, software
11			# distributed under the License is distributed on an "AS IS" BASIS,
12			# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13			# See the License for the specific language governing permissions and
14			# limitations under the License.
15
16			import time
17
18			from st2actions.runners.pythonrunner import Action
19			from orionsdk import SwisClient
20
21
22			class OrionBaseAction(Action):
23			def __init__(self, config):
24			super(OrionBaseAction, self).__init__(config)
25
26			self.client = None
27
28			if "orion" not in self.config:
29			raise ValueError("Orion host details not in the config.yaml")
30
31			def connect(self, platform):
32			"""
33			Connect to an Orion platform from the packs config.yaml.
34			"""
35			try:
36			self.client = SwisClient(
37			self.config['orion'][platform]['host'],
38			self.config['orion'][platform]['user'],
39			self.config['orion'][platform]['password'])
40			except KeyError:
41			raise ValueError("Orion host details not in the config.yaml")
42
43			def query(self, swql, **kargs):
44			"""
45			Run SWQL against the Orion Platform.
46			"""
47			return self.client.query(swql, **kargs)
48
49			def invoke(self, entity, verb, *args):
50			"""
51			Run an Invoke against the Orion Platform.
52			"""
53			return self.client.invoke(entity, verb, *args)
54
55			def create(self, entity, **kargs):
56			"""
57			Run an Create against the Orion Platform.
58			"""
59			return self.client.create(entity, **kargs)
60
61			def node_exists(self, caption, ip_address):
62			"""
63			Check if an Node exists (caption and or ip) on the Orion platform.
64
65			Returns: True or False.
66			"""
67			swql = """SELECT NodeID, IPAddress FROM Orion.Nodes
68			WHERE Caption=@caption"""
69			kargs = {'caption': caption}
70			caption_data = self.query(swql, **kargs)
71
72			if len(caption_data['results']) >= 1:
73			self.logger.debug(
74			"One (or more) Nodes match '{}' Caption.".format(caption))
75			return True
76
77			swql = """SELECT NodeID, IPAddress FROM Orion.Nodes
78			WHERE IPAddress=@ip_address"""
79			kargs = {'ip_address': ip_address}
80			ip_data = self.query(swql, **kargs)
81
82			if len(ip_data['results']) >= 1:
83			self.logger.debug(
84			"One (or more) Nodes match '{}' IP.".format(ip_address))
85			return True
86			else:
87			return False
88
89			def get_snmp_community(self, community, std_community):
90			"""
91			Return the correct SNMP comminity to use.
92			"""
93			if community is not None:
94			return community
95			elif std_community is not None:
96			try:
97			return self.config['defaults']['snmp'][std_community]
98			except KeyError:
99			raise ValueError("Invalid standard community")
100			elif std_community is None:
101			raise ValueError("Need one of community or std_community")
102
103			def get_snmp_cred_id(self, community):
104			"""
105			Look up an SNMP community in the config and then look up
106			the Orion ID for the Credential.
107			"""
108
109			# Check if community is a know standard, otherwise
110			# use it as the community.
111			try:
112			name = self.get_snmp_community(None, community)
113			except ValueError:
114			name = community
115
116			swql = """SELECT ID FROM Orion.Credential
117			WHERE CredentialType=@CredentialType and Name=@name"""
118
119			kargs = {'CredentialType':
120			'SolarWinds.Orion.Core.Models.Credentials.SnmpCredentialsV2',
121			'name': name}
122			orion_data = self.query(swql, **kargs)
123
124			if len(orion_data['results']) == 1:
125			return orion_data['results'][0]['ID']
126			else:
127			raise ValueError(
128			"Failed to lookup community in Orion.Credential!")
129
130			def get_node_id(self, caption):
131			"""
132			Gets an NodeID from the Orion platform.
133
134			Raises: ValueError on muliple or no matching caption.
135
136			Returns: the NodeID (int)
137			"""
138			swql = "SELECT NodeID FROM Orion.Nodes WHERE Caption=@caption"
139			kargs = {'caption': caption}
140			data = self.query(swql, **kargs)
141
142			if len(data['results']) == 1:
143			try:
144			return data['results'][0]['NodeID']
145			except IndexError:
146			raise ValueError("Invalid Node")
147			elif len(data['results']) >= 2:
148			self.logger.debug(
149			"Muliple Nodes match '{}' Caption: {}".format(
150			caption, data))
151			raise ValueError("Muliple Nodes match '{}' Caption".format(
152			caption))
153			elif len(data['results']) == 0:
154			self.logger.debug(
155			"No Nodes match '{}' Caption: {}".format(
156			caption, data))
157			raise ValueError("No matching Caption for '{}'".format(
158			caption))
159
160			def get_engine_id(self, poller):
161			"""
162			Takes a poller name (or primary) and returns the EngineID for
163			the poller.
164
165			Raises: ValueError on an invaild poller.
166
167			Returns: The EngineID (int)
168			"""
169
170			if poller == "primary":
171			return 1
172			else:
173			swql = """SELECT EngineID, ServerName, IP, ServerType
174			FROM Orion.Engines
175			WHERE ServerName=@poller"""
176			kargs = {'poller': poller}
177			data = self.query(swql, **kargs)
178
179			if len(data['results']) == 1:
180			return data['results'][0]['EngineID']
181			else:
182			self.send_user_error("Invalid poller name")
183			raise ValueError("Invalid poller name")
184
185			def get_ncm_node_id(self, caption):
186			"""
187			Queries the Network configuration Manager nodes table on the Orion
188			platform for the NodeID of a given node name (aka NodeCaption).
189
190			Raises: IndexError on Invalid number of nodes (e.g. 0 or 2+).
191
192			Returns: A single node id.
193			"""
194
195			swql = "SELECT NodeID FROM Cirrus.Nodes WHERE NodeCaption=@node"
196			kargs = {'node': caption}
197			data = self.query(swql, **kargs)
198
199			if len(data['results']) == 1:
200			try:
201			return data['results'][0]['NodeID']
202			except IndexError:
203			raise IndexError("Invalid Node")
204			elif len(data['results']) >= 2:
205			raise IndexError("Muliple Nodes match '{}' NodeCaption".format(
206			caption))
207			elif len(data['results']) == 0:
208			raise IndexError("No matching NodeCaption for '{}'".format(
209			caption))
210
211			def get_ncm_transfer_results(self, transfer_id, sleep_delay=10):
212			"""
213			Gets the completed (waits until finished). NCM job transfer status
214			from Orion.
215
216			Retruns: The completed status.
217			"""
218			ts = {}
219			while True:
220			swql = """SELECT TransferID, Action, Status, ErrorMessage,
221			DeviceOutput FROM NCM.TransferResults
222			WHERE TransferID=@transfer_id"""
223			kargs = {'transfer_id': transfer_id}
224
225			transfer_data = self.query(swql, **kargs)
226			status = transfer_data['results'][0]['Status']
227
228			if status == 1:
229			time.sleep(sleep_delay)
230			elif status == 2:
231			ts['status'] = "Complete"
232			break
233			elif status == 3:
234			ts['status'] = "Error"
235			ts['ErrorMessage'] = transfer_data['results'][0][
236			'ErrorMessage']
237			break
238			else:
239			ts['status'] = "Unknown"
240			ts['ErrorMessage'] = "Invalid stauts: {}".format(status)
241			break
242
243			return ts
244
245			def status_code_to_text(self, status):
246			"""
247			Takes an Solarwinds Orion status code and translates it to
248			human text and also a colour that can be used in Slack.
249			"""
250
251			if status == 0:
252			return ("Unknown", "grey") # aka slack 'grey'
253			elif status == 1:
254			return ("Up", "good") # slack 'good'
255			elif status == 2:
256			return ("Down", "#7CD197") # slack 'danger'
257			elif status == 3:
258			return ("Warning", "warning") # slack 'warning'
259			elif status == 14:
260			return ("Critical", "#7CD197") # slack 'danger'
261
262			def send_user_error(self, message):
263			"""
264			Prints an user error message.
265			"""
266			print(message)
267

StackStorm / st2contrib

Pull Request — master (#487)

OrionBaseAction.__init__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

OrionBaseAction.init() A