def add_data_to_meta_data_service(self, key, value):
"""
add data to meta data service
:return: void
"""
mdsclient.MDSPutRequest()
data = {"key": key, "values": [value]}
mdsclient.put(data, app=True)
def run_plugin(self, values):
log = LogFactory().get_log(__name__)
log.info("Starting tomcat metadata publisher...")
# publish callback and issuer id from tomcat for IS to pickup
publish_data = mdsclient.MDSPutRequest()
# hostname_entry = {"key": "TOMCAT_HOSTNAME", "values": member_hostname}
cluster_hostname = values["HOST_NAME"]
log.info("Reading port mappings...")
port_mappings_str = values["PORT_MAPPINGS"]
tomcat_http_port = None
# port mappings format: """NAME:mgt-console|PROTOCOL:https|PORT:4500|PROXY_PORT:8443;
# NAME:tomcat-http|PROTOCOL:http|PORT:4501|PROXY_PORT:7280;"""
log.info("Port mappings: %s" % port_mappings_str)
if port_mappings_str is not None:
port_mappings_array = port_mappings_str.split(";")
if port_mappings_array:
for port_mapping in port_mappings_array:
log.debug("port_mapping: %s" % port_mapping)
name_value_array = port_mapping.split("|")
name = name_value_array[0].split(":")[1]
protocol = name_value_array[1].split(":")[1]
port = name_value_array[2].split(":")[1]
if name == "tomcat-http" and protocol == "http":
tomcat_http_port = port
log.info("Kubernetes service port of tomcat http transport: %s" %
tomcat_http_port)
callback_url = "http://%s:%s/travelocity.com/home.jsp" % (
cluster_hostname, tomcat_http_port)
callback_url_property = {
"key": "CALLBACK_URL",
"values": [callback_url]
}
mdsclient.put(callback_url_property, app=True)
log.info("Published property to metadata API: CALLBACK_URL: %s" %
callback_url)
issuer_property = {"key": "SSO_ISSUER", "values": ["travelocity.com"]}
mdsclient.put(issuer_property, app=True)
log.info(
"Published property to metadata API: SSO_ISSUER: travelocity.com")
log.info("Tomcat metadata publisher completed")
def run_plugin(self, values):
# publish callback and issuer id from tomcat for IS to pickup
publish_data = mdsclient.MDSPutRequest()
# hostname_entry = {"key": "TOMCAT_HOSTNAME", "values": member_hostname}
cluster_hostname = values["HOST_NAME"]
# set port name checking if lb is present or not
payload_ports = values["PORT_MAPPINGS"].split("|")
if values.get("LB_CLUSTER_ID") is not None:
port_no = payload_ports[2].split(":")[1]
else:
port_no = payload_ports[1].split(":")[1]
callback_url = "http://%s:%s/travelocity.com/home.jsp" % (
cluster_hostname, port_no)
saml_callback_entry = {"key": "CALLBACK_URL", "values": callback_url}
issuer_entry = {"key": "SSO_ISSUER", "values": "travelocity.com"}
# properties_data = [hostname_entry, saml_callback_entry]
properties_data = [saml_callback_entry, issuer_entry]
publish_data.properties = properties_data
mdsclient.put(publish_data, app=True)
def run_plugin(self, values):
log = LogFactory().get_log(__name__)
# read tomcat app related values from metadata
mds_response = None
while mds_response is None:
log.debug(
"Waiting for SSO_ISSUER and CALLBACK_URL to be available from metadata service for app ID: %s"
% values["APPLICATION_ID"])
time.sleep(5)
mds_response = mdsclient.get(app=True)
if mds_response is not None:
if mds_response.properties.get("SSO_ISSUER") is None or \
mds_response.properties.get("CALLBACK_URL") is None:
mds_response = None
# mds_response = mdsclient.get()
issuer = mds_response.properties["SSO_ISSUER"]
acs = mds_response.properties["CALLBACK_URL"]
# add a service provider in the security/sso-idp-config.xml file
# is_root = values["APPLICATION_PATH"]
is_root = os.environ.get("CARBON_HOME")
sso_idp_file = "%s/repository/conf/security/sso-idp-config.xml" % is_root
# <SSOIdentityProviderConfig>
# <ServiceProviders>
# <ServiceProvider>
# <Issuer>wso2.my.dashboard</Issuer>
# <AssertionConsumerService>https://is.wso2.com/dashboard/acs</AssertionConsumerService>
# <SignAssertion>true</SignAssertion>
# <SignResponse>true</SignResponse>
# <EnableAttributeProfile>false</EnableAttributeProfile>
# <IncludeAttributeByDefault>false</IncludeAttributeByDefault>
# <Claims>
# <Claim>http://wso2.org/claims/role</Claim>
# </Claims>
# <EnableSingleLogout>false</EnableSingleLogout>
# <SingleLogoutUrl></SingleLogoutUrl>
# <EnableAudienceRestriction>true</EnableAudienceRestriction>
# <AudiencesList>
# <Audience>carbonServer</Audience>
# </AudiencesList>
# <ConsumingServiceIndex></ConsumingServiceIndex>
# </ServiceProvider>
with open(sso_idp_file, "r") as f:
sp_dom = parse(f)
root_element = sp_dom.documentElement
sps_element = sp_dom.getElementsByTagName("ServiceProviders")[0]
sp_entry = sp_dom.createElement("ServiceProvider")
sp_entry_issuer = sp_dom.createElement("Issuer")
sp_entry_issuer.appendChild(sp_dom.createTextNode(issuer))
sp_entry_acs = sp_dom.createElement("AssertionConsumerService")
sp_entry_acs.appendChild(sp_dom.createTextNode(acs))
sp_entry_sign_resp = sp_dom.createElement("SignResponse")
sp_entry_sign_resp.appendChild(sp_dom.createTextNode("true"))
sp_entry_sign_assert = sp_dom.createElement("SignAssertion")
sp_entry_sign_assert.appendChild(sp_dom.createTextNode("true"))
sp_entry_single_logout = sp_dom.createElement("EnableSingleLogout")
sp_entry_single_logout.appendChild(sp_dom.createTextNode("true"))
sp_entry_attribute_profile = sp_dom.createElement(
"EnableAttributeProfile")
sp_entry_attribute_profile.appendChild(sp_dom.createTextNode("true"))
sp_entry.appendChild(sp_entry_issuer)
sp_entry.appendChild(sp_entry_acs)
sp_entry.appendChild(sp_entry_sign_resp)
sp_entry.appendChild(sp_entry_sign_assert)
sp_entry.appendChild(sp_entry_single_logout)
sp_entry.appendChild(sp_entry_attribute_profile)
sps_element.appendChild(sp_entry)
with open(sso_idp_file, 'w+') as f:
root_element.writexml(f, newl="\n")
# root_element.writexml(f)
# data = json.loads(urllib.urlopen("http://ip.jsontest.com/").read())
# ip_entry = data["ip"]
# publish SAML_ENDPOINT to metadata service
# member_hostname = socket.gethostname()
member_hostname = values["HOST_NAME"]
payload_ports = values["PORT_MAPPINGS"].split("|")
if values.get("LB_CLUSTER_ID") is not None:
port_no = payload_ports[2].split(":")[1]
else:
port_no = payload_ports[1].split(":")[1]
saml_endpoint = "https://%s:%s/samlsso" % (member_hostname, port_no)
publish_data = mdsclient.MDSPutRequest()
hostname_entry = {"key": "SAML_ENDPOINT", "values": saml_endpoint}
properties_data = [hostname_entry]
publish_data.properties = properties_data
mdsclient.put(publish_data, app=True)
# start servers
log.info("Starting WSO2 IS server")
# set configurations
carbon_replace_command = "sed -i \"s/CLUSTER_HOST_NAME/%s/g\" %s" % (
member_hostname, "${CARBON_HOME}/repository/conf/carbon.xml")
p = subprocess.Popen(carbon_replace_command, shell=True)
output, errors = p.communicate()
log.debug("Set carbon.xml hostname")
catalina_replace_command = "sed -i \"s/STRATOS_IS_PROXY_PORT/%s/g\" %s" % (
port_no,
"${CARBON_HOME}/repository/conf/tomcat/catalina-server.xml")
p = subprocess.Popen(catalina_replace_command, shell=True)
output, errors = p.communicate()
log.debug("Set catalina-server.xml proxy port")
wso2is_start_command = "exec ${CARBON_HOME}/bin/wso2server.sh start"
env_var = os.environ.copy()
p = subprocess.Popen(wso2is_start_command, env=env_var, shell=True)
output, errors = p.communicate()
log.debug("WSO2 IS server started")