def getEvents(self):
"""
Get Events off the DXL fabric
"""
## Create Web API request queue
SERVICE_TYPE = "/opendxl/webapi"
REQUEST_TOPIC = SERVICE_TYPE + "/requests"
class MyRequestCallback(RequestCallback):
def on_request(self, request):
# Extract
print("Service recieved request payload: " +
request.payload.decode())
# Create the client
with DxlClient(config) as client:
# Connect to the fabric
client.connect()
## Register with ePO and add the request topic
info = ServiceRegistrationInfo(client, SERVICE_TYPE)
client.register_service_sync(info, 10)
info.add_topic(REQUEST_TOPIC, MyRequestCallback())
## Get list of vendorIDs and subscribe to each topic
#vendorList = getVendorList()
#for vendor in vendorList:
# client.add_event_callback(vendorsDict[vendor]['topic'], ChgRepCallback())
client.disconnect()
## Listent to Events
print("Listening for Events")
while not thread_stop_event.isSet():
time.sleep(self.delay)
def __init__(self, client):
self._client = client
# Create DXL Service Registration object
self._service_registration_info = ServiceRegistrationInfo(
self._client, "/opendxl/mocktieserver")
self._mock_event = None
def __init__(self, client):
self._client = client
# Create DXL Service Registration object
self._service_registration_info = ServiceRegistrationInfo(
self._client,
VirusTotalApiClient._SERVICE_TYPE,
)
self._service_registration_info._ttl_lower_limit = 5
self._service_registration_info.ttl = 5
def __init__(self, client, id_number=0):
self._client = client
self.id_number = id_number
# Create DXL Service Registration object
self._service_registration_info = ServiceRegistrationInfo(
self._client,
"/mcafee/service/epo/remote",
)
self._service_registration_info._ttl_lower_limit = 5
self._service_registration_info.ttl = 5
def __register_service(self):
registration = ServiceRegistrationInfo(self.dxl_conn,
self.__config.type)
for name, constructor in SERVICE_ENDPOINTS:
topic = '{}/{}'.format(self.__config.type, name)
registration.add_topic(
topic,
constructor(
self.__monitoring_ctx.register(
ServiceEndpointMonitor('endpoint.' + topic)), self))
self.dxl_conn.register_service_sync(registration, 2)
def initialize(self):
self.dxl.connect()
service_reg = ServiceRegistrationInfo(self.dxl, self.__config.type)
# Register the endpoints that the service provides
for endpoint in self.__config.endpoints:
topic = '{}/{}'.format(self.__config.type, endpoint.name)
monitor = self.__monitoring_ctx.register(
ServiceEndpointMonitor('endpoints.{}'.format(topic)))
service_reg.add_topic(topic, Dispatcher(endpoint, monitor, self))
self.dxl.register_service_sync(service_reg, 2)
def __register_service(self):
"""
Create dispatchers for each endpoint provided by the GRR API and register the service with the OpenDXL service
fabric
:return: None
"""
svc = ServiceRegistrationInfo(self.dxlc, self.__config.service_type)
for endpoint in self.__endpoints:
topic = self.__config.service_type + '/' + endpoint.name
svc.add_topic(topic,
Dispatcher(endpoint, self,
self.__register_monitor(ServiceEndpointMonitor('endpoints.' + topic))))
self.dxlc.register_service_sync(svc, 5)
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# Register service
logger.info("Registering service: %s", "apivoidservice")
service = ServiceRegistrationInfo(self._dxl_client, self.SERVICE_TYPE)
for topic_key in self.REQ_TOPICS_DICT:
topic = topic_key
# Register request callback for this API call
logger.info("Registering request callbacks: %s", topic)
self.add_request_callback(
service,
topic,
ApiVoidCallback(self, self.REQ_TOPICS_DICT[topic_key]),
False
)
topic += "/" + self.REQ_TOPIC_SUFFIX_STATS
# Register "Stats Remained" for this API call
logger.info("Registering request callback: %s", topic)
self.add_request_callback(
service,
topic,
ApiVoidCallback(self),
False
)
self.register_service(service)
def run_sample_with_service(self, sample_file, sample_args, storage_dir):
config = DxlClientConfig.create_dxl_config_from_file(
self._CONFIG_FILE)
with DxlClient(config) as dxl_client:
dxl_client.connect()
info = ServiceRegistrationInfo(
dxl_client, "test-file-transfer-service")
info.add_topic(FileTransferClient._DEFAULT_FILE_SEND_TOPIC,
TestFileStoreRequestCallback(dxl_client,
storage_dir))
dxl_client.register_service_sync(
info, self._SERVICE_REG_INFO_TIMEOUT)
mock_print = self.run_sample(sample_file, sample_args)
dxl_client.unregister_service_sync(
info, self._SERVICE_REG_INFO_TIMEOUT)
return mock_print
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# Register service 'fake_mcafee_service'
logger.info("Registering service: {0}".format("fake_mcafee_service"))
service = ServiceRegistrationInfo(self._dxl_client, "/fake/mcafee/services")
mar_topic = "/mcafee/mar/service/api/search"
logger.info("Registering request callback: {0}".format(mar_topic))
self.add_request_callback(
service,
mar_topic,
FakeMarApiSearchRequestCallback(
self,
self._mar_status_checks_until_request_finished),
True)
tie_callback = FakeTieCallback(self)
for tie_topic in [FakeTieCallback.TIE_GET_AGENTS_FOR_FILE_TOPIC,
FakeTieCallback.TIE_GET_FILE_REPUTATION_TOPIC,
FakeTieCallback.TIE_SET_FILE_REPUTATION_TOPIC,
FakeTieCallback.TIE_GET_AGENTS_FOR_CERT_TOPIC,
FakeTieCallback.TIE_GET_CERT_REPUTATION_TOPIC,
FakeTieCallback.TIE_SET_CERT_REPUTATION_TOPIC]:
logger.info("Registering request callback: {0}".format(tie_topic))
self.add_request_callback(service, tie_topic, tie_callback, True)
self.register_service(service)
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# Register service
service = ServiceRegistrationInfo(self.client, self.DXL_SERVICE_TYPE)
for request_topic in self._epo_by_topic:
service.add_topic(
str(request_topic),
_EpoRequestCallback(self.client, self._epo_by_topic))
logger.info("Registering service ...")
self.client.register_service_sync(
service, self.DXL_SERVICE_REGISTRATION_TIMEOUT)
logger.info("Service registration succeeded.")
self._dxl_service = service
def __init__(self,
client,
id_number=0,
use_commands_service=True,
user_authorized=True):
self._client = client
self.id_number = id_number
self.use_commands_service = use_commands_service
self.user_authorized = user_authorized
# Create DXL Service Registration object
self._service_registration_info = ServiceRegistrationInfo(
self._client,
"/mcafee/service/epo/commands"
if self.use_commands_service else "/mcafee/service/epo/remote"
)
self._service_registration_info._ttl_lower_limit = 5
self._service_registration_info.ttl = 5
if self.use_commands_service:
self._service_registration_info.metadata = \
{"epoGuid": LOCAL_TEST_SERVER_NAME + str(id_number)}
class MockEpoServer(object):
def __init__(self,
client,
id_number=0,
use_commands_service=True,
user_authorized=True):
self._client = client
self.id_number = id_number
self.use_commands_service = use_commands_service
self.user_authorized = user_authorized
# Create DXL Service Registration object
self._service_registration_info = ServiceRegistrationInfo(
self._client,
"/mcafee/service/epo/commands"
if self.use_commands_service else "/mcafee/service/epo/remote"
)
self._service_registration_info._ttl_lower_limit = 5
self._service_registration_info.ttl = 5
if self.use_commands_service:
self._service_registration_info.metadata = \
{"epoGuid": LOCAL_TEST_SERVER_NAME + str(id_number)}
def __enter__(self):
mock_callback = FakeEpoServerCallback(self._client,
self.id_number,
self.use_commands_service,
self.user_authorized)
self._service_registration_info.add_topic(
mock_callback.epo_request_topic,
mock_callback
)
self._client.register_service_sync(self._service_registration_info, 10)
def __exit__(self, exc_type, exc_val, exc_tb):
self._client.unregister_service_sync(self._service_registration_info,
10)
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# Register service 'tide_srv'
logger.info("Registering service: {0}".format("tide_srv"))
service = ServiceRegistrationInfo(self._dxl_client,
"/infoblox/activetrust/tide")
logger.info("Registering request callback: {0}".format("tide_req"))
self.add_request_callback(service, "/infoblox/activetrust/tide",
TIDECallback(self), True)
self.register_service(service)
# Register service 'tide_lookup_srv'
logger.info("Registering service: {0}".format("tide_lookup_srv"))
service = ServiceRegistrationInfo(self._dxl_client,
"/infoblox/activetrust/tide_lookup")
logger.info(
"Registering request callback: {0}".format("tide_lookup_req"))
self.add_request_callback(service, "/infoblox/activetrust/tide_lookup",
TIDELookupCallback(self), True)
self.register_service(service)
# Register service 'dossier_srv'
logger.info("Registering service: {0}".format("dossier_srv"))
service = ServiceRegistrationInfo(self._dxl_client,
"/infoblox/activetrust/dossier")
logger.info("Registering request callback: {0}".format("dossier_req"))
self.add_request_callback(service, "/infoblox/activetrust/dossier",
DossierCallback(self), True)
self.register_service(service)
# Register service 'dossier_lookup_srv'
logger.info("Registering service: {0}".format("dossier_lookup_srv"))
service = ServiceRegistrationInfo(
self._dxl_client, "/infoblox/activetrust/dossier_lookup")
logger.info(
"Registering request callback: {0}".format("dossier_lookup_req"))
self.add_request_callback(service,
"/infoblox/activetrust/dossier_lookup",
DossierLookupCallback(self), True)
self.register_service(service)
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# Register service 'vtapiservice'
logger.info("Registering service: {0}".format("vtapiservice"))
service = ServiceRegistrationInfo(self._dxl_client, self.SERVICE_TYPE)
logger.info("Registering request callback: {0}".format("file_rescan"))
self.add_request_callback(
service, self.REQ_TOPIC_FILE_RESCAN,
VirusTotalApiRequestCallback(
self, False, [VirusTotalApiRequestCallback.PARAM_RESOURCE]),
False)
logger.info("Registering request callback: {0}".format("file_report"))
self.add_request_callback(
service, self.REQ_TOPIC_FILE_REPORT,
VirusTotalApiRequestCallback(
self, True, [VirusTotalApiRequestCallback.PARAM_RESOURCE]),
False)
logger.info("Registering request callback: {0}".format("url_scan"))
self.add_request_callback(
service, self.REQ_TOPIC_URL_SCAN,
VirusTotalApiRequestCallback(
self, False, [VirusTotalApiRequestCallback.PARAM_URL]), False)
logger.info("Registering request callback: {0}".format("url_report"))
self.add_request_callback(
service, self.REQ_TOPIC_URL_REPORT,
VirusTotalApiRequestCallback(
self, False, [VirusTotalApiRequestCallback.PARAM_RESOURCE]),
False)
logger.info(
"Registering request callback: {0}".format("ipaddress_report"))
self.add_request_callback(
service, self.REQ_TOPIC_IP_ADDRESS_REPORT,
VirusTotalApiRequestCallback(
self, True, [VirusTotalApiRequestCallback.PARAM_IP]), False)
logger.info(
"Registering request callback: {0}".format("domain_report"))
self.add_request_callback(
service, self.REQ_TOPIC_DOMAIN_REPORT,
VirusTotalApiRequestCallback(
self, True, [VirusTotalApiRequestCallback.PARAM_DOMAIN]),
False)
self.register_service(service)
def _dxl_connect(self):
"""
Attempts to connect to the DXL fabric and register the ePO DXL service
"""
# Connect to fabric
config = DxlClientConfig.create_dxl_config_from_file(
self._dxlclient_config_path)
config.incoming_message_thread_pool_size = self._incoming_thread_count
config.incoming_message_queue_size = self._incoming_queue_size
logger.info(
"Incoming message configuration: queueSize={0}, threadCount={1}".
format(config.incoming_message_queue_size,
config.incoming_message_thread_pool_size))
client = DxlClient(config)
logger.info("Attempting to connect to DXL fabric ...")
client.connect()
logger.info("Connected to DXL fabric.")
try:
# Register service
service = ServiceRegistrationInfo(client, self.DXL_SERVICE_TYPE)
for request_topic in self._epo_by_topic:
service.add_topic(
str(request_topic),
_EpoRequestCallback(client, self._epo_by_topic))
logger.info("Registering service ...")
client.register_service_sync(service,
self.DXL_SERVICE_REGISTRATION_TIMEOUT)
logger.info("Service registration succeeded.")
except:
client.destroy()
raise
self._dxl_client = client
self._dxl_service = service
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# Register service 'maxmind_geolocation_service'
logger.info("Registering service: %s", "maxmind_geolocation_service")
service = ServiceRegistrationInfo(
self._dxl_client, "/opendxl-maxmind/service/geolocation")
logger.info("Registering request callback: %s",
"maxmind_service_hostlookup")
self.add_request_callback(
service, "/opendxl-maxmind/service/geolocation/host_lookup",
MaxMindHostLookupRequestCallback(self), True)
self.register_service(service)
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# Register service 'nmapservice'
logger.info("Registering service: {0}".format("nmapservice"))
service = ServiceRegistrationInfo(self._dxl_client, self.SERVICE_TYPE)
# See callback format
logger.info("Registering request callback: {0}".format("Scan report"))
self.add_request_callback(service, self._REQ_SCAN,
NmapServiceRequestCallback(self, dict), True)
self.register_service(service)
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
callbacks = {
"create_case": TheHiveCreateCaseRequestCallback,
"create_case_task": TheHiveCreateCaseTaskRequestCallback,
"create_case_observable":
TheHiveCreateCaseObservableRequestCallback,
"get_case": TheHiveGetCaseRequestCallback,
"get_case_task": TheHiveGetCaseTaskRequestCallback,
"get_case_observable": TheHiveGetCaseObservableRequestCallback,
"search_case": TheHiveSearchCaseRequestCallback,
"search_case_task": TheHiveSearchCaseTaskRequestCallback,
"search_case_observable":
TheHiveSearchCaseObservableRequestCallback,
"create_alert": TheHiveCreateAlertRequestCallback,
"get_alert": TheHiveGetAlertRequestCallback,
"search_alert": TheHiveSearchAlertRequestCallback
}
# Register service 'thehive_service'
logger.info("Registering service: %s", "thehive_service")
service = ServiceRegistrationInfo(self._dxl_client, self._SERVICE_TYPE)
logger.info("Connecting to API URL: %s", self._api_url)
thehive_client = TheHiveClient(self._dxl_client, self._api_url,
self._api_principal, self._api_password,
self._verify_certificate)
for api_name in self._api_names:
api_method = callbacks.get(api_name, None)
if api_method:
topic_name_end, _, topic_name_start = api_name.partition("_")
topic_name = "{}{}/{}/{}".format(
self._SERVICE_TYPE,
"/{}".format(self._service_unique_id) \
if self._service_unique_id else "",
topic_name_start.replace("_", "/"),
topic_name_end)
logger.info(
"Registering request callback: thehive_%s_requesthandler",
api_name)
self.add_request_callback(
service, topic_name,
api_method(self._dxl_client, thehive_client), False)
else:
logger.warning("API name is invalid: %s", api_name)
self.register_service(service)
class MockEpoServer(object):
def __init__(self, client, id_number=0):
self._client = client
self.id_number = id_number
# Create DXL Service Registration object
self._service_registration_info = ServiceRegistrationInfo(
self._client,
"/mcafee/service/epo/remote",
)
self._service_registration_info._ttl_lower_limit = 5
self._service_registration_info.ttl = 5
def __enter__(self):
mock_callback = FakeEpoServerCallback(self._client, self.id_number)
self._service_registration_info.add_topic(
mock_callback.epo_request_topic, mock_callback)
self._client.register_service_sync(self._service_registration_info, 10)
def __exit__(self, exc_type, exc_val, exc_tb):
self._client.unregister_service_sync(self._service_registration_info,
10)
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# Register service 'file_transfer_service'
logger.info("Registering service: file_transfer_service")
service = ServiceRegistrationInfo(self._dxl_client, self._SERVICE_TYPE)
logger.info("Registering request callback: %s. Topic: %s.",
"file_transfer_service_file_store", self._store_topic)
self.add_request_callback(
service, self._store_topic,
FileStoreRequestCallback(self.client, self._storage_dir,
self._working_dir), False)
self.register_service(service)
def on_register_services(self):
"""
Invoked when services should be registered with the application
"""
# For methods where "query" is the only required parameter (the
# majority)
query_param = ["query"]
# List of callbacks to register. Each item's key is the name of the
# service to register. The associated value for each item is a list
# of parameters which are required when invoking the service.
callbacks = OrderedDict(
(("account_information", None), ("brand_monitor", query_param),
("domain_profile", query_param), ("domain_search", query_param),
("domain_suggestions", query_param), ("host_domains", ["ip"]),
("hosting_history", query_param), ("ip_monitor", query_param),
("ip_registrant_monitor",
query_param), ("iris", None), ("name_server_monitor",
query_param), ("parsed_whois",
query_param),
("phisheye", query_param), ("phisheye_term_list", None),
("registrant_monitor",
query_param), ("reputation", query_param), ("reverse_ip", [
"domain"
]), ("reverse_ip_whois", None), ("reverse_name_server",
query_param), ("reverse_whois",
query_param),
("whois", query_param), ("whois_history", query_param)))
# Register service 'domaintools_service'
logger.info("Registering service: domaintools_service")
service = ServiceRegistrationInfo(
self._dxl_client, "/opendxl-domaintools/service/domaintools")
for service_name, required_params in callbacks.items():
logger.info(
"Registering request callback: domaintools_%s_requesthandler",
service_name)
self.add_request_callback(
service, "{}/{}".format(self.SERVICE_TYPE, service_name),
DomainToolsRequestCallback(self, service_name,
required_params), False)
self.register_service(service)
# Create DXL configuration from file
config = DxlClientConfig.create_dxl_config_from_file(CONFIG_FILE)
# Create the client
with DxlClient(config) as client:
# Connect to the fabric
client.connect()
class MyRequestCallback(RequestCallback):
def on_request(self, request):
# Extract
print "Service recieved request payload: " + request.payload.decode(
)
# Create the response message
res = Response(request)
res.payload = "pong".encode()
# Send the response
client.send_event_response(res)
# Create service reg object
info = ServiceRegistrationInfo(client, "ScottoService")
# Add topic for the service to repond to
info.add_topic(SERVICE_TOPIC, MyRequestCallback())
# Register the service with the fabric ( wait up to 10 seconds for registration to complete)
client.register_service_sync(info, 10)
logger.info("Ping Service is running ... ")
while True:
time.sleep(60)
class MockTieServer(object):
def __init__(self, client):
self._client = client
# Create DXL Service Registration object
self._service_registration_info = ServiceRegistrationInfo(
self._client, "/opendxl/mocktieserver")
def __enter__(self):
mock_callback = FakeTieServerCallback(self._client)
self._service_registration_info.add_topic(
dxltieclient.client.TIE_GET_FILE_REPUTATION_TOPIC, mock_callback)
self._service_registration_info.add_topic(
dxltieclient.client.TIE_GET_CERT_REPUTATION_TOPIC, mock_callback)
self._service_registration_info.add_topic(
dxltieclient.client.TIE_SET_FILE_REPUTATION_TOPIC, mock_callback)
self._service_registration_info.add_topic(
dxltieclient.client.TIE_SET_CERT_REPUTATION_TOPIC, mock_callback)
self._service_registration_info.add_topic(
dxltieclient.client.TIE_GET_FILE_FIRST_REFS, mock_callback)
self._service_registration_info.add_topic(
dxltieclient.client.TIE_GET_CERT_FIRST_REFS, mock_callback)
self._client.register_service_sync(self._service_registration_info, 10)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._client.unregister_service_sync(self._service_registration_info,
10)
class MockVtService(object):
mockvt_basic_test_topic = FakeVTServiceCallback.vt_basic_test_topic
def __init__(self, client):
self._client = client
# Create DXL Service Registration object
self._service_registration_info = ServiceRegistrationInfo(
self._client,
VirusTotalApiClient._SERVICE_TYPE,
)
self._service_registration_info._ttl_lower_limit = 5
self._service_registration_info.ttl = 5
def __enter__(self):
mock_callback = FakeVTServiceCallback(self._client)
self._service_registration_info.add_topic(
MockVtService.mockvt_basic_test_topic, mock_callback)
self._service_registration_info.add_topic(
VirusTotalApiClient._REQ_TOPIC_DOMAIN_REPORT, mock_callback)
self._service_registration_info.add_topic(
VirusTotalApiClient._REQ_TOPIC_FILE_REPORT, mock_callback)
self._service_registration_info.add_topic(
VirusTotalApiClient._REQ_TOPIC_FILE_RESCAN, mock_callback)
self._service_registration_info.add_topic(
VirusTotalApiClient._REQ_TOPIC_IP_ADDRESS_REPORT, mock_callback)
self._service_registration_info.add_topic(
VirusTotalApiClient._REQ_TOPIC_URL_REPORT, mock_callback)
self._service_registration_info.add_topic(
VirusTotalApiClient._REQ_TOPIC_URL_SCAN, mock_callback)
self._client.register_service_sync(self._service_registration_info, 10)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._client.unregister_service_sync(self._service_registration_info,
10)
message_type = j["message_type"]
if message_type == MessageType.INITIATE_ASSESSMENT.value:
iam = InitiateAssessmentMessage()
iam.parse(event.payload.decode())
store_request(iam)
elif message_type == MessageType.REPORT_RESULTS.value:
rrsm = ReportResultsMessage()
rrsm.parse(event.payload.decode())
store_results(rrsm)
elif message_type == MessageType.REGISTRATION.value:
rm = RegistrationMessage()
rm.parse(event.payload.decode())
store_assets(rm)
else:
store_arbitrary_data(event.payload.decode())
# Prepare service registration information
info = ServiceRegistrationInfo(client, "/scap/repository")
# Connect to the message fabric and add listeners for query requests and
# storage requests
client.connect()
client.add_event_callback(EVENT_STORE_DATA_TOPIC, StoreDataEventCallback())
info.add_topic(SERVICE_REPOSITORY_QUERY_TOPIC, QueryRequestCallback())
client.register_service_sync(info, 10)
# Wait forever
while True:
time.sleep(1)
assessment_requests.append(cam)
# Cancel request didn't come from originating application so ignore
else:
logger.info("Ignoring cancel request " + cam.transaction_id +
" for application " + cam.requestor_id)
# Send request acknowledgement message with the transaction
# id that was cancelled
res = Response(request)
ram = RequestAcknowledgementMessage()
ram.transaction_id = cam.transaction_id
res.payload = (ram.to_json()).encode()
client.send_response(res)
# Prepare service registration information
info = ServiceRegistrationInfo(client, "/scap/manager")
# Have manager provide assessment request, cancel assessment, and query services
info.add_topic(SERVICE_INITIATE_ASSESSMENT_TOPIC,
InitiateAssessmentCallback())
info.add_topic(SERVICE_CANCEL_ASSESSMENT_TOPIC, CancelAssessmentCallback())
# Connect to the message fabric and register the service
client.connect()
client.register_service_sync(info, 10)
# Wait forever
while True:
# Process all initiate assessment requests that were received
while assessment_requests:
ar = assessment_requests.pop(0)
# Create the response message
response = Response(request)
# Populate the response payload
response.payload = weather_response.encode(encoding="UTF-8")
# Send the response
client.send_response(response)
except Exception as ex:
print str(ex)
# Send error response
client.send_response(
ErrorResponse(
request,
error_message=str(ex).encode(encoding="UTF-8")))
# Create service registration object
info = ServiceRegistrationInfo(client, SERVICE_NAME)
# Add a topic for the service to respond to
info.add_topic(SERVICE_CURRENT_WEATHER_TOPIC, CurrentWeatherCallback())
# Register the service with the fabric (wait up to 10 seconds for registration to complete)
client.register_service_sync(info, 10)
logger.info("Weather service is running...")
# Wait forever
while True:
time.sleep(60)
sys.stdout.write("\rPercent complete: {}%".format(
int((segment_number / total_segments) *
100) if total_segments else 100))
sys.stdout.flush()
# Create the client
with DxlClient(config) as dxl_client:
# Connect to the fabric
dxl_client.connect()
logger.info("Connected to DXL fabric.")
# Create service registration object
info = ServiceRegistrationInfo(dxl_client, "myService")
# Add a topic for the service to respond to
info.add_topic(SERVICE_TOPIC,
FileStoreRequestCallback(dxl_client, STORAGE_DIR))
# Register the service with the fabric (wait up to 10 seconds for
# registration to complete)
dxl_client.register_service_sync(info, 10)
# Create client wrapper
file_transfer_client = FileTransferClient(dxl_client, SERVICE_TOPIC)
start = time.time()
# Invoke the send file request method to store the file on the server
logger.info(
"Service Provider - Creating Response for Request ID %s on %s",
request.message_id, request.destination_topic)
response = Response(request)
# Encode string payload as UTF-8
response.payload = "Sample Response Payload".encode()
# Send the Response back
logger.info(
"Service Provider - Sending Response to Request ID: %s on %s",
response.request_message_id, request.destination_topic)
client.send_response(response)
# Create DXL Service Registration object
service_registration_info = ServiceRegistrationInfo(
client, "/mycompany/myservice")
# Add a topic for the service to respond to
service_registration_info.add_topic(SERVICE_TOPIC, MyRequestCallback())
# Register the service with the DXL fabric (with a wait up to 10 seconds for registration to complete)
logger.info("Registering service.")
client.register_service_sync(service_registration_info, 10)
# Wait for DXL Requests
while True:
print " Enter 9 to quit"
input = raw_input(" Enter value: ")
try:
option = int(input)
