def get(self, local_port, protocol):
mappings_list = self.load()
mapping = next(
(m for m in mappings_list
if m.local_port == local_port and m.protocol == protocol), None)
mapping_for_log = convertible.to_json(mapping) if mapping else mapping
self.logger.info('getting port mapping for local_port={0}: {1}'.format(
local_port, mapping_for_log))
return mapping
def sync(self):
self.port_mapper.sync()
services = self.service_config.load()
domain = self.domain_config.load()
if not domain:
raise Exception("No token saved, need to call set_dns or get_dns_token first")
services_data = []
for service in services:
mapping = self.port_mapper.get(service.port)
if mapping:
service.port = mapping.external_port
service_data = dict(
name=service.name,
protocol=service.protocol,
type=service.type,
url=service.url,
port=mapping.external_port,
local_port=mapping.local_port
)
services_data.append(service_data)
data = {'token': domain.update_token, 'local_ip': self.local_ip, 'services': services_data}
external_ip = self.port_mapper.external_ip()
if not external_ip:
self.logger.warn("Unable to get external ip")
else:
if IP(external_ip).iptype() != 'PUBLIC':
external_ip = None
self.logger.warn("External ip is not public")
if external_ip:
data['ip'] = external_ip
else:
self.logger.warn("Will try server side client ip detection")
url = urljoin(self.insider_config.get_redirect_api_url(), "/domain/update")
self.logger.debug('url: ' + url)
json = convertible.to_json(data)
self.logger.debug('request: ' + json)
response = requests.post(url, json)
self.check_http_error(response)
def sync(self, external_ip, web_port, web_local_port, web_protocol,
update_token, external_access):
map_local_address = not external_access
version = self.versions.platform_version()
local_ip = linux.local_ip()
data = {
'token': update_token,
'platform_version': version,
'local_ip': local_ip,
'map_local_address': map_local_address,
'web_protocol': web_protocol,
'web_port': web_port,
'web_local_port': web_local_port
}
if not external_ip:
self.logger.warn("No external ip")
else:
iptype = IP(external_ip).iptype()
if iptype != 'PUBLIC':
external_ip = None
self.logger.warn(
"External ip is not public: {0}".format(iptype))
if not map_local_address:
if external_ip:
data['ip'] = external_ip
else:
self.logger.warn("Will try server side client ip detection")
url = urljoin(self.user_platform_config.get_redirect_api_url(),
"/domain/update")
self.logger.debug('url: ' + url)
json = convertible.to_json(data)
self.logger.info('request: ' + json)
response = requests.post(url, json)
util.check_http_error(response)
def test_port_mapping(self):
expected = '{"external_port": "8080", "local_port": "80"}'
actual = to_json(Port("80", "8080"))
self.assertEquals(expected, actual)
class RedirectService:
def __init__(self, user_platform_config, versions):
self.versions = versions
self.user_platform_config = user_platform_config
self.logger = logger.get_logger('RedirectService')
def get_user(self, email, password):
url = urljoin(self.user_platform_config.get_redirect_api_url(), "/user/get")
response = requests.get(url, params={'email': email, 'password': password})
util.check_http_error(response)
user = convertible.from_json(response.text).data
return user
def send_log(self, user_update_token, logs):
url = urljoin(self.user_platform_config.get_redirect_api_url(), "/user/log")
response = requests.post(url, {'token': user_update_token, 'data': logs})
util.check_http_error(response)
user = convertible.from_json(response.text)
return user
def acquire(self, email, password, user_domain):
device_id = id.id()
data = {
'email': email,
'password': password,
'user_domain': user_domain,
'device_mac_address': device_id.mac_address,
'device_name': device_id.name,
'device_title': device_id.title,
}
url = urljoin(self.user_platform_config.get_redirect_api_url(), "/domain/acquire")
response = requests.post(url, data)
util.check_http_error(response)
response_data = convertible.from_json(response.text)
return response_data
def sync(self, port_drill, update_token, web_protocol, external_access, network_protocol):
try:
port_drill.sync()
except Exception, e:
self.logger.error('Unable to sync port mappings: {0}'.format(e.message))
map_local_address = not external_access
web_local_port = util.protocol_to_port(web_protocol)
web_port = None
mapping = port_drill.get(web_local_port, network_protocol)
if mapping:
web_port = mapping.external_port
version = self.versions.platform_version()
local_ip = linux.local_ip()
data = {
'token': update_token,
'platform_version': version,
'local_ip': local_ip,
'map_local_address': map_local_address,
'web_protocol': web_protocol,
'web_port': web_port,
'web_local_port': web_local_port
}
external_ip = port_drill.external_ip()
if not external_ip:
self.logger.warn("No external ip")
else:
iptype=IP(external_ip).iptype()
if iptype != 'PUBLIC':
external_ip = None
self.logger.warn("External ip is not public: {0}".format(iptype))
if not map_local_address:
if external_ip:
data['ip'] = external_ip
else:
self.logger.warn("Will try server side client ip detection")
url = urljoin(self.user_platform_config.get_redirect_api_url(), "/domain/update")
self.logger.debug('url: ' + url)
json = convertible.to_json(data)
self.logger.info('request: ' + json)
response = requests.post(url, json)
util.check_http_error(response)
def get(self, local_port, protocol):
mappings_list = self.load()
mapping = next((m for m in mappings_list if m.local_port == local_port and m.protocol == protocol), None)
mapping_for_log = convertible.to_json(mapping) if mapping else mapping
self.logger.info('getting port mapping for local_port={0}: {1}'.format(local_port, mapping_for_log))
return mapping
def test_datetime_to_json(self):
datetime_value = datetime(2014, 6, 28, hour=7, minute=58, second=59)
obj = Klass("value1", datetime_value)
actual = to_json(obj)
expected = '{"member1": "value1", "member2": "2014-06-28 07:58:59"}'
self.assertEquals(expected, actual)
def test_dictionary_to_json(self):
objects_dict = {"obj1": Klass("value1", 123), "obj2": Klass("value2", 345)}
actual = to_json(objects_dict)
expected = '{"obj1": {"member1": "value1", "member2": 123}, "obj2": {"member1": "value2", "member2": 345}}'
self.assertEquals(expected, actual)
def test_list_to_json(self):
objects_list = [Klass("value1", 123), Klass("value2", 345)]
actual = to_json(objects_list)
expected = '[{"member1": "value1", "member2": 123}, {"member1": "value2", "member2": 345}]'
self.assertEquals(expected, actual)
def test_nested_to_json(self):
obj = Klass(True, Klass("value", 345))
actual = to_json(obj)
expected = '{"member1": true, "member2": {"member1": "value", "member2": 345}}'
self.assertEquals(expected, actual)
def test_object_to_json(self):
obj = Klass("value", 345)
actual = to_json(obj)
expected = '{"member1": "value", "member2": 345}'
self.assertEquals(expected, actual)
def test_port_mapping():
expected = '{"protocol": "TCP", "external_port": "8080", "local_port": "80"}'
actual = to_json(Port("80", "8080", "TCP"))
assert expected == actual
