Merge pull request #22 from rubenvp8510/travis

Setting up Travis CI

Author: burmanm

.travis.yml

@@ -0,0 +1,21 @@
+sudo: required
+
+language: python
+python:
+  - "2.7"
+  - "3.4"
+
+services:
+  - docker
+
+before_install:
+  - sudo apt-get install jq
+  - ./.travis/run_hawkular.sh
+env:
+  global:
+    - PYTHONPATH=.
+  matrix:
+    - HAWKULAR_VERSION=latest
+    - HAWKULAR_VERSION=0.15
+
+script: pytest

.travis/run_hawkular.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+
+WAIT_STEP=3
+MAX_STEPS=120
+LOWER_VERSION="0.15"
+
+if [[ -z ${HAWKULAR_VERSION+x} ]]; then
+    HAWKULAR_VERSION='latest'
+fi
+
+HAWKULAR_IMAGE=rubensvp/hawkular-metrics:${HAWKULAR_VERSION}
+
+function metrics_status {
+    curl -s http://localhost:8080/hawkular/metrics/status | jq -r '.MetricsService'  2> /dev/null
+}
+
+function alerts_status {
+    curl -s http://localhost:8080/hawkular/alerts/status | jq -r '.status' 2> /dev/null
+}
+
+function cassandra_status {
+    docker exec hawkular-cassandra nodetool statusbinary  | tr -dc '[[:print:]]'  2> /dev/null
+}
+
+function wait_hawkular {
+    METRICS_STATUS=$(metrics_status)
+    ALERTS_STATUS=$(alerts_status)
+    TOTAL_WAIT=0
+    echo "Starting hawkular metrics $HAWKULAR_VERSION ..."
+    while ([ "$METRICS_STATUS" != "STARTED" ] || ( [ "$ALERTS_STATUS" != "STARTED" ] && [ "$HAWKULAR_VERSION" != "$LOWER_VERSION" ]) )  && [ ${TOTAL_WAIT} -lt ${MAX_STEPS} ]; do
+        METRICS_STATUS=$(metrics_status)
+        ALERTS_STATUS=$(alerts_status)
+        sleep ${WAIT_STEP}
+        if [[ "$HAWKULAR_VERSION" == "$LOWER_VERSION" ]]; then
+            echo "Hawkular server status, metrics: $METRICS_STATUS"
+        else
+            echo "Hawkular server status, metrics: $METRICS_STATUS, alerts: $ALERTS_STATUS"
+        fi
+        TOTAL_WAIT=$((TOTAL_WAIT+WAIT_STEP))
+        echo "Waited $TOTAL_WAIT seconds for Hawkular metrics to start."
+    done
+}
+
+function launch_hawkular {
+    docker run --name hawkular-metrics -p 8080:8080 --link hawkular-cassandra -d  ${HAWKULAR_IMAGE}
+}
+
+function launch_cassandra {
+    docker run --name  hawkular-cassandra  -e CASSANDRA_START_RPC=true -d cassandra:3.7
+}
+
+function wait_cassandra {
+    CASSANDRA_STATUS=$(cassandra_status)
+    TOTAL_WAIT=0;
+    while [ "$CASSANDRA_STATUS" != "running" ] && [ ${TOTAL_WAIT} -lt ${MAX_STEPS} ]; do
+        CASSANDRA_STATUS=$(cassandra_status)
+        echo "Cassandra server status: $CASSANDRA_STATUS."
+        sleep ${WAIT_STEP}
+        TOTAL_WAIT=$((TOTAL_WAIT+WAIT_STEP))
+        echo "Waited $TOTAL_WAIT seconds for Cassandra to start."
+    done
+}
+
+launch_cassandra
+wait_cassandra
+launch_hawkular
+wait_hawkular

hawkular/alerts.py

