def test_deny_unverified_by_default(httpsserver):
"""Ensure that we throw an error by default for self-signed servers."""
api = Api(domain=httpsserver.url)
with pytest.raises(HttpCouldNotVerifyServerError):
api.login('*****@*****.**', 'test')
with pytest.raises(HttpCouldNotVerifyServerError):
api.logout()
with pytest.raises(HttpCouldNotVerifyServerError):
api.refresh_token()
# Also ensure that the RestResource works as well
resource = api.event
with pytest.raises(HttpCouldNotVerifyServerError):
resource.get()
with pytest.raises(HttpCouldNotVerifyServerError):
resource.put()
with pytest.raises(HttpCouldNotVerifyServerError):
resource.patch()
with pytest.raises(HttpCouldNotVerifyServerError):
resource.post()
with pytest.raises(HttpCouldNotVerifyServerError):
resource.delete()
def test_mock_cloud_login(water_meter):
"""Make sure the mock cloud is working."""
domain, cloud = water_meter
api = Api(domain=domain, verify=False)
res = api.login('test', '*****@*****.**')
assert res
acc = api.account.get()
print(acc)
assert len(acc['results']) == 1
assert acc['results'][0] == {
"id": 1,
"email": "unknown email",
"username": "******",
"name": "unknown name",
"slug": "unknown slug"
}
res = api.login('test2', '*****@*****.**')
assert not res
res = api.login('test', '[email protected]')
assert not res
def test_list_devices(mock_cloud_private_nossl):
"""Make sure we can list and filter devices."""
domain, cloud = mock_cloud_private_nossl
api = Api(domain=domain)
cloud.quick_add_user('*****@*****.**', 'test')
api.login('test', '*****@*****.**')
proj_id1, _slug1 = cloud.quick_add_project()
device_slug1_1 = cloud.quick_add_device(proj_id1, 15)
device_slug1_2 = cloud.quick_add_device(proj_id1, 20)
proj_id2, _slug2 = cloud.quick_add_project()
device_slug2_1 = cloud.quick_add_device(proj_id2)
device_slug2_2 = cloud.quick_add_device(proj_id2)
device_slug2_3 = cloud.quick_add_device(proj_id2)
res = api.device.get()
assert len(res['results']) == 5
res = api.device.get(project=proj_id1)
devs = set([x['slug'] for x in res['results']])
assert device_slug1_1 in devs and device_slug1_2 in devs and len(devs) == 2
res = api.device.get(project=proj_id2)
devs = set([x['slug'] for x in res['results']])
assert device_slug2_1 in devs and device_slug2_2 in devs and device_slug2_3 in devs and len(
devs) == 3
def test_quick_add_functionality(mock_cloud_private_nossl):
"""Make sure quick add functions work."""
domain, cloud = mock_cloud_private_nossl
api = Api(domain=domain)
res = api.login('test', '*****@*****.**')
assert res is False
cloud.quick_add_user('*****@*****.**', 'test')
res = api.login('test', '*****@*****.**')
assert res is True
proj_id, slug = cloud.quick_add_project()
proj_data = api.project(proj_id).get()
assert proj_data['id'] == proj_id
assert proj_data['slug'] == slug
org_data = api.org(proj_data['org']).get()
assert org_data['slug'] == "quick-test-org"
# Make sure quick add streamer works (Issue 28)
slug = cloud.quick_add_streamer(1, 0, 10)
resp = api.streamer(slug).get()
print(resp)
assert resp['last_id'] == 10
def test_get_sg_dt(mock_cloud_private_nossl):
domain, cloud = mock_cloud_private_nossl
api = Api(domain=domain)
cloud.quick_add_user('*****@*****.**', 'test')
api.login('test', '*****@*****.**')
sg_slug = cloud.quick_add_sg(slug="test-sg", app_tag=1027)
dt_slug = cloud.quick_add_dt(slug="test-dt", os_tag=1027)
assert api.sg(sg_slug).get()['slug'] == "test-sg"
assert api.dt(dt_slug).get()['slug'] == "test-dt"
def test_upload_report(mock_cloud_private_nossl):
"""Make sure we can upload data."""
domain, cloud = mock_cloud_private_nossl
api = Api(domain=domain)
cloud.quick_add_user('*****@*****.**', 'test')
api.login('test', '*****@*****.**')
inpath = os.path.join(os.path.dirname(__file__), 'reports',
'report_100readings_10dev.bin')
with open(inpath, "rb") as infile:
data = infile.read()
timestamp = '{}'.format(cloud._fixed_utc_timestr())
payload = {'file': BytesIO(data)}
resource = api.streamer.report
headers = {}
authorization_str = '{0} {1}'.format(api.token_type, api.token)
headers['Authorization'] = authorization_str
# Make sure there are no reports
resp = api.streamer.report.get()
assert len(resp['results']) == 0
resp = requests.post(resource.url(),
files=payload,
headers=headers,
params={'timestamp': timestamp})
resp = resource._process_response(resp)
# Verify that the response contains a count record
assert resp['count'] == 100
# Verify the streamer record exists
resp = api.streamer('t--0000-0000-0000-000a--0001').get()
assert resp['last_id'] == 100
assert resp['selector'] == 0xABCD
# Verify the report record exists and that the raw file is saved
resp = api.streamer.report.get()
assert len(resp['results']) == 1
rep_id = resp['results'][0]['id']
report = api.streamer.report(rep_id).get()
assert report['id'] == rep_id
assert cloud.raw_report_files[rep_id] == data
def test_data_access(water_meter):
"""Make sure we can load and access data."""
domain, _cloud = water_meter
api = Api(domain=domain, verify=False)
api.login('test', '*****@*****.**')
data = api.device('d--0000-0000-0000-00d2').get()
assert data['slug'] == 'd--0000-0000-0000-00d2'
data = api.datablock('b--0001-0000-0000-04e7').get()
assert data['slug'] == 'b--0001-0000-0000-04e7'
stream = api.stream('s--0000-0077--0000-0000-0000-00d2--5002').get()
assert stream['slug'] == 's--0000-0077--0000-0000-0000-00d2--5002'
proj = api.project('1c07fdd0-3fad-4549-bd56-5af2aca18d5b').get()
assert proj['slug'] == 'p--0000-0077'
events = api.event.get(filter="s--0000-0077--0000-0000-0000-00d2--5001")
res = events['results']
assert len(res) == 3
raw1 = api.event(1).data.get()
assert raw1 == {"test": 1, "hello": 2}
raw2 = api.event(2).data.get()
assert raw2 == {"test": 1, "goodbye": 15}
api.vartype('water-meter-volume').get()
extra = api.device('d--0000-0000-0000-00d2').extra.get()
counts = extra.get('stream_counts')
print(counts)
assert counts is not None
assert len(counts) == 3
assert counts['s--0000-0077--0000-0000-0000-00d2--5001']['data_cnt'] == 11
assert counts['s--0000-0077--0000-0000-0000-00d2--5001'][
'has_streamid'] is True
assert counts['s--0000-0077--0000-0000-0000-00d2--5002']['data_cnt'] == 3
assert counts['s--0000-0077--0000-0000-0000-00d2--5002'][
'has_streamid'] is True
assert counts['s--0000-0077--0000-0000-0000-00d2--5c00']['data_cnt'] == 4
assert counts['s--0000-0077--0000-0000-0000-00d2--5c00'][
'has_streamid'] is False
def link_cloud(self, username=None, password=None, device_id=None):
"""Create and store a token for interacting with the IOTile Cloud API.
You will need to call link_cloud once for each virtualenv that
you create and want to use with any api calls that touch iotile cloud.
Note that this method is called on a ConfigManager instance
If you do not pass your username or password it will be prompted from
you securely on stdin.
If you are logging in for a user, the token will expire periodically and you
will have to relogin.
If you pass a device_id, you can obtain a limited token for that device
that will never expire, assuming you have access to that device.
Args:
username (string): Your iotile.cloud username. This is prompted
from stdin if not provided.
password (string): Your iotile.cloud password. This is prompted
from stdin if not provided.
device_id (int): Optional device id to obtain permanent credentials
for a device.
"""
reg = ComponentRegistry()
domain = self.get('cloud:server')
if username is None:
# Both python 2 and 3 require native strings to be passed into getpass
prompt_str = "Please enter your IOTile.cloud email: "
if sys.version_info.major < 3:
prompt_str = prompt_str.encode('utf-8')
username = input(prompt_str)
if password is None:
# Both python 2 and 3 require native strings to be passed into getpass
prompt_str = "Please enter your IOTile.cloud password: "******"Could not login to iotile.cloud as user %s" %
username)
reg.set_config('arch:cloud_user', cloud.username)
reg.set_config('arch:cloud_token', cloud.token)
reg.set_config('arch:cloud_token_type', cloud.token_type)
if device_id is not None:
cloud = IOTileCloud()
cloud.impersonate_device(device_id)
def test_device_patch(mock_cloud_private_nossl):
"""Make sure we can patch device data"""
domain, cloud = mock_cloud_private_nossl
api = Api(domain=domain)
cloud.quick_add_user('*****@*****.**', 'test')
api.login('test', '*****@*****.**')
proj_id, _slug = cloud.quick_add_project()
device_slug = cloud.quick_add_device(proj_id, 15)
assert api.device(
'd--0000-0000-0000-000f').get()['sg'] == 'water-meter-v1-1-0'
payload = {'sg': 'water-meter-v1-1-1'}
api.device('d--0000-0000-0000-000f').patch(payload)
assert api.device(
'd--0000-0000-0000-000f').get()['sg'] == 'water-meter-v1-1-1'
def test_http_support(water_meter_http):
"""Make sure we can use the cloud over http as well."""
domain, cloud = water_meter_http
api = Api(domain=domain, verify=False)
res = api.login('test', '*****@*****.**')
assert res
def test_allow_unverified_option(httpsserver):
"""Ensure that we allow unverified servers if the user passes a flag."""
api = Api(domain=httpsserver.url, verify=False)
api.login('*****@*****.**', 'test')
api.logout()
api.refresh_token()
# Also ensure that the RestResource works as well
resource = api.event
resource.get()
resource.put()
resource.patch()
resource.post()
resource.delete()
def test_login(self, m):
payload = {'jwt': 'big-token', 'username': '******'}
m.post('http://iotile.test/api/v1/auth/login/',
text=json.dumps(payload))
api = Api(domain='http://iotile.test')
ok = api.login(email='*****@*****.**', password='******')
self.assertTrue(ok)
self.assertEqual(api.username, 'user1')
self.assertEqual(api.token, 'big-token')
def test_data_stream(water_meter):
"""Make sure we can load and access data."""
domain, _cloud = water_meter
api = Api(domain=domain, verify=False)
api.login('test', '*****@*****.**')
data = api.data.get(filter='s--0000-0077--0000-0000-0000-00d2--5001')
assert data['count'] == 11
first = data['results'][0]
assert first['project'] == 'p--0000-0077'
assert first['device'] == 'd--0000-0000-0000-00d2'
assert first['stream'] == 's--0000-0077--0000-0000-0000-00d2--5001'
assert first['value'] == 37854.1
assert first['int_value'] == 100
data2 = api.data.get(filter='s--0000-0077--0000-0000-0000-00d2--5c00')
assert data2['count'] == 4
def test_data_frame(water_meter):
"""Make sure we can load and access data."""
domain, _cloud = water_meter
api = Api(domain=domain, verify=False)
api.login('test', '*****@*****.**')
data = api.df.get(filter='s--0000-0077--0000-0000-0000-00d2--5001',
format='csv')
data = data.decode('utf-8')
lines = data.split('\n')
assert len(lines) == 12
data = [x.split(',') for x in lines]
assert data[0] == ['row', 'int_value', 'stream_slug']
assert data[1] == [
'2017-04-11T20:37:29.608972Z', '37854.1',
's--0000-0077--0000-0000-0000-00d2--5001'
]
def test_quick_add_fleet(mock_cloud_private_nossl):
"""Make sure we can add, list and filter fleets."""
domain, cloud = mock_cloud_private_nossl
api = Api(domain=domain)
cloud.quick_add_user('*****@*****.**', 'test')
api.login('test', '*****@*****.**')
proj, _slug = cloud.quick_add_project()
dev1 = cloud.quick_add_device(proj, 1)
dev2 = cloud.quick_add_device(proj)
dev3 = cloud.quick_add_device(proj)
dev4 = cloud.quick_add_device(proj)
fleet = cloud.quick_add_fleet([1, (dev2, False, False), (dev3, True)],
True)
fleet2 = cloud.quick_add_fleet([dev2])
# Make sure we can list
res = api.fleet.get()
assert len(res['results']) == 2
# Make sure we can get a single fleet
fleet_data = api.fleet(fleet).get()
assert fleet_data == cloud.fleets[fleet]
# Make sure we can get all fleets containing a device
res = api.fleet().get(device=dev1)
assert len(res['results']) == 1
assert res['results'][0]['slug'] == fleet
res = api.fleet().get(device=dev4)
assert len(res['results']) == 0
res = api.fleet().get(device=dev2)
assert len(res['results']) == 2
# Make sure we can get all devices in a fleet
res = api.fleet(fleet).devices.get()
assert len(res['results']) == 3
def test_logout(self, m):
payload = {'jwt': 'big-token', 'username': '******'}
# login works only if there is no Authorization header in the request
def match_request_headers(request):
return 'Authorization' not in request.headers
m.post('http://iotile.test/api/v1/auth/login/',
additional_matcher=match_request_headers,
text=json.dumps(payload))
m.post('http://iotile.test/api/v1/auth/logout/', status_code=204)
api = Api(domain='http://iotile.test')
ok = api.login(email='*****@*****.**', password='******')
self.assertTrue(ok)
api.logout()
self.assertEqual(api.username, None)
self.assertEqual(api.token, None)
# can log in again
ok = api.login(email='*****@*****.**', password='******')
self.assertTrue(ok)
def test_quick_add_device(mock_cloud_private_nossl):
"""Make sure quick_add_device works."""
domain, cloud = mock_cloud_private_nossl
api = Api(domain=domain)
cloud.quick_add_user('*****@*****.**', 'test')
api.login('test', '*****@*****.**')
res = api.streamer.get()
assert len(res['results']) == 0
proj_id, slug = cloud.quick_add_project()
device_slug15 = cloud.quick_add_device(proj_id, 15, streamers=[10, 15])
device_slug20 = cloud.quick_add_device(proj_id, 20, streamers=[1])
device_slug = cloud.quick_add_device(proj_id)
res = api.streamer.get()
assert len(res['results']) == 3
res = api.streamer.get(device=device_slug15)
assert len(res['results']) == 2
res = api.streamer('t--0000-0000-0000-000f--0001').get()
assert res['last_id'] == 15
assert res['device'] == device_slug15
assert res['is_system'] is True
with pytest.raises(HttpNotFoundError):
api.streamer('t--0000-0000-0000-0015--0001').get()
res = api.device(device_slug15).get()
assert res['slug'] == device_slug15
res = api.device(device_slug20).get()
assert res['slug'] == device_slug20
logger.error(e)
sys.exit(1)
if not args.t1:
t1 = datetime.utcnow()
else:
try:
t1 = dt_parse(args.t1)
except Exception as e:
logger.error(e)
sys.exit(1)
password = getpass.getpass()
domain = PRODUCTION_DOMAIN_NAME
logger.info('Using Server: {0}'.format(domain))
c = Api(domain)
ok = c.login(email=args.email, password=password)
if ok:
logger.info('Welcome {0}'.format(args.email))
gen = AccumulationReportGenerator(c)
stats =gen.compute_sum(sources=args.sources, start=t0, end=t1)
pprint(stats)
logger.info('Goodbye!!')
c.logout()
class IOTileCloud:
"""High level routines for interacting with IOTile cloud.
Normally, you can create one of these objects with no arguments
and the iotile.cloud server and authentication details will
be pulled from the ComponentRegistry. However, you can force
a specific domain by passing the optional domain arguments.
If there are no stored credentials in ComponentRegistry, the
user will be prompted for a password on the command line IF
the session is interactive, otherwise __init__ will fail.
Args:
domain (str): Optional server domain. If not specified,
the default will be whatever is stored in the registry
username (str): Optional username to force the user to use
if they don't have stored credentials
"""
DEVICE_TOKEN_TYPE = 'a-jwt'
def __init__(self, domain=None, username=None, **kwargs):
reg = ComponentRegistry()
conf = ConfigManager()
if domain is None:
domain = conf.get('cloud:server')
self.api = Api(domain=domain, **kwargs)
self._domain = self.api.domain
try:
token = reg.get_config('arch:cloud_token')
token_type = reg.get_config('arch:cloud_token_type', default='jwt')
self.api.set_token(token, token_type=token_type)
except ArgumentError:
# If we are interactive, try to get the user to login for a single
# session rather than making them call link_cloud to store a cloud token
if type_system.interactive:
username, password = self._prompt_user_pass(username, domain)
ok_resp = self.api.login(email=username, password=password)
if not ok_resp:
raise ExternalError("Could not login to %s as user %s" %
(domain, username))
else:
raise ExternalError(
"No stored iotile cloud authentication information",
suggestion=
'Call iotile config link_cloud with your username and password'
)
self.token = self.api.token
self.token_type = self.api.token_type
def _prompt_user_pass(self, username, domain):
if username is None:
prompt_str = "Please enter your IOTile.cloud email: "
username = input(prompt_str)
prompt_str = "Please enter your IOTile.cloud password: "******"{:04x}".format(device_id)
streamer_hex = "{:04x}".format(streamer_id)
return "t--0000-0000-0000-{}--{}".format(idhex, streamer_hex)
@param("device_id",
"integer",
desc="ID of the device that we want information about")
@return_type("basic_dict")
def device_info(self, device_id):
"""Query information about a device by its device id
"""
slug = device_id_to_slug(device_id)
try:
dev = self.api.device(slug).get()
except HttpNotFoundError:
raise ArgumentError("Device does not exist in cloud database",
device_id=device_id,
slug=slug)
return dev
@param("fleet_id", "integer", desc="Id of the fleet we want to retrieve")
@return_type("basic_dict")
def get_fleet(self, fleet_id):
""" Returns the devices in the given fleet."""
api = self.api
slug = fleet_id_to_slug(fleet_id)
try:
results = api.fleet(slug).devices.get()
entries = results.get('results', [])
return {entry.pop('device'): entry for entry in entries}
except HttpNotFoundError:
raise ArgumentError("Fleet does not exist in cloud database",
fleet_id=fleet_id,
slug=slug)
@param("device_id",
"integer",
desc="Id of the device whose fleet we want to retrieve")
@return_type("basic_dict")
def get_whitelist(self, device_id):
""" Returns the whitelist associated with the given device_id if any"""
api = self.api
slug = device_id_to_slug(device_id)
try:
fleets = api.fleet.get(device=slug)['results']
except HttpNotFoundError:
raise ExternalError(
"Could not find the right URL. Are fleets enabled ?")
if not fleets:
# This is to be expected for devices set to take data from all project, or any device.
raise ExternalError("The device isn't in any network !")
networks = [
self.get_fleet(fleet['id']) for fleet in fleets
if fleet.get('is_network', False) is True
]
networks_to_manage = [
x for x in networks
if x.get(slug, {}).get('is_access_point', False) is True
]
out = {}
for network in networks_to_manage:
out.update(network)
# Remove ourselves from the whitelist that we are supposed to manage
if slug in out:
del out[slug]
if not out:
raise ExternalError("No device to manage in these fleets !")
return out
@param("max_slop", "integer", desc="Optional max time difference value")
@return_type("bool")
def check_time(self, max_slop=300):
""" Check if current system time is consistent with iotile.cloud time"""
cloud_time = self.api.session.get('{}/api/v1/server/'.format(
self._domain)).json().get('now', None)
if cloud_time is None:
raise DataError("No date header returned from iotile cloud",
domain=self._domain)
curtime = datetime.datetime.now(tzutc())
delta = dateutil.parser.parse(cloud_time) - curtime
delta_secs = delta.total_seconds()
return abs(delta_secs) < max_slop
@param("device_id",
"integer",
desc="ID of the device that we want information about")
@param("new_sg",
"string",
desc="The new sensor graph id that we want to load")
@param(
"app_tag",
"integer",
desc=
"Optional arg to check if the device template on the cloud matches the app_tag"
)
def set_sensorgraph(self, device_id, new_sg, app_tag=None):
"""The the cloud's sensor graph id that informs what kind of device this is.
Is app_tag is passed, verify that the sensorgraph explicitly matches
the expected app_tag by making another API call.
Args:
device_id (int): The id of the device that we want to change the sensorgraph for.
new_sg (string): Name of a valid sensorgraph that you wish to set the device to
app_tag (int): Optional. The intended app_tag of the sensorgraph will be set. If the
app_tag passed into this function does not match the app_tag of the sensorgraph
in iotile.cloud, raise an error.
"""
try:
sg = self.api.sg(new_sg).get()
except RestHttpBaseException as exc:
raise ExternalError("Error calling method on iotile.cloud",
exception=exc,
response=exc.response.status_code)
if app_tag is not None:
if sg.get('app_tag', None) != app_tag:
raise ArgumentError(
"Cloud sensorgraph record does not match app tag",
value=new_sg,
cloud_sg_app_tag=sg.get('app_tag', None),
app_tag_set=app_tag)
slug = device_id_to_slug(device_id)
patch = {'sg': new_sg}
try:
self.api.device(slug).patch(patch)
except RestHttpBaseException as exc:
if exc.response.status_code == 400:
raise ArgumentError(
"Error setting sensor graph, invalid value",
value=new_sg,
error_code=exc.response.status_code)
else:
raise ExternalError("Error calling method on iotile.cloud",
exception=exc,
response=exc.response.status_code)
@param("device_id",
"integer",
desc="ID of the device that we want information about")
@param("new_template",
"string",
desc="The new device template that we want to set")
@param(
"os_tag",
"integer",
desc=
"Optional arg to check if the sensorgraph on the cloud matches the os_tag"
)
def set_device_template(self, device_id, new_template, os_tag=None):
"""Sets the device template for the given device in iotile.cloud.
Is os_tag is passed, verify that the device template explicitly matches
the expected os_tag by making another API call.
Args:
device_id (int): The id of the device that we want to change the device template for.
new_template (string): Name of a valid device template that you wish to set the device to
os_tag (int): Optional. If the os_tag passed into this function does not match the
os_tag of the device_template in iotile.cloud, raise an error.
"""
try:
dt = self.api.dt(new_template).get()
except RestHttpBaseException as exc:
raise ExternalError("Error calling method on iotile.cloud",
exception=exc,
response=exc.response.status_code)
if os_tag is not None:
if dt.get('os_tag', None) != os_tag:
raise ArgumentError(
"Cloud device template record does not match os tag",
value=new_template,
cloud_sg_os_tag=dt.get('os_tag', None),
os_tag_set=os_tag)
slug = device_id_to_slug(device_id)
patch = {'template': new_template}
try:
self.api.device(slug).patch(patch, staff=1)
except RestHttpBaseException as exc:
if exc.response.status_code == 400:
raise ArgumentError(
"Error setting device template, invalid value",
value=new_template,
error_code=exc.response.status_code)
else:
raise ExternalError("Error calling method on iotile.cloud",
exception=exc,
response=exc.response.status_code)
@param("project_id",
"string",
desc="Optional ID of the project to download a list of devices from"
)
@return_type("list(integer)")
def device_list(self, project_id=None):
"""Download a list of all device IDs or device IDs that are members for a specific project."""
if project_id:
devices = self.api.device.get(project=project_id)
else:
devices = self.api.device.get()
ids = [device['id'] for device in devices['results']]
return ids
@param("device_id",
"integer",
desc="ID of the device that we want to get a permanent token for")
def impersonate_device(self, device_id):
"""Convert our token to a permanent device token.
This function is most useful for creating virtual IOTile devices whose access to iotile.cloud
is based on their device id, not any particular user's account.
There are a few differences between device tokens and user tokens:
- Device tokens never expire and don't need to be refreshed
- Device tokens are more restricted in what they can access in IOTile.cloud than user tokens
Args:
device_id (int): The id of the device that we want to get a token for.
"""
slug = device_id_to_slug(device_id)
token_type = IOTileCloud.DEVICE_TOKEN_TYPE
try:
resp = self.api.device(slug).key.get(
type=IOTileCloud.DEVICE_TOKEN_TYPE)
token = resp['key']
except RestHttpBaseException as exc:
raise ExternalError("Error calling method on iotile.cloud",
exception=exc,
response=exc.response.status_code)
self.api.set_token(token, token_type=token_type)
self.token = token
self.token_type = token_type
reg = ComponentRegistry()
reg.set_config('arch:cloud_token', self.token)
reg.set_config('arch:cloud_token_type', self.token_type)
reg.set_config('arch:cloud_device', slug)
@param("device_id",
"integer",
desc="ID of the device that we want information about")
@param("clean", "bool", desc="Also clean old stream data for this device")
def unclaim(self, device_id, clean=True):
"""Unclaim a device that may have previously been claimed."""
slug = device_id_to_slug(device_id)
payload = {'clean_streams': clean}
try:
self.api.device(slug).unclaim.post(payload)
except RestHttpBaseException as exc:
raise ExternalError("Error calling method on iotile.cloud",
exception=exc,
response=exc.response.status_code)
def upload_report(self, report):
"""Upload an IOTile report to the cloud.
This function currently supports uploading the following kinds of
reports:
SignedListReport
FlexibleDictionaryReport
If you pass an instance of IndividualReadingReport, an exception will
be thrown because IOTile.cloud does not support receiving individual
readings. Those are only for local use.
The filename of the uploaded report will have an extension set based
on the type of report that you are uploading.
Args:
report (IOTileReport): The report that you want to upload. This should
not be an IndividualReadingReport.
Returns:
int: The number of new readings that were accepted by the cloud as novel.
"""
if isinstance(report, IndividualReadingReport):
raise ArgumentError(
"You cannot upload IndividualReadingReport objects to iotile.cloud",
report=report)
if isinstance(report, SignedListReport):
file_ext = ".bin"
elif isinstance(report, FlexibleDictionaryReport):
file_ext = ".mp"
else:
raise ArgumentError(
"Unknown report format passed to upload_report",
classname=report.__class__.__name__,
report=report)
timestamp = '{}'.format(report.received_time.isoformat())
payload = {'file': ("report" + file_ext, BytesIO(report.encode()))}
resource = self.api.streamer.report
headers = {}
authorization_str = '{0} {1}'.format(self.token_type, self.token)
headers['Authorization'] = authorization_str
resp = self.api.session.post(resource.url(),
files=payload,
headers=headers,
params={'timestamp': timestamp})
count = resource._process_response(resp)['count']
return count
def highest_acknowledged(self, device_id, streamer):
"""Get the highest acknowledged reading for a given streamer.
Args:
device_id (int): The device whose streamer we are querying
streamer (int): The streamer on the device that we want info
about.
Returns:
int: The highest reading id that has been acknowledged by the cloud
"""
slug = self._build_streamer_slug(device_id, streamer)
try:
data = self.api.streamer(slug).get()
except RestHttpBaseException as exc:
raise ArgumentError("Could not get information for streamer",
device_id=device_id,
streamer_id=streamer,
slug=slug,
err=str(exc))
if 'last_id' not in data:
raise ExternalError(
"Response fom the cloud did not have last_id set",
response=data)
return data['last_id']
def device_acknowledgements(self, device_id):
"""Get all streamer acknowledgements for a device by its id.
Args:
device_id (int): The device we are querying
Returns:
list of namedtuples: A list of all acknowledgement values received from the cloud.
The namedtuples should have index, ack and selector fields pulled from the corresponding
record in the cloud.
"""
slug = device_id_to_slug(device_id)
try:
data = self.api.streamer().get(device=slug)
except RestHttpBaseException as exc:
raise ArgumentError("Could not get information for streamer",
device_id=device_id,
slug=slug,
err=str(exc))
results = data.get('results', [])
acknowledgements = []
for result in results:
acknowledgement = Acknowledgement(result.get("index"),
result.get("last_id"),
result.get("selector"))
acknowledgements.append(acknowledgement)
return acknowledgements
@annotated
def refresh_token(self):
"""Attempt to refresh out cloud token with iotile.cloud."""
if self.token_type != 'jwt':
raise DataError(
"Attempting to refresh a token that does not need to be refreshed",
token_type=self.token_type)
conf = ConfigManager()
domain = conf.get('cloud:server')
url = '{}/api/v1/auth/api-jwt-refresh/'.format(domain)
resp = self.api.session.post(url, json={'token': self.token})
if resp.status_code != 200:
raise ExternalError("Could not refresh token",
error_code=resp.status_code)
data = resp.json()
# Save token that we just refreshed to the registry and update our own token
self.token = data['token']
reg = ComponentRegistry()
reg.set_config('arch:cloud_token', self.token)
class BaseMain(object):
parser = None
args = None
api = None
domain = 'https://iotile.cloud'
def __init__(self):
"""
Initialize Logging configuration
Initialize argument parsing
Process any extra arguments
Only hard codes one required argument: --user
Additional arguments can be configured by overwriting the add_extra_args() method
Logging configuration can be changed by overwritting the config_logging() method
"""
self.parser = argparse.ArgumentParser(description=__doc__)
self.parser.add_argument('-u',
'--user',
dest='email',
type=str,
help='Email used for login')
self.add_extra_args()
self.args = self.parser.parse_args()
self.config_logging()
if not self.args.email:
logger.error('User email is required: --user')
sys.exit(1)
def _critical_exit(self, msg):
logger.error(msg)
sys.exit(1)
def main(self):
"""
Main function to call to initiate execution.
1. Get domain name and use to instantiate Api object
2. Call before_login to allow for work before logging in
3. Logging into the server
4. Call after_loging to do actual work with server data
5. Logout
6. Call after_logout to do work at end of script
:return: Nothing
"""
self.domain = self.get_domain()
self.api = Api(self.domain)
self.before_login()
ok = self.login()
if ok:
self.after_login()
self.logout()
self.after_logout()
# Following functions can be overwritten if needed
# ================================================
def config_logging(self):
"""
Overwrite to change the way the logging package is configured
:return: Nothing
"""
logging.basicConfig(
level=logging.INFO,
format='[%(asctime)-15s] %(levelname)-6s %(message)s',
datefmt='%d/%b/%Y %H:%M:%S')
def add_extra_args(self):
"""
Overwrite to change the way extra arguments are added to the args parser
:return: Nothing
"""
pass
def get_domain(self):
"""
Overwrite to change the default domain
:return: URL for server. e.g. 'https://iotile.cloud'
"""
return self.domain
def login(self):
"""
Overwrite to change how to login to the server
:return: True if successful
"""
password = getpass.getpass()
ok = self.api.login(email=self.args.email, password=password)
return ok
def logout(self):
"""
Overwrite to change how to logout from server
:return: Nothing
"""
self.api.logout()
def before_login(self):
"""
Overwrite to do work after parsing, but before logging in to the server
This is a good place to do additional custom argument checks
:return: Nothing
"""
pass
def after_login(self):
"""
This function MUST be overwritten to do actual work after logging into the Server
:return: Nothing
"""
logger.warning('No actual work done')
def after_logout(self):
"""
Overwrite if you want to do work after loging out of the server
:return: Nothing
"""
pass