def create_blazar_client(config, session):
"""Check the reservation, creates a new one if nescessary."""
return blazar_client.Client(
session=session,
service_type="reservation",
region_name=os.environ["OS_REGION_NAME"],
)
def blazarclient(request):
try:
api_url = base.url_for(request, 'reservation')
except exceptions.ServiceCatalogException:
LOG.debug('No Reservation service is configured.')
return None
LOG.debug('blazarclient connection created using the token "%s" and url'
'"%s"' % (request.user.token.id, api_url))
return blazar_client.Client(blazar_url=api_url,
auth_token=request.user.token.id)
def _create(self, version=None):
interface = self._get_client_option(CLIENT_NAME, 'endpoint_type')
args = {
'session': self.context.keystone_session,
'service_type': self.RESERVATION,
'interface': interface,
'region_name': self._get_region_name(),
}
client = blazar_client.Client(**args)
return client
def get_lease_info(sess, user_id, project_id):
lease_list = []
blazar = blazar_client.Client("1",
service_type="reservation",
interface="publicURL",
session=sess)
ironic = ironic_client.Client("1", session=sess)
leases = blazar.lease.list()
for lease in leases:
if lease.get("user_id") != user_id or lease.get(
"project_id") != project_id:
continue
# Ignore if more than 3 days out of date
end_date = parser.parse(lease.get("end_date"))
date_diff = datetime.utcnow() - end_date
if date_diff.days > 3:
continue
lease_dict = {}
lease_dict["name"] = lease.get("name")
lease_dict["status"] = lease.get("status")
lease_dict["start_date"] = str(parser.parse(lease.get("start_date")))
lease_dict["end_date"] = str(end_date)
lease_dict["id"] = lease.get("id")
lease_dict["hosts"] = []
resource_map = {r["id"]: r for r in blazar.host.list()}
for blazar_host in blazar.host.list_allocations():
if any(res["lease_id"] == lease_dict["id"]
for res in blazar_host["reservations"]):
resource_host = resource_map[blazar_host["resource_id"]]
host = {
"node_name": resource_host["node_name"],
"uid": resource_host["uid"],
"node_type": resource_host["node_type"],
}
node = ironic.node.get(resource_host["uid"])
host["provision_state"] = node.provision_state
host["instance_uuid"] = node.instance_uuid
host["last_error"] = node.last_error
lease_dict["hosts"].append(host)
lease_dict["networks"] = []
resource_map = {r["id"]: r for r in blazar.network.list()}
for network in blazar.network.list_allocations():
if any(res["lease_id"] == lease_dict["id"]
for res in network["reservations"]):
lease_dict["networks"].append(
resource_map[network["resource_id"]])
lease_list.append(lease_dict)
return lease_list
def blazarclient(cls):
data = cls.get_credentials()
domain_name = data.pop('domain_name')
data['user_domain_name'] = domain_name
data['project_domain_name'] = domain_name
auth_ses = clients.OpenstackClients(auth_attr=data).keystone_session
args = {
'session': auth_ses,
'service_type': 'reservation',
'interface': 'public',
'region_name': 'RegionOne',
}
client = blazar_client.Client(**args)
return client
def authenticate_user(self):
"""Authenticate user and set client by using passed params."""
auth = loading.load_auth_from_argparse_arguments(self.options)
sess = loading.load_session_from_argparse_arguments(
self.options, auth=auth)
self.client = blazar_client.Client(
self.options.os_reservation_api_version,
session=sess,
service_type=(self.options.service_type or
self.options.os_service_type),
interface=self.options.endpoint_type or self.options.os_interface,
region_name=self.options.os_region_name,
)
return
def get_lease_info(psess):
lease_list = []
blazar = blazar_client.Client('1',
service_type='reservation',
interface='publicURL',
session=psess)
leases = blazar.lease.list()
for lease in leases:
lease_dict = {}
lease_dict['name'] = lease.get('name')
lease_dict['status'] = lease.get('status')
lease_dict['start_date'] = str(parser.parse(lease.get('start_date')))
lease_dict['end_date'] = str(parser.parse(lease.get('end_date')))
lease_dict['id'] = lease.get('id')
lease_list.append(lease_dict)
return lease_list
def reserve(sess, node, start_time, requested_hours, reason, operator, dryrun):
end_time = start_time + datetime.timedelta(hours=requested_hours)
start_time_str_in_ct = start_time.replace(
tzinfo=tz.gettz('UTC')).astimezone(
tz.gettz('America/Chicago')).strftime(DATETIME_STR_FORMAT)
end_time_str_in_ct = end_time.replace(tzinfo=tz.gettz('UTC')).astimezone(
tz.gettz('America/Chicago')).strftime(DATETIME_STR_FORMAT)
print((
("Creating maintenance reservation for node {node_name} "
"(id: {node_uuid}), starting {start} and ending {end} in central time"
).format(node_name=node.name,
node_uuid=node.uuid,
start=start_time_str_in_ct,
end=end_time_str_in_ct)))
if not dryrun:
blazar = blazar_client.Client(1,
session=sess,
service_type='reservation')
resource_properties = '["=", "$uid", "{node_uuid}"]'.format(
node_uuid=node.uuid)
phys_res = {
'min': "1",
'max': "1",
'hypervisor_properties': "",
'resource_properties': resource_properties,
'resource_type': 'physical:host'
}
lease_name = MAINT_LEASE_NAME.format(
node_name=node.name.replace(' ', '_'),
operator=operator.replace(' ', '_'),
reason=reason.replace(' ', '_'))
lease = blazar.lease.create(
name=lease_name,
start=start_time.strftime('%Y-%m-%d %H:%M'),
end=end_time.strftime('%Y-%m-%d %H:%M'),
reservations=[phys_res],
events=[])
print(("Lease {name} (id: {id}) created successfully!".format(
name=lease['name'], id=lease['id'])))
return start_time_str_in_ct, end_time_str_in_ct
def create_blazar_client(config):
"""Check the reservation, creates a new one if nescessary."""
kclient = keystone.Client(auth_url=os.environ["OS_AUTH_URL"],
username=os.environ["OS_USERNAME"],
password=os.environ["OS_PASSWORD"],
tenant_id=os.environ["OS_TENANT_ID"])
auth = kclient.authenticate()
if auth:
blazar_url = kclient.service_catalog.url_for(
service_type='reservation')
else:
raise Exception("User *%s* is not authorized." %
os.environ["OS_USERNAME"])
# let the version by default
return blazar_client.Client(blazar_url=blazar_url,
auth_token=kclient.auth_token)
def authenticate_user(self):
"""Authenticate user and set client by using passed params."""
if self.options.os_token:
auth = identity.Token(
auth_url=self.options.os_auth_url,
token=self.options.os_token,
tenant_id=self.options.os_tenant_id,
tenant_name=self.options.os_tenant_name,
project_id=self.options.os_project_id,
project_name=self.options.os_project_name,
project_domain_id=self.options.os_project_domain_id,
project_domain_name=self.options.os_project_domain_name
)
else:
auth = identity.Password(
auth_url=self.options.os_auth_url,
username=self.options.os_username,
tenant_id=self.options.os_tenant_id,
tenant_name=self.options.os_tenant_name,
password=self.options.os_password,
project_id=self.options.os_project_id,
project_name=self.options.os_project_name,
project_domain_id=self.options.os_project_domain_id,
project_domain_name=self.options.os_project_domain_name,
user_domain_id=self.options.os_user_domain_id,
user_domain_name=self.options.os_user_domain_name
)
sess = session.Session(
auth=auth,
verify=(self.options.os_cacert or not self.options.insecure)
)
self.client = blazar_client.Client(
self.options.os_reservation_api_version,
session=sess,
service_type=self.options.service_type,
interface=self.options.endpoint_type,
region_name=self.options.os_region_name,
)
return