@@ -14,9 +14,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 """
-
-from client import ApiOject, HawkularBaseClient
-
+from hawkular.client import ApiOject, HawkularBaseClient
 
 class Trigger(ApiOject):
     __slots__ = [

hawkular/client.py

@@ -56,7 +56,11 @@ def __init__(self, dictionary=dict()):
             setattr(self, k, udict.get(k,self.defaults.get(k)))
 
     def to_json_object(self):
-        return ApiOject.transform_dict_to_camelcase(self.__dict__)
+        dictionary = {}
+        for attribute in self.__slots__:
+            if hasattr(self,attribute):
+                dictionary[attribute] = getattr(self,attribute)
+        return ApiOject.transform_dict_to_camelcase(dictionary)
 
     @staticmethod
     def _to_camelcase(word):
@@ -71,13 +75,13 @@ def _to_underscore(word):
     def transform_dict_to_camelcase(dictionary):
         if dictionary is None:
             return dict()
-        return dict((ApiOject._to_camelcase(k), v) for k, v in dictionary.iteritems() if v is not None)
+        return dict((ApiOject._to_camelcase(k), v) for k, v in dictionary.items() if v is not None)
 
     @staticmethod
     def transform_dict_to_underscore(dictionary):
         if dictionary is None:
             return dict()
-        return dict((ApiOject._to_underscore(k), v) for k, v in dictionary.iteritems() if v is not None)
+        return dict((ApiOject._to_underscore(k), v) for k, v in dictionary.items() if v is not None)
 
     @classmethod
     def list_to_object_list(cls, o):
@@ -171,8 +175,9 @@ def _http(self, url, method, data=None, decoder=None):
         if self.token is not None:
             req.add_header('Authorization', 'Bearer {0}'.format(self.token))
         elif self.username is not None:
+            b64 = base64.b64encode(bytes(self.username + ':' + self.password, encoding='utf-8'))
             req.add_header('Authorization',
-                           'Basic {0}'.format(base64.b64encode(self.username + b':' + self.password)))
+                           'Basic {0}'.format(b64))
 
         if not isinstance(data, str):
             data = json.dumps(data, indent=2)

hawkular/metrics.py

@@ -98,7 +98,8 @@ def __init__(self,
                  token=None,
                  username=None,
                  password=None,
-                 auto_set_legacy_api=True):
+                 auto_set_legacy_api=True,
+                 authtoken=None):
         """
         A new instance of HawkularMetricsClient is created with the following defaults:
 
@@ -123,6 +124,7 @@ def __init__(self,
         self.username = username
         self.password = password
         self.legacy_api = False
+        self.authtoken = authtoken
 
         opener = build_opener(HawkularHTTPErrorProcessor())
         install_opener(opener)
@@ -185,6 +187,9 @@ def _http(self, url, method, data=None):
             elif self.username is not None:
                 req.add_header('Authorization', 'Basic {0}'.format(base64.b64encode(self.username + b':' + self.password)))
 
+            if self.authtoken is not None:
+                req.add_header('Hawkular-Admin-Token', self.authtoken)
+
             if not isinstance(data, str):
                 data = json.dumps(data, indent=2)
 

tests/__init__.py

@@ -0,0 +1,10 @@
+import os
+
+version = os.environ.get('HAWKULAR_VERSION','latest')
+
+if version != 'latest':
+    major_version, minor_version = version.split('.')
+    major_version = int(major_version)
+    minor_version = int(minor_version)
+else:
+    major_version = minor_version = 0

tests/base.py

@@ -18,20 +18,22 @@
 
 import unittest
 import uuid
-from alerts import *
+from hawkular.alerts import *
+import os
+from tests import base
 
 
 class TestAlertsFunctionsBase(unittest.TestCase):
     def setUp(self):
         self.maxDiff = None
         self.test_tenant = str(uuid.uuid4())
         self.client = HawkularAlertsClient(tenant_id=self.test_tenant,
-                                           port=8080,
-                                           username='jdoe',
-                                           password='password')
+                                           port=8080)
 
 
-class MetricsTestCase(TestAlertsFunctionsBase):
+@unittest.skipIf(base.version != 'latest' and base.major_version == 0 and base.minor_version <= 15,
+                 'Not supported in ' + base.version + ' version')
+class AlertsTestCase(TestAlertsFunctionsBase):
     def test_trigger_creation(self):
         trigger = Trigger()
         trigger.id = 'id_1'

