x/packstack
Code Issues Proposed changes

Adding Initial openstack plugins

Browse Source 
This is a first working version of the installer, there is a lot
more to be added, for example a lot more can be paramatarized
This commit is contained in:
Derek Higgins
2012-08-02 16:52:15 +01:00
parent 853e71bab1
commit bd9d2e8388
27 changed files with 1404 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
plugins/glance_200.py Normal file
View File

@@ -0,0 +1,75 @@
"""
Installs and configures Glance
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-Glance"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/glance.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Glance configuration")
paramsList = [
{"CMD_OPTION" : "glance-host",
"USAGE" : "Hostname of the Glance server",
"PROMPT" : "Hostname of the Glance server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_GLANCE_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "GLANCE",
"DESCRIPTION" : "Glance Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
glancesteps = [
{'title': 'Creating Galnce Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Glance", [], [], glancesteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_glance.pp"%controller.CONF['CONFIG_GLANCE_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

99
plugins/keystone_100.py Normal file
View File

@@ -0,0 +1,99 @@
"""
Installs and configures Keystone
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-Keystone"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/keystone.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Keystone configuration")
paramsList = [
{"CMD_OPTION" : "keystone-host",
"USAGE" : "Hostname of the Keystone server",
"PROMPT" : "Hostname of the Keystone server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_KEYSTONE_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
{"CMD_OPTION" : "keystone-admin-token",
"USAGE" : "Keystone Admin Token",
"PROMPT" : "Keystone Admin Token",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validateStringNotEmpty,
"DEFAULT_VALUE" : uuid.uuid4().hex,
"MASK_INPUT" : True,
"LOOSE_VALIDATION": False,
"CONF_NAME" : "CONFIG_KEYSTONE_ADMINTOKEN",
"USE_DEFAULT" : True,
"NEED_CONFIRM" : False,
"CONDITION" : False },
{"CMD_OPTION" : "keystone-admin-passwd",
"USAGE" : "Keystone Admin Password",
"PROMPT" : "Keystone Admin Password",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validateStringNotEmpty,
"DEFAULT_VALUE" : uuid.uuid4().hex[:6],
"MASK_INPUT" : True,
"LOOSE_VALIDATION": False,
"CONF_NAME" : "CONFIG_KEYSTONE_ADMINPASSWD",
"USE_DEFAULT" : True,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "KEYSTONE",
"DESCRIPTION" : "Keystone Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
keystonesteps = [
{'title': 'Creating Keystone Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Keystone", [], [], keystonesteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_keystone.pp"%controller.CONF['CONFIG_KEYSTONE_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

98
plugins/mysql_001.py Normal file
View File

@@ -0,0 +1,98 @@
"""
Installs and configures MySQL
"""
import logging
import os
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-MySQL"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/mysql.pp'
PUPPET_MANIFEST_DIR = 'puppet/manifests'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding MySQL Openstack configuration")
paramsList = [
{"CMD_OPTION" : "mysql-host",
"USAGE" : "Hostname of the MySQL server",
"PROMPT" : "Hostname of the MySQL server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_MYSQL_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
{"CMD_OPTION" : "mysql-user",
"USAGE" : "Username of the MySQL admin user",
"PROMPT" : "Username of the MySQL admin user",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validateStringNotEmpty,
"DEFAULT_VALUE" : "root",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": False,
"CONF_NAME" : "CONFIG_MYSQL_USER",
"USE_DEFAULT" : True,
"NEED_CONFIRM" : False,
"CONDITION" : False },
{"CMD_OPTION" : "mysql-pw",
"USAGE" : "Password for the MySQL admin user",
"PROMPT" : "Password for the MySQL admin user",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : lambda a,b: True,
"DEFAULT_VALUE" : "",
"MASK_INPUT" : True,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_MYSQL_PW",
"USE_DEFAULT" : True,
"NEED_CONFIRM" : True,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "MYSQL",
"DESCRIPTION" : "MySQL Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
mysqlsteps = [
{'title': 'Create MySQL Manifest',
'functions':[createmanifest]}
]
controller.addSequence("Installing MySQL", [], [], mysqlsteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_mysql.pp"%controller.CONF['CONFIG_MYSQL_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

75
plugins/nova_api_310.py Normal file
View File

@@ -0,0 +1,75 @@
"""
Installs and configures nova api
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-NOVAAPI"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/nova_api.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Nova API configuration")
paramsList = [
{"CMD_OPTION" : "novaapi-host",
"USAGE" : "Hostname of the Nova API server",
"PROMPT" : "Hostname of the Nova API server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_NOVAAPI_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "NOVAAPI",
"DESCRIPTION" : "NOVAAPI Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
novaapisteps = [
{'title': 'Creating Nova API Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Nova API", [], [], novaapisteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_api_nova.pp"%controller.CONF['CONFIG_NOVAAPI_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

75
plugins/nova_cert_320.py Normal file
View File

@@ -0,0 +1,75 @@
"""
Installs and configures nova cert
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-NOVACERT"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/nova_cert.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Nova CERT configuration")
paramsList = [
{"CMD_OPTION" : "novacert-host",
"USAGE" : "Hostname of the Nova CERT server",
"PROMPT" : "Hostname of the Nova CERT server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_NOVACERT_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "NOVACERT",
"DESCRIPTION" : "NOVACERT Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
novacertsteps = [
{'title': 'Creating Nova CERT Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Nova CERT", [], [], novacertsteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_nova.pp"%controller.CONF['CONFIG_NOVACERT_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

63
plugins/nova_common_390.py Normal file
View File

@@ -0,0 +1,63 @@
"""
Installs and configures nova common
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-NOVACOMMON"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/nova_common.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Nova Common configuration")
paramsList = [
]
groupDict = { "GROUP_NAME" : "NOVACOMMON",
"DESCRIPTION" : "NOVACOMMON Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
novacommonsteps = [
{'title': 'Creating Nova Common Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Nova Common", [], [], novacommonsteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
for manifestfile in controller.CONF['CONFIG_MANIFESTFILES']:
if manifestfile.endswith("_nova.pp"):
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

89
plugins/nova_compute_330.py Normal file
View File

@@ -0,0 +1,89 @@
"""
Installs and configures nova compute
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-NOVACOMPUTE"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/nova_compute.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Nova Compute configuration")
paramsList = [
{"CMD_OPTION" : "novacompute-hosts",
"USAGE" : "Hostname of the Nova Compute servers (commma seperated)",
"PROMPT" : "Hostname of the Nova Compute server (commma seperated)",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validateMultiPing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_NOVACOMPUTE_HOSTS",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
{"CMD_OPTION" : "libvirt-type",
"USAGE" : "Libvirt Type to use",
"PROMPT" : "Libvirt Type to use",
"OPTION_LIST" : ["qemu", "kvm"],
"VALIDATION_FUNC" : validate.validateOptions,
"DEFAULT_VALUE" : "kvm",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": False,
"CONF_NAME" : "CONFIG_LIBVIRT_TYPE",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "NOVACOMPUTE",
"DESCRIPTION" : "Nova Compute Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
novacomputesteps = [
{'title': 'Creating Nova Compute Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Nova Compute", [], [], novacomputesteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
for host in controller.CONF["CONFIG_NOVACOMPUTE_HOSTS"].split(","):
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_nova.pp"%host.strip())
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

75
plugins/nova_network_340.py Normal file
View File

@@ -0,0 +1,75 @@
"""
Installs and configures nova network
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-NOVANETWORK"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/nova_network.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Nova NETWORK configuration")
paramsList = [
{"CMD_OPTION" : "novanetwork-host",
"USAGE" : "Hostname of the Nova Network server",
"PROMPT" : "Hostname of the Nova Network server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_NOVANETWORK_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "NOVANETWORK",
"DESCRIPTION" : "Nova Network Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
novanetworksteps = [
{'title': 'Creating Nova Network Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Nova Network", [], [], novanetworksteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_nova.pp"%controller.CONF['CONFIG_NOVANETWORK_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

75
plugins/nova_sched_350.py Normal file
View File

@@ -0,0 +1,75 @@
"""
Installs and configures nova sched
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-NOVASCHED"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/nova_sched.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Nova Sched configuration")
paramsList = [
{"CMD_OPTION" : "novasched-host",
"USAGE" : "Hostname of the Nova Sched server",
"PROMPT" : "Hostname of the Nova Sched server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_NOVASCHED_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "NOVASCHED",
"DESCRIPTION" : "NOVASCHED Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
novaschedsteps = [
{'title': 'Creating Nova Sched Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Nova Sched", [], [], novaschedsteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_nova.pp"%controller.CONF['CONFIG_NOVASCHED_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

75
plugins/nova_volume_360.py Normal file
View File

@@ -0,0 +1,75 @@
"""
Installs and configures nova volume
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-NOVAVOLUME"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/nova_volume.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Nova VOLUME configuration")
paramsList = [
{"CMD_OPTION" : "novavolume-host",
"USAGE" : "Hostname of the Nova Volume server",
"PROMPT" : "Hostname of the Nova Volume server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_NOVAVOLUME_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "NOVAVOLUME",
"DESCRIPTION" : "NOVAVOLUME Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
novavolumesteps = [
{'title': 'Creating Nova Volume Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing Nova Volume", [], [], novavolumesteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_nova.pp"%controller.CONF['CONFIG_NOVAVOLUME_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

75
plugins/openstack_client_400.py Normal file
View File

@@ -0,0 +1,75 @@
"""
Installs and configures an openstack client
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-CLIENT"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/openstack_client.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack client configuration")
paramsList = [
{"CMD_OPTION" : "osclient-host",
"USAGE" : "Hostname of the OpenStack client",
"PROMPT" : "Hostname of the OpenStack client",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_OSCLIENT_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "NOVACLIENT",
"DESCRIPTION" : "NOVACLIENT Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
osclientsteps = [
{'title': 'Creating OS Client Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing OpenStack Client", [], [], osclientsteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_osclient.pp"%controller.CONF['CONFIG_OSCLIENT_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

124
plugins/puppet_950.py Normal file
View File

@@ -0,0 +1,124 @@
"""
Installs and configures puppet
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OSPUPPET"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPETDIR = "puppet"
MODULEDIR = os.path.join(PUPPETDIR, "modules")
MANIFESTDIR = os.path.join(PUPPETDIR, "manifests")
PUPPET_MODULES = [
('https://github.com/puppetlabs/puppetlabs-glance.git', 'glance'),
('https://github.com/puppetlabs/puppetlabs-horizon.git', 'horizon'),
('https://github.com/puppetlabs/puppetlabs-keystone.git', 'keystone'),
('https://github.com/puppetlabs/puppetlabs-nova.git', 'nova'),
('https://github.com/puppetlabs/puppetlabs-openstack.git', 'openstack'),
('https://github.com/puppetlabs/puppetlabs-stdlib.git', 'stdlib'),
('https://github.com/puppetlabs/puppetlabs-sysctl.git', 'sysctl'),
('https://github.com/puppetlabs/puppetlabs-mysql.git', 'mysql'),
('https://github.com/puppetlabs/puppetlabs-concat.git', 'concat'),
('https://github.com/puppetlabs/puppetlabs-create_resources.git', 'create_resources'),
('https://github.com/puppetlabs/puppetlabs-firewall.git', 'firewall'),
('https://github.com/saz/puppet-memcached.git', 'memcached'),
('https://github.com/derekhiggins/puppet-qpid.git', 'qpid'),
('https://github.com/derekhiggins/puppet-vlan.git', 'vlan')
]
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack Puppet configuration")
paramsList = [
{"CMD_OPTION" : "remove-puppetmodules",
"USAGE" : "Causes the Puppet modules to be removed (if present), and as a result re-cloned from git",
"PROMPT" : "Should we remove the Puppet modules",
"OPTION_LIST" : ["yes", "no"],
"VALIDATION_FUNC" : validate.validateOptions,
"DEFAULT_VALUE" : "no",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_PUPPET_REMOVEMODULES",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "PUPPET",
"DESCRIPTION" : "Puppet Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
puppetpresteps = [
{'title': 'Clean Up', 'functions':[runCleanup]},
]
controller.insertSequenceBeforeSequence("Initial Steps", "Clean Up", [], [], puppetpresteps)
puppetsteps = [
{'title': 'Getting Puppet modules', 'functions':[getPuppetModules]},
{'title': 'Installing Puppet', 'functions':[installpuppet]},
{'title': 'Copying Puppet modules/manifests', 'functions':[copyPuppetModules]},
{'title': 'Applying Puppet manifests', 'functions':[applyPuppetManifest]},
]
controller.addSequence("Puppet", [], [], puppetsteps)
controller.CONF.setdefault('CONFIG_MANIFESTFILES', [])
def runCleanup():
localserver = utils.ScriptRunner()
localserver.append("rm -rf %s/*pp"%MANIFESTDIR)
if controller.CONF["CONFIG_PUPPET_REMOVEMODULES"] == 'yes':
localserver.append("rm -rf %s"%MODULEDIR)
localserver.execute()
def getPuppetModules():
localserver = utils.ScriptRunner()
localserver.append('mkdir -p %s'%MODULEDIR)
for repository, directory in PUPPET_MODULES:
directory = os.path.join(MODULEDIR, directory)
localserver.append('[ -d %s ] || git clone %s %s'%(directory, repository, directory))
localserver.execute()
def installpuppet():
for hostname in utils.gethostlist(controller.CONF):
server = utils.ScriptRunner(hostname)
server.append("rpm -q puppet || yum install -y puppet")
server.execute()
def copyPuppetModules():
server = utils.ScriptRunner()
for hostname in utils.gethostlist(controller.CONF):
server.append("tar -czf - puppet/manifests puppet/modules | ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null root@%s tar -C /etc -xzf -"%(hostname))
server.execute()
def applyPuppetManifest():
print
for manifest in controller.CONF['CONFIG_MANIFESTFILES']:
for hostname in utils.gethostlist(controller.CONF):
if "/%s_"%hostname not in manifest: continue
print "Applying "+ manifest
server = utils.ScriptRunner(hostname)
server.append("puppet apply /etc/puppet/manifests/%s"%os.path.split(manifest)[1])
server.execute()

75
plugins/qpid_002.py Normal file
View File

@@ -0,0 +1,75 @@
"""
Installs and configures qpid
"""
import logging
import os
import uuid
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-QPID"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
PUPPET_MANIFEST_DIR = 'puppet/manifests'
PUPPET_MANIFEST_TEMPLATE = 'puppet/templates/qpid.pp'
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding Openstack QPID configuration")
paramsList = [
{"CMD_OPTION" : "qpid-host",
"USAGE" : "Hostname of the QPID server",
"PROMPT" : "Hostname of the QPID server",
"OPTION_LIST" : [],
"VALIDATION_FUNC" : validate.validatePing,
"DEFAULT_VALUE" : "localhost",
"MASK_INPUT" : False,
"LOOSE_VALIDATION": True,
"CONF_NAME" : "CONFIG_QPID_HOST",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "QPIDLANCE",
"DESCRIPTION" : "QPID Config paramaters",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
qpidsteps = [
{'title': 'Creating QPID Manifest', 'functions':[createmanifest]}
]
controller.addSequence("Installing QPID", [], [], qpidsteps)
def createmanifest():
with open(PUPPET_MANIFEST_TEMPLATE) as fp:
manifestdata = fp.read()
manifestdata = manifestdata%controller.CONF
if not os.path.exists(PUPPET_MANIFEST_DIR):
os.mkdir(PUPPET_MANIFEST_DIR)
manifestfile = os.path.join(PUPPET_MANIFEST_DIR, "%s_qpid.pp"%controller.CONF['CONFIG_QPID_HOST'])
if manifestfile not in controller.CONF['CONFIG_MANIFESTFILES']:
controller.CONF['CONFIG_MANIFESTFILES'].append(manifestfile)
with open(manifestfile, 'a') as fp:
fp.write("\n")
fp.write(manifestdata)

59
plugins/serverprep_901.py Normal file
View File

@@ -0,0 +1,59 @@
"""
prepare server
"""
import glob
import logging
import os
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-SERVERPREPARE"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding SERVERPREPARE KEY configuration")
conf_params = {"SERVERPREPARE": [
]
}
conf_groups = [
{ "GROUP_NAME" : "SERVERPREPARE",
"DESCRIPTION" : "Server Prepare Configs ",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True},
]
for group in conf_groups:
paramList = conf_params[group["GROUP_NAME"]]
controller.addGroup(group, paramList)
def initSequences(controller):
preparesteps = [
{'title': 'Installing EPEL', 'functions':[installepel]}
]
controller.addSequence("Prepare Server", [], [], preparesteps)
def installepel():
for hostname in utils.gethostlist(controller.CONF):
server = utils.ScriptRunner(hostname)
server.append("rpm -q epel-release-6-7 || rpm -Uvh http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-7.noarch.rpm")
server.append("setenforce 0")
server.execute()

70
plugins/sshkeys_900.py Normal file
View File

@@ -0,0 +1,70 @@
"""
Installs and configures ssh keys
"""
import glob
import logging
import os
import engine_validators as validate
import basedefs
import common_utils as utils
# Controller object will be initialized from main flow
controller = None
# Plugin name
PLUGIN_NAME = "OS-SSHKEYS"
PLUGIN_NAME_COLORED = utils.getColoredText(PLUGIN_NAME, basedefs.BLUE)
logging.debug("plugin %s loaded", __name__)
def initConfig(controllerObject):
global controller
controller = controllerObject
logging.debug("Adding SSH KEY configuration")
paramsList = [
{"CMD_OPTION" : "ssh-public-key",
"USAGE" : "Public key to install on servers",
"PROMPT" : "Public key to install on servers",
"OPTION_LIST" : glob.glob(os.path.join(os.environ["HOME"], ".ssh/*.pub")),
"VALIDATION_FUNC" : validate.validateFile,
"DEFAULT_VALUE" : (glob.glob(os.path.join(os.environ["HOME"], ".ssh/*.pub"))+[""])[0],
"MASK_INPUT" : False,
"LOOSE_VALIDATION": False,
"CONF_NAME" : "CONFIG_SSH_KEY",
"USE_DEFAULT" : False,
"NEED_CONFIRM" : False,
"CONDITION" : False },
]
groupDict = { "GROUP_NAME" : "SSHKEY",
"DESCRIPTION" : "SSH Configs ",
"PRE_CONDITION" : utils.returnYes,
"PRE_CONDITION_MATCH" : "yes",
"POST_CONDITION" : False,
"POST_CONDITION_MATCH" : True}
controller.addGroup(groupDict, paramsList)
def initSequences(controller):
puppetsteps = [
{'title': 'Setting Up ssh keys',
'functions':[installKeys]}
]
controller.addSequence("ssh key setup", [], [], puppetsteps)
def installKeys():
with open(controller.CONF["CONFIG_SSH_KEY"]) as fp:
sshkeydata = fp.read().strip()
for hostname in utils.gethostlist(controller.CONF):
server = utils.ScriptRunner(hostname)
server.append("mkdir -p ~/.ssh")
server.append("grep '%s' ~/.ssh/authorized_keys > /dev/null 2>&1 || echo %s > ~/.ssh/authorized_keys"%(sshkeydata, sshkeydata))
server.append("restorecon -r ~/.ssh")
server.execute()

25
puppet/templates/glance.pp Normal file
View File

@@ -0,0 +1,25 @@
class {"glance::api":
auth_host => "%(CONFIG_KEYSTONE_HOST)s",
keystone_tenant => "services",
keystone_user => "glance",
keystone_password => "glance_password",
}
class { 'glance::backend::file': }
class {"glance::registry":
auth_host => "%(CONFIG_KEYSTONE_HOST)s",
keystone_tenant => "services",
keystone_user => "glance",
keystone_password => "glance_password",
sql_connection => "mysql://glance:glance_default_password@%(CONFIG_MYSQL_HOST)s/glance"
}
firewall { '001 glance incomming':
proto => 'tcp',
dport => ['9292'],
action => 'accept',
}

45
puppet/templates/keystone.pp Normal file
View File

@@ -0,0 +1,45 @@
class {"keystone":
admin_token => "%(CONFIG_KEYSTONE_ADMINTOKEN)s"
}
class {"keystone::config::mysql":
host => "%(CONFIG_MYSQL_HOST)s"
}
class {"keystone::roles::admin":
email => "test@test.com",
password => "%(CONFIG_KEYSTONE_ADMINPASSWD)s",
admin_tenant => "admin"
}
class {"openstack::auth_file":
admin_password => "%(CONFIG_KEYSTONE_ADMINPASSWD)s",
admin_tenant => "admin",
keystone_admin_token => $ksadmintoken
}
class {"keystone::endpoint":
public_address => "%(CONFIG_KEYSTONE_HOST)s",
admin_address => "%(CONFIG_KEYSTONE_HOST)s",
internal_address => "%(CONFIG_KEYSTONE_HOST)s",
}
class {"glance::keystone::auth":
public_address => "%(CONFIG_GLANCE_HOST)s",
admin_address => "%(CONFIG_GLANCE_HOST)s",
internal_address => "%(CONFIG_GLANCE_HOST)s",
}
class {"nova::keystone::auth":
public_address => "%(CONFIG_NOVAAPI_HOST)s",
admin_address => "%(CONFIG_NOVAAPI_HOST)s",
internal_address => "%(CONFIG_NOVAAPI_HOST)s",
}
firewall { '001 keystone incomming':
proto => 'tcp',
dport => ['5000', '35357'],
action => 'accept',
}

24
puppet/templates/mysql.pp Normal file
View File

@@ -0,0 +1,24 @@
class {"mysql::server":
config_hash => {bind_address => "0.0.0.0"}
}
class {"keystone::db::mysql":
allowed_hosts => "%%",
}
class {"glance::db::mysql":
allowed_hosts => "%%",
password => "glance_default_password",
}
class {"nova::db::mysql":
allowed_hosts => "%%",
password => "nova_password",
}
firewall { '001 mysql incomming':
proto => 'tcp',
dport => ['3306'],
action => 'accept',
}

19
puppet/templates/nova_api.pp Normal file
View File

@@ -0,0 +1,19 @@
require 'keystone::python'
class {"nova::api":
enabled => true,
auth_host => "%(CONFIG_KEYSTONE_HOST)s",
admin_password => "nova_password",
}
# the notify in the nova:api class doesn't work, so need to set these ones
# TODO : figure this out
Package<| title == 'nova-common' |> ~> Exec['initial-db-sync']
Package<| title == 'nova-common' |> ~> File['/etc/nova/api-paste.ini']
firewall { '001 novaapi incomming':
proto => 'tcp',
dport => ['8773', '8774', '8776'],
action => 'accept',
}

4
puppet/templates/nova_cert.pp Normal file
View File

@@ -0,0 +1,4 @@
class {"nova::cert":
enabled => true,
}

10
puppet/templates/nova_common.pp Normal file
View File

@@ -0,0 +1,10 @@
nova_config{
"metadata_host": value => "%(CONFIG_NOVAAPI_HOST)s";
"qpid_hostname": value => "%(CONFIG_QPID_HOST)s";
"rpc_backend": value => "nova.rpc.impl_qpid";
}
class {"nova":
glance_api_servers => "%(CONFIG_GLANCE_HOST)s:9292",
sql_connection => "mysql://nova:nova_password@%(CONFIG_MYSQL_HOST)s/nova",
}

26
puppet/templates/nova_compute.pp Normal file
View File

@@ -0,0 +1,26 @@
nova_config{
#"flat_interface": value => "eth0";
"network_host": value => "%(CONFIG_NOVANETWORK_HOST)s";
"libvirt_inject_partition": value => "-1";
}
class {"nova::compute":
enabled => true,
}
class { 'nova::compute::libvirt':
libvirt_type => "%(CONFIG_LIBVIRT_TYPE)s",
}
if "%(CONFIG_LIBVIRT_TYPE)s" == "qemu" {
file { "/usr/bin/qemu-system-x86_64":
ensure => link,
target => "/usr/libexec/qemu-kvm",
}
}
class {"vlan":
interface => "em1",
vlan => "16"
}

9
puppet/templates/nova_network.pp Normal file
View File

@@ -0,0 +1,9 @@
class {"nova::network":
enabled => true,
private_interface => 'eth0',
public_interface => 'eth0',
fixed_range => '192.168.11.0/24',
floating_range => '192.168.13.0/24'
}

3
puppet/templates/nova_sched.pp Normal file
View File

@@ -0,0 +1,3 @@
class {"nova::scheduler":
enabled => true,
}

12
puppet/templates/nova_volume.pp Normal file
View File

@@ -0,0 +1,12 @@
class {"nova::volume":
enabled => true,
}
class {"nova::volume::iscsi":}
firewall { '001 volume incomming':
proto => 'tcp',
dport => ['3260'],
action => 'accept',
}

14
puppet/templates/openstack_client.pp Normal file
View File

@@ -0,0 +1,14 @@
package {"clientlibs":
name => ["python-novaclient", "python-keystoneclient", "openstack-glance"]
}
file {"/root/keystonerc_admin":
ensure => "present",
content => "export OS_USERNAME=admin
export OS_TENANT_NAME=admin
export OS_PASSWORD=%(CONFIG_KEYSTONE_ADMINPASSWD)s
export OS_AUTH_URL=http://%(CONFIG_KEYSTONE_HOST)s:35357/v2.0/
export PS1=\"[\\u@\\h \\W(keystone_admin)]\$ \"
"
}

11
puppet/templates/qpid.pp Normal file
View File

@@ -0,0 +1,11 @@
class {"qpid::server":
auth => "no"
}
firewall { '001 qpid incomming':
proto => 'tcp',
dport => ['5672'],
action => 'accept',
}