class UserManagerService(ServiceBase):
@rpc(User, _returns=Integer)
def add_user(ctx, user):
print id(user.permissions[0].__class__), id(Permission)
ctx.udc.session.add(user)
ctx.udc.session.flush()
return user.user_id
@rpc(Integer, _returns=User)
def get_user(ctx, user_id):
return ctx.udc.session.query(User).filter_by(user_id=user_id).one()
@rpc(User)
def set_user(ctx, user):
ctx.udc.session.merge(user)
@rpc(Integer)
def del_user(ctx, user_id):
ctx.udc.session.query(User).filter_by(user_id=user_id).delete()
@rpc(_returns=Iterable(User))
def get_all_user(ctx):
return ctx.udc.session.query(User)
class Service_submitseq(ServiceBase):
@rpc(Unicode, Unicode, Unicode, Unicode, _returns=Iterable(Unicode))
# submit job to the front-end
def submitjob(ctx, seq="", fixtop="", jobname="", email=""):#{{{
seq = seq + "\n" #force add a new line for correct parsing the fasta file
seqinfo = {}
filtered_seq = webcom.ValidateSeq(seq, seqinfo, g_params)
# ValidateFixtop(fixtop) #to be implemented
jobid = "None"
url = "None"
numseq_str = "%d"%(seqinfo['numseq'])
warninfo = seqinfo['warninfo']
errinfo = ""
# print "\n\nreq\n", dir(ctx.transport.req) #debug
# print "\n\n", ctx.transport.req.META['REMOTE_ADDR'] #debug
# print "\n\n", ctx.transport.req.META['HTTP_HOST'] #debug
if filtered_seq == "":
errinfo = seqinfo['errinfo']
else:
soap_req = ctx.transport.req
try:
client_ip = soap_req.META['REMOTE_ADDR']
except:
client_ip = ""
try:
hostname = soap_req.META['HTTP_HOST']
except:
hostname = ""
# print client_ip
# print hostname
seqinfo['jobname'] = jobname
seqinfo['email'] = email
seqinfo['fixtop'] = fixtop
seqinfo['date'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
seqinfo['client_ip'] = client_ip
seqinfo['hostname'] = hostname
seqinfo['method_submission'] = "wsdl"
seqinfo['isForceRun'] = False # disable isForceRun if submitted by WSDL
jobid = RunQuery_wsdl(seq, filtered_seq, seqinfo)
if jobid == "":
errinfo = "Failed to submit your job to the queue\n"+seqinfo['errinfo']
else:
log_record = "%s\t%s\t%s\t%s\t%d\t%s\t%s\t%s\n"%(seqinfo['date'], jobid,
seqinfo['client_ip'], seqinfo['numseq'],
len(seq),seqinfo['jobname'], seqinfo['email'],
seqinfo['method_submission'])
main_logfile_query = "%s/%s/%s"%(SITE_ROOT, "static/log", "submitted_seq.log")
myfunc.WriteFile(log_record, main_logfile_query, "a")
divided_logfile_query = "%s/%s/%s"%(SITE_ROOT, "static/log/divided",
"%s_submitted_seq.log"%(seqinfo['client_ip']))
if seqinfo['client_ip'] != "":
myfunc.WriteFile(log_record, divided_logfile_query, "a")
url = "http://" + hostname + g_params['BASEURL'] + "result/%s"%(jobid)
file_seq_warning = "%s/%s/%s/%s"%(SITE_ROOT, "static/result", jobid, "query.warn.txt")
if seqinfo['warninfo'] != "":
myfunc.WriteFile(seqinfo['warninfo'], file_seq_warning, "a")
errinfo = seqinfo['errinfo']
for s in [jobid, url, numseq_str, errinfo, warninfo]:
yield s
#}}}
@rpc(Unicode, Unicode, Unicode, Unicode, Unicode, Unicode, _returns=Iterable(Unicode))
# submitted_remote will be called by the daemon
# sequences are submitted one by one by the daemon, but the numseq_of_job is
# for the number of sequences of the whole job submitted to the front end
# isforcerun is set as string, "true" or "false", case insensitive
def submitjob_remote(ctx, seq="", fixtop="", jobname="", email="",#{{{
numseq_this_user="", isforcerun=""):
seq = seq + "\n" #force add a new line for correct parsing the fasta file
seqinfo = {}
filtered_seq = webcom.ValidateSeq(seq, seqinfo, g_params)
# ValidateFixtop(fixtop) #to be implemented
if numseq_this_user != "" and numseq_this_user.isdigit():
seqinfo['numseq_this_user'] = int(numseq_this_user)
else:
seqinfo['numseq_this_user'] = 1
numseq_str = "%d"%(seqinfo['numseq'])
warninfo = seqinfo['warninfo']
# print "\n\nreq\n", dir(ctx.transport.req) #debug
# print "\n\n", ctx.transport.req.META['REMOTE_ADDR'] #debug
# print "\n\n", ctx.transport.req.META['HTTP_HOST'] #debug
jobid = "None"
url = "None"
if filtered_seq == "":
errinfo = seqinfo['errinfo']
else:
soap_req = ctx.transport.req
try:
client_ip = soap_req.META['REMOTE_ADDR']
except:
client_ip = ""
try:
hostname = soap_req.META['HTTP_HOST']
except:
hostname = ""
# print client_ip
# print hostname
seqinfo['jobname'] = jobname
seqinfo['email'] = email
seqinfo['fixtop'] = fixtop
seqinfo['date'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
seqinfo['client_ip'] = client_ip
seqinfo['hostname'] = hostname
seqinfo['method_submission'] = "wsdl"
# for this method, wsdl is called only by the daemon script, isForceRun can be
# set by the argument
if isforcerun.upper()[:1] == "T":
seqinfo['isForceRun'] = True
else:
seqinfo['isForceRun'] = False
jobid = RunQuery_wsdl_local(seq, filtered_seq, seqinfo)
if jobid == "":
errinfo = "Failed to submit your job to the queue\n"+seqinfo['errinfo']
else:
log_record = "%s\t%s\t%s\t%s\t%d\t%s\t%s\t%s\n"%(seqinfo['date'], jobid,
seqinfo['client_ip'], seqinfo['numseq'],
len(seq),seqinfo['jobname'], seqinfo['email'],
seqinfo['method_submission'])
main_logfile_query = "%s/%s/%s"%(SITE_ROOT, "static/log", "submitted_seq.log")
myfunc.WriteFile(log_record, main_logfile_query, "a")
divided_logfile_query = "%s/%s/%s"%(SITE_ROOT, "static/log/divided",
"%s_submitted_seq.log"%(seqinfo['client_ip']))
if seqinfo['client_ip'] != "":
myfunc.WriteFile(log_record, divided_logfile_query, "a")
url = "http://" + hostname + g_params['BASEURL'] + "result/%s"%(jobid)
file_seq_warning = "%s/%s/%s/%s"%(SITE_ROOT, "static/result", jobid, "query.warn.txt")
if seqinfo['warninfo'] != "":
myfunc.WriteFile(seqinfo['warninfo'], file_seq_warning, "a")
errinfo = seqinfo['errinfo']
for s in [jobid, url, numseq_str, errinfo, warninfo]:
yield s
#}}}
@rpc(Unicode, _returns=Iterable(Unicode))
def checkjob(ctx, jobid=""):#{{{
rstdir = "%s/%s"%(path_result, jobid)
soap_req = ctx.transport.req
hostname = soap_req.META['HTTP_HOST']
result_url = "http://" + hostname + "/static/" + "result/%s/%s.zip"%(jobid, jobid)
status = "None"
url = ""
errinfo = ""
if not os.path.exists(rstdir):
status = "None"
errinfo = "Error! jobid %s does not exist."%(jobid)
else:
starttagfile = "%s/%s"%(rstdir, "runjob.start")
finishtagfile = "%s/%s"%(rstdir, "runjob.finish")
failtagfile = "%s/%s"%(rstdir, "runjob.failed")
errfile = "%s/%s"%(rstdir, "runjob.err")
if os.path.exists(failtagfile):
status = "Failed"
errinfo = ""
if os.path.exists(errfile):
errinfo = myfunc.ReadFile(errfile)
elif os.path.exists(finishtagfile):
status = "Finished"
url = result_url
errinfo = ""
elif os.path.exists(starttagfile):
status = "Running"
else:
status = "Wait"
for s in [status, url, errinfo]:
yield s
#}}}
@rpc(Unicode, _returns=Iterable(Unicode))
def deletejob(ctx, jobid=""):#{{{
rstdir = "%s/%s"%(path_result, jobid)
status = "None"
errinfo = ""
try:
shutil.rmtree(rstdir)
status = "Succeeded"
except OSError as e:
errinfo = str(e)
status = "Failed"
for s in [status, errinfo]:
yield s
class SomeService(Service):
@srpc(Iterable(Unicode), _returns=Iterable(Unicode))
def some_call(s):
return s
class SomeService(Service):
@srpc(_returns=Iterable(Integer))
def some_call():
return iter(range(1000))
class SomeService(ServiceBase):
@srpc(Integer, _returns=Iterable(Integer))
def some_call(yo):
return range(yo)
class SomeService(ServiceBase):
@srpc(Iterable(ECM), _returns=Iterable(ECM))
def some_call(ecm):
return ecm
class HelloWorldService(Service):
@rpc(Unicode, Integer, _returns=Iterable(Unicode))
def say_hello(self, name, times):
print("Hlloe")
for i in range(times):
yield 'Hello, %s' % name
class PlaceManagerService(ServiceBase):
@rpc(Mandatory.UnsignedInteger32, _returns=Place)
def get_place(ctx, place_id):
return ctx.udc.session.query(Place).filter_by(id=place_id).one()
@rpc(Place, _returns=UnsignedInteger32)
def put_place(ctx, place):
if place.id is None:
ctx.udc.session.add(place)
ctx.udc.session.flush() # so that we get the place.id value
else:
if ctx.udc.session.query(Place).get(place.id) is None:
# this is to prevent the client from setting the primary key
# of a new object instead of the database's own primary-key
# generator.
# Instead of raising an exception, you can also choose to
# ignore the primary key set by the client by silently doing
# place.id = None
raise ResourceNotFoundError('place.id=%d' % place.id)
else:
ctx.udc.session.merge(place)
return place.id
@rpc(Mandatory.UnsignedInteger32)
def del_place(ctx, place_id):
count = ctx.udc.session.query(Place).filter_by(id=place_id).count()
if count == 0:
raise ResourceNotFoundError(place_id)
ctx.udc.session.query(Place).filter_by(id=place_id).delete()
@rpc(_returns=Iterable(Place))
def get_all_places(ctx):
return ctx.udc.session.query(Place)
@rpc(Mandatory.UnsignedInteger32,
UnsignedInteger32,
UnsignedInteger32,
_returns=Iterable(Place))
def get_places_by_category_id(ctx, category_id, from_id=0, elements=None):
places = ctx.udc.session.query(Place).filter_by(
category_id=category_id)
if from_id is not None:
places = [place for place in places if place.id >= from_id]
for place in places:
place.rating = -1.0 if place.rating == 0.0 else place.rating
return _partition_places(places, elements)
@rpc(Mandatory.UnsignedInteger32,
Decimal,
Decimal,
Decimal,
UnsignedInteger32,
UnsignedInteger32,
_returns=Iterable(Place))
def get_near_places_by_category_id(ctx,
category_id,
lat,
lng,
radius,
from_id=0,
elements=None):
places = ctx.udc.session.query(Place).filter_by(
category_id=category_id)
places = places.order_by(asc(Place.id))
if from_id is not None:
places = [place for place in places if place.id >= from_id]
# Filter just near places
places = [
place for place in places
if _are_points_closed(place.lat, place.lng, lat, lng, radius)
]
# Just places id greater than from_id
return _partition_places(places, elements)
@rpc(Mandatory.Unicode, Mandatory.UnsignedInteger32, _returns=Boolean)
def gplaces_id_exists_in_category(ctx, gplaces_id, category_id):
return ctx.udc.session.query(Place).filter_by(
category_id=category_id, gplaces_id=gplaces_id).count() > 0
@rpc(Unicode, File(min_occurs=1, nullable=False), _returns=Unicode)
def upload_image(ctx, image_name, image_file):
image_name = image_name.replace(
' ', '_') + '_' + datetime.datetime.now().strftime(
"%d-%m-%y_%H.%m") + '.jpg'
path = os.path.join(os.path.abspath('/srv/images'), image_name)
if not path.startswith(os.path.abspath('/srv/images')):
raise ValidationError(image_file)
f = open(path, 'wb')
try:
for data in image_file.data:
f.write(base64.b64decode(data))
logger.debug("File written: %r" % image_name)
f.close()
except:
f.close()
os.remove(image_name)
logger.debug("File removed: %r" % image_name)
raise # again, the client will see an internal error.
# Watch out the port!
url = 'http://' + socket.gethostbyname(
socket.gethostname()) + ':8080/images/' + image_name
return url
class HelloService(ServiceBase):
@rpc(Unicode, Integer, _returns=Iterable(Unicode))
def SayHello(ctx, Name, Times):
return (u"Hello, {0}!".format(Name) for _ in xrange(Times))
class HelloWorldService(ServiceBase):
@rpc(String, Integer, _returns=Iterable(String))
def say_hello(ctx, name, times):
for i in xrange(times):
yield 'Hello, %s' % name
class SomeSoapService(spyne.Service):
__service_url_path__ = '/soap/someservice'
__in_protocol__ = Soap11(validator='lxml')
__out_protocol__ = Soap11()
@spyne.srpc(Unicode, Unicode, _returns=Iterable(Unicode))
def hello(xusername, xpassword):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
args = [
xusername,
xpassword,
]
cursor.callproc("checkUser", args)
for result in cursor.stored_results():
tup = result.fetchone()
str1 = "".join(tup)
cantidad = str1.count("Error")
if (cantidad == 0):
return str1, 200
else:
return str1, 404
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
@spyne.srpc(Unicode,
Unicode,
Unicode,
Unicode,
Unicode,
Unicode,
float,
_returns=Iterable(Unicode))
def createUser(username, password, dni, name, surname, currency, amount):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
args = [username, password, dni, name, surname, currency, amount]
cursor.callproc("createUser", args)
connection.commit()
for result in cursor.stored_results():
tup = result.fetchone()
str1 = "".join(tup)
return str1, 200
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
@spyne.srpc(Unicode, _returns=Iterable(Unicode))
def deleteUser(id):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
args = [
id,
]
cursor.callproc("deleteUser", args)
connection.commit()
for result in cursor.stored_results():
tup = result.fetchone()
str1 = "".join(tup)
if (str1 == "deleted"):
return str1, 200
else:
return str1, 404
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
@spyne.srpc(Unicode, Unicode, Unicode, float, _returns=Iterable(Unicode))
def buy(id, currency, currencyTo, amountTo):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
#moneda. Para el caso de valor de compra, se establece un precio del 94% sobre el
#valor de venta. Por ejemplo, si el valor del dolar es de $60, la casa de cambio le vende al usuario a $60 y se los
#compra a $56,40.
url = 'http://data.fixer.io/api/latest?access_key=6f29ee6eb68ccc8ec4043564a16e5a51&symbols=' + currency + ',' + currencyTo
response = requests.get(url)
data = json.loads(response.text)
currency1 = (data['rates'][currency])
currencyTo1 = (data['rates'][currencyTo])
# $1 de moneda a comprar
valorPorCadaPeso = (currency1) / currencyTo1
args = [
id,
currency,
currencyTo,
amountTo,
str(round(valorPorCadaPeso, 2)),
]
cursor.callproc("buy", args)
connection.commit()
for result in cursor.stored_results():
tup = result.fetchone()
str1 = " ".join(map(str, tup))
if (str1 == 'success'):
return str1, 200
elif (str1 ==
'Error 102: No posees saldo suficiente para realizar la operacion'
):
return str1, 404
elif (str1 == 'Error 100: No existe un usuario con ese id'):
return str1, 404
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
@spyne.srpc(Unicode, Unicode, Unicode, float, _returns=Iterable(Unicode))
def sell(id, currency, currencyToBuy, amount):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
#moneda. Para el caso de valor de compra, se establece un precio del 94% sobre el
#valor de venta. Por ejemplo, si el valor del dolar es de $60, la casa de cambio le vende al usuario a $60 y se los
#compra a $56,40.
url = 'http://data.fixer.io/api/latest?access_key=6f29ee6eb68ccc8ec4043564a16e5a51&symbols=' + currency + ',' + currencyToBuy
response = requests.get(url)
data = json.loads(response.text)
currency1 = (data['rates'][currency])
currencyTo1 = (data['rates'][currencyToBuy])
# $1 de moneda a comprar
valorPorCadaPeso = ((currencyTo1) / currency1) * 0.94
args = [
id,
currency,
amount,
str(round(valorPorCadaPeso, 2)),
]
cursor.callproc("sell", args)
connection.commit()
for result in cursor.stored_results():
tup = result.fetchone()
str1 = " ".join(map(str, tup))
if (str1 == 'success'):
return str1, 200
elif (str1 ==
'Error 102: No posees saldo suficiente para realizar la operacion'
):
return str1, 404
elif (str1 == 'Error 100: No existe un usuario con ese id'):
return str1, 404
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
@spyne.srpc(Unicode, Unicode, float, _returns=Iterable(Unicode))
def withdraw(id, currency, amount):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
args = [
id,
currency,
amount,
]
cursor.callproc("withdraw", args)
connection.commit()
for result in cursor.stored_results():
tup = result.fetchone()
str1 = " ".join(map(str, tup))
if (str1 == 'success'):
return str1, 200
elif (str1 == 'Error 101: No tienes dinero suficiente'):
return str1, 404
elif (str1 == 'Error 100: No existe un usuario con ese id'):
return str1, 404
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
@spyne.srpc(Unicode, Unicode, float, _returns=Iterable(Unicode))
def deposit(id, currency, amount):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
args = [
id,
currency,
amount,
]
cursor.callproc("deposit", args)
connection.commit()
for result in cursor.stored_results():
tup = result.fetchone()
str1 = " ".join(map(str, tup))
if (str1 == 'success'):
return str1, 200
elif (str1 == 'Error 100: No existe un usuario con ese id'):
return str1, 404
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
@spyne.srpc(Unicode, _returns=Iterable(Unicode))
def balance(id):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
args = [
id,
]
cursor.callproc("balance", args)
for result in cursor.stored_results():
tup = result.fetchall()
str1 = " ".join(map(str, tup))
return str1, 200
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
@spyne.srpc(Unicode, Unicode, _returns=Iterable(Unicode))
def balancePerCurrency(currency, id):
try:
connection = mysql.connector.connect(host='127.0.0.1',
database='arbolito',
user='******',
password='******')
cursor = connection.cursor()
args = [
id,
currency,
]
cursor.callproc("balancePerCurrency", args)
for result in cursor.stored_results():
tup = result.fetchone()
str1 = " ".join(map(str, tup))
return str1, 200
except mysql.connector.Error as error:
print("Failed to execute stored procedure: {}".format(error))
finally:
if (connection.is_connected()):
cursor.close()
connection.close()
print("MySQL connection is closed")
class JsonService(ServiceBase):
@rpc(_returns=Iterable(Unicode))
def get_json(self):
jsn = m.read_json()
return HttpResponse(jsn)
class XmlService(ServiceBase):
@rpc(_returns=Iterable(Unicode))
def get_xml(self):
xml = m.read_xml()
return HttpResponse(xml)
class HelloWorldService(ServiceBase):
@rpc(Unicode, _returns=Iterable(Unicode))
def hello(ctx, name):
return f'Hello, {name}'
class SomeService(ServiceBase):
@srpc(_returns=Iterable(Integer))
def some_call():
return 1, 2
class HelloWorldService(Service):
@rpc(Unicode, Integer, _returns=Iterable(Unicode))
def hello(ctx, name, times):
name = name or ctx.udc.config['HELLO']
for i in range(times):
yield u'Hello, %s' % name
class SomeService(ServiceBase):
@srpc(Iterable(String), _returns=Iterable(String))
def some_call(s):
return s
class HelloWorldService(ServiceBase):
# '''sskdjf谁看得见发牢骚降低非'''
@srpc(String, UnsignedInteger, _returns=Iterable(String))
def say_hello(name, times):
for i in xrange(times):
yield 'Hello,%s' % name
class HelloWorldService(ServiceBase):
@rpc(Unicode, Integer, _returns=Iterable(Unicode))
def say_hello(ctx, name, times):
for i in range(times):
yield 'Hola, %s' % name
class AutoConfigServer(ServiceBase):
""" TR-069 ACS implementation. The TR-069/CWMP RPC messages are defined, as
per cwmp-1-0.xsd schema definition, in the RPC decorators below. These
RPC methods are intended to be called by TR-069-compliant customer
premesis equipment (CPE), over the SOAP/HTTP interface defined by
TR-069.
Per spyne documentation, this class is never instantiated, so all RPC
functions are implicitly staticmethods. Hence use static class variables
to hold state.
This also means that only a single thread can be used (since there are
no locks).
Note that staticmethod decorator can't be used in conjunction with rpc
decorator.
"""
__out_header__ = models.ID
__in_header__ = models.ID
_acs_to_cpe_queue = None
_cpe_to_acs_queue = None
""" Set maxEnvelopes to 1, as per TR-069 spec """
_max_envelopes = 1
@classmethod
def set_state_machine_pointer(
cls,
state_machine_pointer: StateMachinePointer
) -> None:
cls.state_machine_pointer = state_machine_pointer
@classmethod
def get_new_state_machine(
cls,
device_name: EnodebDeviceName,
) -> EnodebAcsStateMachine:
"""
Create a new state machine because the previous used data model was
incorrect
"""
device_handler_class = get_device_handler_from_name(device_name)
service = cls.state_machine().service
stats_mgr = cls.state_machine().stats_manager
acs_state_machine = device_handler_class(service, stats_mgr)
return acs_state_machine
@classmethod
def _handle_tr069_message(cls, ctx: Any, message: ComplexModelBase) -> Any:
if not cls.state_machine():
raise Tr069Error('ACS not given eNB state machine')
# Log incoming msg
if hasattr(message, 'as_dict'):
logging.debug('Handling TR069 message: %s', str(type(message)))
else:
logging.debug('Handling TR069 message.')
try:
req = cls.state_machine().handle_tr069_message(message)
except IncorrectDeviceHandlerError as err:
logging.warning('Incorrect device_handler! Switching to : %s',
str(err.device_name))
cls.set_state_machine(
cls.get_new_state_machine(err.device_name))
# Retry with the new state machine
req = cls.state_machine().handle_tr069_message(message)
# Log outgoing msg
if hasattr(req, 'as_dict'):
logging.debug('Sending TR069 message: %s', str(req.as_dict()))
else:
logging.debug('Sending TR069 message.')
# Set header
ctx.out_header = models.ID(mustUnderstand='1')
ctx.out_header.Data = 'null'
# Set return message name
if isinstance(req, models.DummyInput):
# Generate 'empty' request to CPE using empty message name
ctx.descriptor.out_message.Attributes.sub_name = 'EmptyHttp'
return models.AcsToCpeRequests()
ctx.descriptor.out_message.Attributes.sub_name = req.__class__.__name__
return cls._generate_acs_to_cpe_request_copy(req)
@staticmethod
def _generate_acs_to_cpe_request_copy(request):
""" Create an AcsToCpeRequests instance with all the appropriate
members set from the input request. AcsToCpeRequests is a union of
all request messages, so field names match.
"""
request_out = models.AcsToCpeRequests()
for parameter in request.get_flat_type_info(request.__class__):
try:
setattr(request_out, parameter, getattr(request, parameter))
except(AttributeError):
# Allow un-set parameters. If CPE can't handle this, it will
# respond with an error message
pass
return request_out
@classmethod
def state_machine(cls) -> EnodebAcsStateMachine:
return cls.state_machine_pointer.state_machine
@classmethod
def set_state_machine(cls, state_machine: EnodebAcsStateMachine) -> None:
cls.state_machine_pointer.state_machine = state_machine
# CPE->ACS RPC calls
@rpc(_returns=Iterable(String),
_operation_name="GetRPCMethods")
def get_rpc_methods(ctx):
""" GetRPCMethods RPC call is terminated here. No need to pass to higher
layer """
fill_response_header(ctx)
for rpc_method in RPC_METHODS:
yield '%s' % rpc_method
@rpc(models.Inform,
_returns=models.InformResponse,
_body_style="bare",
_operation_name="Inform",
_out_message_name="InformResponse")
def inform(ctx, request):
""" Inform response generated locally """
fill_response_header(ctx)
resp = AutoConfigServer._handle_tr069_message(ctx, request)
resp.MaxEnvelopes = AutoConfigServer._max_envelopes
return resp
@rpc(models.TransferComplete,
_returns=models.TransferCompleteResponse,
_body_style="bare",
_operation_name="TransferComplete",
_out_message_name="TransferCompleteResponse")
def transfer_complete(ctx, request):
fill_response_header(ctx)
resp = AutoConfigServer._handle_tr069_message(ctx, request)
resp.MaxEnvelopes = AutoConfigServer._max_envelopes
return resp
# Spyne does not handle no input or SimpleModel input for 'bare' function
# DummyInput is unused
# pylint: disable=unused-argument
@rpc(models.DummyInput,
_returns=models.AcsToCpeRequests,
_out_message_name="EmptyHttp",
_body_style='bare',
_operation_name="EmptyHttp")
def empty_http(ctx, dummy):
# Function to handle empty HTTP request
return AutoConfigServer._handle_tr069_message(ctx, dummy)
# CPE->ACS responses to ACS->CPE RPC calls
@rpc(models.SetParameterValuesResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="SetParameterValuesResponse")
def set_parameter_values_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.GetParameterValuesResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="GetParameterValuesResponse")
def get_parameter_values_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.GetParameterNamesResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="GetParameterNamesResponse")
def get_parameter_names_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.SetParameterAttributesResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="SetParameterAttributesResponse")
def set_parameter_attributes_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.GetParameterAttributesResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="GetParameterAttributesResponse")
def get_parameter_attributes_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.AddObjectResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="AddObjectResponse")
def add_object_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.DeleteObjectResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="DeleteObjectResponse")
def delete_object_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.DownloadResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="DownloadResponse")
def download_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.RebootResponse,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="RebootResponse")
def reboot_response(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)
@rpc(models.Fault,
_returns=models.AcsToCpeRequests,
_out_message_name="MessageNameToBeReplaced",
_body_style='bare',
_operation_name="Fault")
def fault(ctx, response):
return AutoConfigServer._handle_tr069_message(ctx, response)