hawkular/alerts_test.py tests/test_alerts.pyhawkular/alerts_test.py renamed to tests/test_alerts.py

@@ -18,37 +18,42 @@
 
 import unittest
 import uuid
-from metrics import *
+from  hawkular.metrics import *
+import os
+
+from tests import base
 
-class TestMetricFunctionsBase(unittest.TestCase):
 
+class TestMetricFunctionsBase(unittest.TestCase):
     def setUp(self):
         self.maxDiff = None
         self.test_tenant = str(uuid.uuid4())
-        self.client = HawkularMetricsClient(tenant_id=self.test_tenant, port=8080)
-        
+        self.client = HawkularMetricsClient(tenant_id=self.test_tenant, port=8080, authtoken='secret')
+
+
 class TenantTestCase(TestMetricFunctionsBase):
     """
     Test creating and fetching tenants. Each creation test should also
     fetch the tenants to test that functionality also
     """
-    
+
     def test_tenant_creation(self):
         tenant = str(uuid.uuid4())
         self.client.create_tenant(tenant)
         tenants = self.client.query_tenants()
 
-        expect = { 'id': tenant }
+        expect = {'id': tenant}
         self.assertIn(expect, tenants)
 
     def test_tenant_creation_with_retentions(self):
         tenant = str(uuid.uuid4())
-        retentions = { 'gauge': 8, 'availability': 30 }
+        retentions = {'gauge': 8, 'availability': 30}
         self.client.create_tenant(tenant, retentions)
 
-        expect = { 'id': tenant, 'retentions': { 'gauge': 8, 'availability': 30 } }
+        expect = {'id': tenant, 'retentions': {'gauge': 8, 'availability': 30}}
         self.assertIn(expect, self.client.query_tenants())
-        
+
+
 class MetricsTestCase(TestMetricFunctionsBase):
     """
     Test metric functionality, both adding definition and querying for definition, 
@@ -62,7 +67,7 @@ def find_metric(self, name, definitions):
         for defin in definitions:
             if defin['id'] == name:
                 return defin
-    
+
     def test_gauge_creation(self):
         """
         Test creating gauge metric definitions with different tags and definition.
@@ -72,7 +77,8 @@ def test_gauge_creation(self):
 
         md1 = self.client.create_metric_definition(MetricType.Gauge, id_name.format('1'))
         md2 = self.client.create_metric_definition(MetricType.Gauge, id_name.format('2'), dataRetention=90)
-        md3 = self.client.create_metric_definition(MetricType.Gauge, id_name.format('3'), dataRetention=90, units='bytes', env='qa')
+        md3 = self.client.create_metric_definition(MetricType.Gauge, id_name.format('3'), dataRetention=90,
+                                                   units='bytes', env='qa')
         self.assertTrue(md1)
         self.assertTrue(md2)
         self.assertTrue(md3)
@@ -88,8 +94,8 @@ def test_gauge_creation(self):
 
         # This is what the returned dict should look like
         expect = [
-            { 'dataRetention': 7, 'type': 'gauge', 'id': 'test.create.gauge.1',
-             'tenantId': self.test_tenant },
+            {'dataRetention': 7, 'type': 'gauge', 'id': 'test.create.gauge.1',
+             'tenantId': self.test_tenant},
             {'dataRetention': 90, 'type': 'gauge', 'id': 'test.create.gauge.2', 'tenantId': self.test_tenant},
             {'tags': {'units': 'bytes', 'env': 'qa'},
              'id': 'test.create.gauge.3', 'dataRetention': 90, 'type': 'gauge', 'tenantId': self.test_tenant}]
