--- /dev/null
+##############################################################################
+# Copyright 2017 Parker Berberian and Others #
+# #
+# Licensed 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 requests
+import time
+import calendar
+import json
+from st2reactor.sensor.base import PollingSensor
+
+
+class Pharos_api(PollingSensor):
+ """
+ This class listens to the dashboard and starts/stops bookings accordingly.
+ """
+
+ def getBookingList(self):
+ return json.loads(
+ self.sensor_service.get_value(name='bookings', local=False)
+ )
+
+ def updateBookingList(self, blist):
+ self.sensor_service.set_value(
+ name='bookings',
+ value=json.dumps(blist),
+ local=False
+ )
+
+ def AddBooking(self, new_booking):
+ """
+ checks if booking is in the database, and adds it if it isnt
+ """
+ # first, check if booking is already expired
+ if time.time() > new_booking['end']:
+ return
+ # check if booking already in db
+ booking_list = self.getBookingList()
+ if new_booking['id'] in booking_list:
+ return
+ new_booking['status'] = 0 # add status code
+ booking_list.append(new_booking['id'])
+ name = "booking_" + str(new_booking['id'])
+ self.sensor_service.set_value(
+ name=name,
+ value=json.dumps(new_booking),
+ local=False
+ )
+ self.updateBookingList(booking_list)
+
+ def convertTimes(self, booking):
+ """
+ this method will take the time reported by Pharos in the
+ format yyyy-mm-ddThh:mm:ssZ
+ and convert it into seconds since the epoch,
+ for easier management
+ """
+ booking['start'] = self.pharosToEpoch(booking['start'])
+ booking['end'] = self.pharosToEpoch(booking['end'])
+
+ def pharosToEpoch(self, timeStr):
+ """
+ Converts the dates from the dashboard to epoch time.
+ """
+ time_struct = time.strptime(timeStr, '%Y-%m-%dT%H:%M:%SZ')
+ epoch_time = calendar.timegm(time_struct)
+ return epoch_time
+
+ def checkBookings(self):
+ """
+ This method checks all the bookings in our database to see if any
+ action is required.
+ """
+
+ # get all active bookings from database into a usable form
+ booking_list = self.getBookingList()
+ for booking_id in booking_list:
+ booking = self.getBooking(booking_id)
+ # first, check if booking is over
+ if time.time() > booking['end']:
+ self.log.info("ending the booking with id %i", booking_id)
+ self.endBooking(booking)
+ # Then check if booking has begun and the host is still idle
+ elif time.time() > booking['start'] and booking['status'] < 1:
+ self.log.info("starting the booking with id %i", booking['id'])
+ self.startBooking(booking)
+
+ def startBooking(self, booking):
+ """
+ Starts the scheduled booking on the requested host with
+ the correct config file.
+ The provisioning process gets spun up in a subproccess,
+ so the api listener is not interupted.
+ """
+ host = self.getServer(pharos_id=booking['resource_id'])['hostname']
+ self.log.info("Detected a new booking started for host %s", host)
+ self.setBookingStatus(booking['id'], 1) # mark booking started
+ # dispatch trigger into system
+ trigger = "pharoslaas.start_deployment_trigger"
+ payload = {"host": host, "installer": booking['installer_name']}
+ payload['scenario'] = booking['scenario_name']
+ payload['booking'] = booking['id']
+ self.sensor_service.dispatch(trigger=trigger, payload=payload)
+
+ def endBooking(self, booking):
+ """
+ Resets a host once its booking has ended.
+ """
+ host = self.getServer(pharos_id=booking['resource_id'])['hostname']
+ self.log.info('Lease expired. Resetting host %s', host)
+ self.setBookingStatus(booking['id'], 3)
+ self.removeBooking(booking['id'])
+ # dispatch trigger to clean
+ host = self.getServer(pharos_id=booking['resource_id'])['hostname']
+ trigger = "pharoslaas.end_deployment_trigger"
+ payload = {"host": host, "booking": booking['id']}
+ if 'vpn_key' in booking.keys():
+ payload['key'] = booking['vpn_key']
+ else:
+ payload['key'] = ''
+ self.sensor_service.dispatch(trigger=trigger, payload=payload)
+
+ def getServer(self, fog_name=None, hostname=None, pharos_id=None):
+ key = ""
+ value = ""
+ if fog_name is not None:
+ key = "fog_name"
+ value = fog_name
+ elif hostname is not None:
+ key = "hostname"
+ value = hostname
+ elif pharos_id is not None:
+ key = "pharos_id"
+ value = pharos_id
+ for server in self.servers:
+ if server[key] == value:
+ return server
+
+ def getBooking(self, booking_id):
+ name = "booking_" + str(booking_id)
+ return json.loads(
+ self.sensor_service.get_value(
+ name=name,
+ local=False
+ )
+ )
+
+ def setBookingStatus(self, booking_id, status):
+ booking = self.getBooking(booking_id)
+ booking['status'] = status
+ name = "booking_" + str(booking_id)
+ self.sensor_service.set_value(
+ name=name,
+ value=json.dumps(booking),
+ local=False
+ )
+
+ def removeBooking(self, booking_id):
+ blist = self.getBookingList()
+ blist.remove(booking_id)
+ self.updateBookingList(blist)
+ name = "booking_" + str(booking_id)
+ self.sensor_service.delete_value(name=name, local=False)
+
+ # Sensor Interface Methods #
+
+ def setup(self):
+ """
+ This method is called by stackstorm once to setup this polling sensor.
+ Basically __init__, assigns instance variables, etc
+ """
+ server_names = json.loads(
+ self.sensor_service.get_value('hosts', local=False)
+ )
+ self.servers = []
+ for server in server_names:
+ self.servers.append(
+ json.loads(
+ self.sensor_service.get_value(server, local=False)
+ )
+ )
+ self.resource_ids = []
+ for host in self.servers:
+ self.resource_ids.append(host['pharos_id'])
+ self.log = self.sensor_service.get_logger(name=self.__class__.__name__)
+ self.dashboard = self.sensor_service.get_value(
+ name='dashboard_url',
+ local=False
+ )
+ self.log.info("connecting to dashboard at %s", self.dashboard)
+ # get token here for when dashboard supports it
+
+ def poll(self):
+ """
+ this method will continuously poll the pharos dashboard.
+ If a booking is found on our server,
+ we will start a deployment in the background with the
+ proper config file for the requested
+ installer and scenario.
+ """
+ self.log.debug("%s", "Beginning polling of dashboard")
+ try:
+ url = self.dashboard+"/api/bookings/"
+ bookings = requests.get(url).json()
+ for booking in bookings:
+ if booking['resource_id'] in self.resource_ids:
+ self.convertTimes(booking)
+ self.AddBooking(booking)
+ self.checkBookings()
+ except Exception:
+ self.log.exception('%s', "failed to connect to dashboard")
+
+ def cleanup(self):
+ # called when st2 goes down
+ pass
+
+ def add_trigger(self, trigger):
+ # called when trigger is created
+ pass
+
+ def update_trigger(self, trigger):
+ # called when trigger is updated
+ pass
+
+ def remove_trigger(self, trigger):
+ # called when trigger is deleted
+ pass
Code Review / pharos-tools.git / blobdiff