Skip to content

Issue#95 add update domain capability #104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 5 commits into from
May 22, 2018
Merged

Issue#95 add update domain capability #104

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
94b499f
Issue#95 - Provide update of topology and resources
rakillen May 17, 2018
b9c9557
Issue#95 - Provide update of security provider elements
rakillen May 18, 2018
d958add
Issue#95 - Provide update of domain and classpath libraries
rakillen May 21, 2018
4dfd776
Issue#95 - Provide update of server group targeting
rakillen May 22, 2018
1254a44
Merge branch 'master' into issue#95-add-update-domain-capability
rakillen May 22, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
501 changes: 501 additions & 0 deletions core/src/main/python/update.py
View file
Open in desktop

Large diffs are not rendered by default.

156 changes: 7 additions & 149 deletions core/src/main/python/wlsdeploy/tool/create/creator.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,9 +2,7 @@
Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
The Universal Permissive License (UPL), Version 1.0
"""
import copy

from oracle.weblogic.deploy.util import PyOrderedDict as OrderedDict
from oracle.weblogic.deploy.util import WLSDeployArchive

from wlsdeploy.aliases.location_context import LocationContext
Expand All @@ -17,29 +15,26 @@
from wlsdeploy.tool.util.wlst_helper import WlstHelper
from wlsdeploy.util import dictionary_utils
from wlsdeploy.util.model import Model
from wlsdeploy.util import string_utils
from wlsdeploy.util.weblogic_helper import WebLogicHelper

from wlsdeploy.aliases.model_constants import CLUSTER
from wlsdeploy.aliases.model_constants import MODEL_LIST_DELIMITER
from wlsdeploy.aliases.model_constants import SERVER


class Creator(object):
"""
The base class used by the DomainCreator.
"""
__class_name = 'Creator'

def __init__(self, model, model_context, aliases):
self.logger = PlatformLogger('wlsdeploy.create')
def __init__(self, model, model_context, aliases, exception_type=ExceptionType.CREATE,
logger=PlatformLogger('wlsdeploy.create')):

self.logger = logger
self.aliases = aliases
self.alias_helper = AliasHelper(self.aliases, self.logger, ExceptionType.CREATE)
self.wlst_helper = WlstHelper(self.logger, ExceptionType.CREATE)
self.alias_helper = AliasHelper(self.aliases, self.logger, exception_type)
self.wlst_helper = WlstHelper(self.logger, exception_type)
self.model = Model(model)
self.model_context = model_context
self.wls_helper = WebLogicHelper(self.logger)
self.attribute_setter = AttributeSetter(self.aliases, self.logger, ExceptionType.CREATE)
self.attribute_setter = AttributeSetter(self.aliases, self.logger, exception_type)
# Must be initialized by the subclass since only it has
# the knowledge required to compute the domain name.
self.archive_helper = None
Expand Down Expand Up @@ -393,7 +388,6 @@ def _create_subfolders(self, location, model_nodes):
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
return


def _is_type_valid(self, location, type_name):
"""
Verify that the specified location in valid for the current WLS version.
Expand Down Expand Up @@ -451,139 +445,3 @@ def _format_model_path(self, location, name):
path += '/'
path += name
return path

def _get_existing_server_names(self):
"""
Get the list of server names from WLST.
:return: the list of server names
:raises: CreateException: is an error occurs reading from the aliases or WLST
"""
_method_name = '_get_existing_server_names'

self.logger.entering(class_name=self.__class_name, method_name=_method_name)
server_location = LocationContext().append_location(SERVER)
server_list_path = self.alias_helper.get_wlst_list_path(server_location)
result = self.wlst_helper.get_existing_object_list(server_list_path)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
return result

def _get_clusters_and_members_map(self):
"""
Get a map keyed by cluster name with values that are a list of member server names
:return: the cluster name to member server names map
:raises: CreateException: is an error occurs reading from the aliases or WLST
"""
_method_name = '_get_clusters_and_members_map'