@@ -109,7 +115,7 @@ def test_availability_creation(self):
         self.client.create_metric_definition(MetricType.Availability, id_name.format('2'), dataRetention=90)
         self.client.create_metric_definition(MetricType.Availability, id_name.format('3'), dataRetention=94, env='qa')
         # Fetch metrics and check that it did appear
-        m = self.client.query_metric_definitions(MetricType.Availability)        
+        m = self.client.query_metric_definitions(MetricType.Availability)
         self.assertEqual(3, len(m))
 
         avail_3 = self.find_metric(id_name.format('3'), m)
@@ -135,7 +141,7 @@ def test_tags_modifications(self):
         self.assertEqual(0, len(tags_2))
 
     def test_tags_queries(self):
-        for i in range(1,9):
+        for i in range(1, 9):
             m_id = 'test.query.tags.{}'.format(i)
             hostname = 'host{}'.format(i)
             self.client.create_metric_definition(MetricType.Counter, m_id, hostname=hostname, env='qa')
@@ -170,22 +176,24 @@ def test_add_availability_single(self):
 
         up = self.client.query_metric(MetricType.Availability, 'test.avail.1')
         self.assertEqual(up[0]['value'], 'up')
-        
+
         down = self.client.query_metric(MetricType.Availability, 'test.avail.2')
         self.assertEqual(down[0]['value'], Availability.Down)
 
+    @unittest.skipIf(base.version != 'latest' and base.major_version == 0 and base.minor_version <= 15,
+                     'Not supported in ' + base.version + ' version')
     def test_add_string_single(self):
         self.client.push(MetricType.String, 'test.string.1', "foo")
         data = self.client.query_metric(MetricType.String, 'test.string.1')
         self.assertEqual(data[0]["value"], 'foo')
-        
+
     def test_add_gauge_multi_datapoint(self):
         metric_1v = create_datapoint(float(1.45))
         metric_2v = create_datapoint(float(2.00), (time_millis() - 2000))
 
         metric = create_metric(MetricType.Gauge, 'test.gauge.multi', [metric_1v, metric_2v])
         self.client.put(metric)
-        
+
         data = self.client.query_metric(MetricType.Gauge, 'test.gauge.multi')
         self.assertEqual(len(data), 2)
         self.assertEqual(data[0]['value'], float(1.45))
@@ -197,7 +205,7 @@ def test_add_availability_multi_datapoint(self):
         down = create_datapoint('down', t)
 
         m = create_metric(MetricType.Availability, 'test.avail.multi', [up, down])
-        
+
         self.client.put(m)
         data = self.client.query_metric(MetricType.Availability, 'test.avail.multi')
 
@@ -212,7 +220,7 @@ def test_add_mixed_metrics_and_datapoints(self):
         metric_multi = create_metric(MetricType.Gauge, 'test.multi.gauge.1', [metric1, metric1_2])
 
         metric2 = create_datapoint(Availability.Up)
-        metric2_multi = create_metric(MetricType.Availability,'test.multi.gauge.2', [metric2])
+        metric2_multi = create_metric(MetricType.Availability, 'test.multi.gauge.2', [metric2])
 
         self.client.put([metric_multi, metric2_multi])
 
@@ -237,7 +245,7 @@ def test_query_options(self):
         self.assertEqual(2, len(d))
 
         # Query for data which has start time limitation
-        d = self.client.query_metric(MetricType.Gauge, 'test.query.gauge.1', start=(t-1000))
+        d = self.client.query_metric(MetricType.Gauge, 'test.query.gauge.1', start=(t - 1000))
         self.assertEqual(1, len(d))
 
     def test_tenant_changing(self):
@@ -278,5 +286,6 @@ def test_get_metrics_stats_url(self):
         url = self.client._get_metrics_stats_url('some.key')
         self.assertEqual('some.key/stats', url)
 
+
 if __name__ == '__main__':
     unittest.main()