self.logger.entering(class_name=self.__class_name, method_name=_method_name)
server_location = LocationContext().append_location(SERVER)
server_list_path = self.alias_helper.get_wlst_list_path(server_location)
server_names = self.wlst_helper.get_existing_object_list(server_list_path)
server_token = self.alias_helper.get_name_token(server_location)
cluster_map = OrderedDict()
for server_name in server_names:
server_location.add_name_token(server_token, server_name)
server_attributes_path = self.alias_helper.get_wlst_attributes_path(server_location)
self.wlst_helper.cd(server_attributes_path)

server_attributes_map = self.wlst_helper.lsa()
cluster_name = dictionary_utils.get_element(server_attributes_map, CLUSTER)
if string_utils.is_empty(cluster_name):
# if server is not part of a cluster, continue with the next server
continue

if cluster_name not in cluster_map:
cluster_map[cluster_name] = list()
cluster_map[cluster_name].append(server_name)

self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=cluster_map)
return cluster_map

def _get_server_group_targeting_limits(self, server_group_targeting_limits, clusters_map):
"""
Get any server group targeting limits specified in the model, converting any cluster
names to the list of members. This method assumes that the limits dictionary is not
None or empty.
:param server_group_targeting_limits: the raw server group targeting_limits from the model
:param clusters_map: the map of cluster names to member server names
:return: the map of server groups to server names to target
"""
_method_name = '_get_server_group_targeting_limits'

self.logger.entering(str(server_group_targeting_limits), str(clusters_map),
class_name=self.__class_name, method_name=_method_name)
sg_targeting_limits = copy.deepcopy(server_group_targeting_limits)
for server_group_name, sg_targeting_limit in sg_targeting_limits.iteritems():
if type(sg_targeting_limit) is str:
if MODEL_LIST_DELIMITER in sg_targeting_limit:
sg_targeting_limit = sg_targeting_limit.split(MODEL_LIST_DELIMITER)
else:
# convert a single value into a list of one...
new_list = list()
new_list.append(sg_targeting_limit)
sg_targeting_limit = new_list

# Convert any references to a cluster name into the list of member server names
new_list = list()
for target_name in sg_targeting_limit:
target_name = target_name.strip()
if target_name in clusters_map:
cluster_members = dictionary_utils.get_element(clusters_map, target_name)
new_list.extend(cluster_members)
else:
# Assume it is a server name and add it to the new list
new_list.append(target_name)
sg_targeting_limits[server_group_name] = new_list

self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=sg_targeting_limits)
return sg_targeting_limits

def _get_server_to_server_groups_map(self, admin_server_name, server_names, server_groups, sg_targeting_limits):
"""
Get the map of server names to the list of server groups to target to that server.
:param admin_server_name: the admin server name
:param server_names: the list of server names
:param server_groups: the complete list of server groups that will, by default, be targeted to
all managed servers unless the server is listed in the targeting limits map
:param sg_targeting_limits: the targeting limits map
:return: the map of server names to the list of server groups to target to that server
"""
_method_name = '_get_server_to_server_groups_map'

self.logger.entering(admin_server_name, str(server_names), str(server_groups), str(sg_targeting_limits),
class_name=self.__class_name, method_name=_method_name)
result = OrderedDict()
for server_name in server_names:
server_groups_for_server = self.__get_server_groups_for_server(server_name, sg_targeting_limits)
if server_groups_for_server is not None:
result[server_name] = server_groups_for_server
elif server_name != admin_server_name:
# By default, we only target managed servers unless explicitly listed in the targeting limits
result[server_name] = list(server_groups)
else:
result[admin_server_name] = list()
if admin_server_name not in result:
result[admin_server_name] = list()
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
return result

def __get_server_groups_for_server(self, server_name, sg_targeting_limits):
"""
Get the servers groups to target for a given server name.
:param server_name: the server name
:param sg_targeting_limits: the targeting limits
:return: the list of server groups to target to the specified server name, or None
if the server name does not appear in the targeting limits
"""
_method_name = '__get_server_groups_for_server'

self.logger.entering(server_name, str(sg_targeting_limits),
class_name=self.__class_name, method_name=_method_name)
result = None
for server_group, server_names_list in sg_targeting_limits.iteritems():
if server_name in server_names_list:
if result is None:
result = list()
result.append(server_group)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name, result=result)
return result
Loading