def terminateInstance(self, instanceid):
params = {'Action': 'TerminateInstances', 'InstanceId': instanceid}
try:
elem = self.connection.request(self.path, params=params).object
previousStates = []
for rs in findall(element=elem,
xpath='instancesSet/item',
namespace=NAMESPACE):
code = findtext(element=rs,
xpath='previousState/code',
namespace=NAMESPACE)
name = findtext(element=rs,
xpath='previousState/name',
namespace=NAMESPACE)
previousStates.append({"code": code, "name": name})
if len(previousStates) > 1:
#複数のインスタンスが削除された場合
raise IaasException("EPROCESS-000108", [
instanceid,
])
#実行ログ
self.logger.info(None, "IPROCESS-100117", [
instanceid,
])
return previousStates[0]
except Exception:
# インスタンス削除失敗時
raise IaasException("EPROCESS-000107", [
instanceid,
])
return None
def deleteDataDisk(self, cloudService, roleName, diskName, lun):
deploymentName = cloudService
# TODO: デタッチコンフリクト問題に暫定的に対応
for i in range(0, 6):
try:
asyncOperation = self.sms.delete_data_disk(service_name = cloudService, \
deployment_name = deploymentName, role_name = roleName, \
lun = lun)
except WindowsAzureMissingResourceError as e:
# クラウドサービス/デプロイメントが存在しない(_ERROR_NOT_FOUND)
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000911", [roleName, diskName])
except WindowsAzureConflictError as e:
# TODO: アタッチコンフリクト問題に暫定的に対応
if i == 5:
# 既に存在する
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000911",
[roleName, diskName])
else:
time.sleep(30)
continue
except Exception:
# 予期せぬ例外
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000911", [roleName, diskName])
else:
operationStatus = self.waitAsyncOperationFinished(
asyncOperation)
if operationStatus != 'Succeeded':
raise IaasException("EPROCESS-000911", [roleName, diskName])
return operationStatus
def describeVpcAddress(self, publicIp=None):
params = {'Action': 'DescribeAddresses'}
#任意パラメータ
if publicIp != None:
params.update({'PublicIp.0': publicIp})
elem = self.connection.request(self.path, params=params).object
address = []
for rs in findall(element=elem,
xpath='addressesSet/item',
namespace=NAMESPACE):
address.append(self._to_vpcaddress(rs))
if not address or len(address) == 0:
#アドレスが存在しない場合
raise IaasException("EPROCESS-000117", [
publicIp,
])
if len(address) > 1:
#アドレスを複数参照できた場合
raise IaasException("EPROCESS-000118", [
publicIp,
])
return address[0]
def createVirtualMachineDeployment(self, cloudService, instanceName, osConfig, osHardDisk, \
instanceType, networkConfig, networkName, availabilitySet):
deploymentName = cloudService
deploymentLabel = deploymentName
try:
asyncOperation = self.sms.create_virtual_machine_deployment( \
service_name=cloudService, deployment_name=deploymentName, \
deployment_slot='production', label=deploymentLabel, \
role_name=instanceName, system_config=osConfig, \
os_virtual_hard_disk=osHardDisk, role_size=instanceType, \
network_config=networkConfig, availability_set_name=availabilitySet, \
virtual_network_name=networkName)
except WindowsAzureConflictError as e:
# 既に存在する
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000903", [instanceName])
except Exception:
# 予期せぬ例外
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000903", [instanceName])
else:
operationStatus = self.waitAsyncOperationFinished(asyncOperation)
# 異常系テストコード
#operationStatus = 'Failed'
if operationStatus != 'Succeeded':
raise IaasException("EPROCESS-000903", [instanceName])
return self.waitVirtualMachineStatusReadyRole(cloudService,
instanceName)
def addRole(self, cloudService, instanceName, osConfig, osHardDisk, \
instanceType, networkConfig, networkName, availabilitySet):
# XXX: ネットワーク名が既存デプロイメントのネットワークと一致することを確認すべきか。
deploymentName = cloudService
try:
asyncOperation = self.sms.add_role( \
service_name=cloudService, deployment_name=deploymentName, \
role_name=instanceName, system_config=osConfig, \
os_virtual_hard_disk=osHardDisk, role_size=instanceType, \
network_config=networkConfig, availability_set_name=availabilitySet)
except WindowsAzureConflictError as e:
# 既に存在する
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000905", [instanceName])
except Exception:
# 予期せぬ例外
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000905", [instanceName])
else:
operationStatus = self.waitAsyncOperationFinished(asyncOperation)
# 異常系テストコード
#operationStatus = 'Failed'
if operationStatus != 'Succeeded':
raise IaasException("EPROCESS-000905", [instanceName])
return self.waitVirtualMachineStatusReadyRole(cloudService,
instanceName)
def createVolume(self,
name,
location=None,
size=None,
snapshotId=None,
diskid=None,
iscustomized=True):
args = {}
if snapshotId is None and diskid is None:
# ボリューム作成失敗時
raise IaasException("**********")
if snapshotId is not None:
args['snapshotid'] = snapshotId
if diskid is not None:
args['diskofferingid'] = diskid
if size is not None and iscustomized:
args['size'] = str(size)
if location is None:
location = self.describeAvailabilityZones()[0]["id"]
args['zoneid'] = location
result = self._async_request('createVolume', name=name, **args)
volume = None
if 'volume' in result:
volume = result['volume']
else:
raise IaasException("EPROCESS-000707", [])
return volume
def createAddDataDisk(self, cloudService, roleName, mediaLink, size, lun):
deploymentName = cloudService
# TODO: アタッチコンフリクト問題に暫定的に対応
for i in range(0, 6):
try:
asyncOperation = self.sms.add_data_disk(service_name = cloudService, \
deployment_name = deploymentName, role_name = roleName, \
lun = lun, host_caching = 'ReadOnly', media_link = mediaLink, \
disk_label = None, disk_name = None, logical_disk_size_in_gb = size, \
#disk_label = '%sL' % (diskName), disk_name = '%sN' % (diskName), logical_disk_size_in_gb = size, \
source_media_link = None)
except WindowsAzureMissingResourceError as e:
# クラウドサービス/デプロイメントが存在しない(_ERROR_NOT_FOUND)
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000915", [roleName])
except WindowsAzureConflictError as e:
# TODO: アタッチコンフリクト問題に暫定的に対応
if i == 5:
# 既に存在する
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000915", [roleName])
else:
time.sleep(30)
continue
except Exception:
# 予期せぬ例外
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000915", [roleName])
else:
operationStatus = self.waitAsyncOperationFinished(
asyncOperation)
if operationStatus != 'Succeeded':
raise IaasException("EPROCESS-000915", [roleName])
return operationStatus
def _deleteDisk(self, osHardDiskName):
self.logger.debug("Blob of OS Disk deleting...(%s)" % osHardDiskName)
try:
# 指定されたデータまたはオペレーティング システム ディスクをイメージ リポジトリから削除
# ディスクに関連付けられた BLOB も削除
asyncOperation = self.sms.delete_disk(osHardDiskName, True)
except WindowsAzureMissingResourceError as e:
# クラウドサービス/デプロイメントが存在しない(_ERROR_NOT_FOUND)
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000916", [osHardDiskName])
except WindowsAzureError as e:
# XXX: Blobがロックされている場合を想定しているが、他にもこのエラーにかかる可能性あり
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000916", [osHardDiskName])
except Exception:
# 予期せぬ例外
self.logger.error(traceback.format_exc())
raise IaasException("EPROCESS-000916", [osHardDiskName])
else:
operationStatus = self.waitAsyncOperationFinished(asyncOperation,
flg='del')
if operationStatus != 'Succeeded':
raise IaasException("EPROCESS-000916", [osHardDiskName])
self.logger.debug("Blob of OS Disk deleted.(%s)" % osHardDiskName)
return operationStatus
def stopInstance(self, instanceNo):
self.logger.info(' StopInstance: %s' % (instanceNo))
# インスタンスIDの取得
openstackInstanceTable = self.conn.getTable("OPENSTACK_INSTANCE")
openstackInstanceInfo = self.conn.selectOne(openstackInstanceTable.select\
(openstackInstanceTable.c.INSTANCE_NO==instanceNo))
openstackInstanceId = openstackInstanceInfo['INSTANCE_ID']
# インスタンス名の取得
instanceTable = self.conn.getTable("INSTANCE")
instanceInfo = self.conn.selectOne(instanceTable.select\
(instanceTable.c.INSTANCE_NO==instanceNo))
instanceName = instanceInfo['FQDN']
if isEmpty(openstackInstanceId):
# 一度もStartしたことがない
self.logger.info(' Nonexistent Instance: %s' % (instanceName))
raise IaasException("EPROCESS-001006", [instanceName])
# ステータスを確認する
try:
status = self.client.getVirtualMachineStatus(openstackInstanceId)
except:
raise IaasException("EPROCESS-001008", [instanceName])
if status == 'SHUTOFF':
# 既にインスタンスは起動しているため、statusを更新して終了する。
self.logger.info(' Instance: %s is already SHUTOFF' % (instanceName))
# データベース更新
table = self.conn.getTable("OPENSTACK_INSTANCE")
updateDict = self.conn.selectOne(table.select(table.c.INSTANCE_NO==instanceNo))
updateDict["STATUS"] = status
sql = table.update(table.c.INSTANCE_NO == updateDict["INSTANCE_NO"], values=updateDict)
self.conn.execute(sql)
return True
self.logger.info(' Stopping Instance: %s' % (instanceName))
try:
instanceObj = self.client.stopVirtualMachine(openstackInstanceId)
except:
raise IaasException("EPROCESS-001006", [instanceName])
status = instanceObj.status
if status != 'SHUTOFF':
raise IaasException("EPROCESS-001007", [instanceName, status])
self.logger.info(' StopInstance finished. Status: %s' % (status))
# データベース更新
table = self.conn.getTable("OPENSTACK_INSTANCE")
updateDict = self.conn.selectOne(table.select(table.c.INSTANCE_NO==instanceNo))
updateDict["STATUS"] = status
sql = table.update(table.c.INSTANCE_NO == updateDict["INSTANCE_NO"], values=updateDict)
self.conn.execute(sql)
return True
def describeSnapshot(self, snapshotId):
snapshots = self.describeSnapshots(snapshotId)
if not snapshots or len(snapshots) == 0:
#アドレスが存在しない場合
raise IaasException("EPROCESS-000122", [
snapshotId,
])
if len(snapshots) > 1:
#アドレスを複数参照できた場合
raise IaasException("EPROCESS-000123", [
snapshotId,
])
return snapshots[0]
def describePublicIpAddress(self, addressid):
addresses = self.describePublicIpAddresses(addressid)
if len(addresses) == 0:
#インスタンスが存在しない場合
raise IaasException("EPROCESS-000708", [
addressid,
])
if len(addresses) > 1:
#インスタンスを複数参照できた場合
raise IaasException("EPROCESS-000709", [
addressid,
])
return addresses[0]
def describeLoadBalancer(self, loadBalancerid):
loadBalancers = self.describeLoadBalancers(loadBalancerid)
if len(loadBalancers) == 0:
#インスタンスが存在しない場合
raise IaasException("EPROCESS-000719", [
loadBalancerid,
])
if len(loadBalancers) > 1:
#インスタンスを複数参照できた場合
raise IaasException("EPROCESS-000720", [
loadBalancerid,
])
return loadBalancers[0]
def getAwsAddress(self, instanceNo):
table = self.conn.getTable("AWS_ADDRESS")
awsAddresses = self.conn.select(
table.select(table.c.INSTANCE_NO == instanceNo))
if not awsAddresses or len(awsAddresses) == 0:
return None
elif len(awsAddresses) > 1:
# アドレス情報が複数ある場合
raise IaasException("EPROCESS-000202", [
instanceNo,
])
awsAddress = awsAddresses[0]
# Platformのチェック
platformNo = awsAddress["PLATFORM_NO"]
if self.client.getPlatformNo() != str(platformNo):
# PlatformNoが異なる場合、データ不整合なので警告ログを出す
self.logger.warn(None, "EPROCESS-000203", [
awsAddress["PUBLIC_IP"], awsAddress["PLATFORM_NO"],
self.client.getPlatformNo()
])
return None
return awsAddress
def describeVolume(self, volumeId):
volumes = self.describeVolumes(volumeId)
if not volumes or len(volumes) == 0:
#インスタンスが存在しない場合
raise IaasException("EPROCESS-000110", [
volumeId,
])
if len(volumes) > 1:
#インスタンスを複数参照できた場合
raise IaasException("EPROCESS-000111", [
volumeId,
])
return volumes[0]
def stop(self, instanceNo, csInstance, pccInstance):
instanceId = csInstance["INSTANCE_ID"]
# イベントログ出力
self.conn.debug(pccInstance["FARM_NO"], None, None, instanceNo, pccInstance["INSTANCE_NAME"], "CloudStackInstanceStop",["CLOUDSTACK", instanceId])
# インスタンスの停止
node = self.client.stopInstance(instanceId);
if node["state"] != "Stopped":
# インスタンス作成失敗時
raise IaasException("EPROCESS-000718", [instanceId, node["state"]])
# ログ出力
self.logger.info(None, "IPROCESS-100602", [instanceId,])
# イベントログ出力
self.conn.debug(pccInstance["FARM_NO"], None, None, instanceNo, pccInstance["INSTANCE_NAME"], "CloudStackInstanceStopFinish",["CLOUDSTACK", instanceId])
# データベース更新
table = self.conn.getTable("CLOUDSTACK_INSTANCE")
updateDict = self.conn.selectOne(table.select(table.c.INSTANCE_NO==instanceNo))
updateDict["ZONEID"] = node["zoneid"]
updateDict["STATE"] = node["state"]
updateDict["DISPLAYNAME"] = node["displayname"]
updateDict["IPADDRESS"] = node["nic"][0]["ipaddress"]
sql = table.update(table.c.INSTANCE_NO ==updateDict["INSTANCE_NO"], values=updateDict)
self.conn.execute(sql)
def waitInstance(self, instanceId):
# インスタンスの処理待ち
instance = None
retryCount = 0
while (True):
time.sleep(3)
try:
instance = self.client.describeInstance(instanceId)
except Exception:
#起動時にIDが行方不明になる事があるので3回までリトライする
self.logger.info(
"===============RETRY ID:%s ==========================" %
str(instanceId))
if self.ERROR_RETRY_COUNT < retryCount:
raise
else:
retryCount += 1
continue
status = instance.extra['status']
if status == "stopped" or status == "running" or status == "terminated":
break
if status != "stopping" and status != "pending" and status != "shutting-down":
#予期しないステータス
raise IaasException("EPROCESS-000104", [
instanceId,
status,
])
return instance
def getCsAddress(self, instanceNo):
table = self.conn.getTable("CLOUDSTACK_ADDRESS")
csAddresses = self.conn.select(
table.select(table.c.INSTANCE_NO == instanceNo))
if not csAddresses or len(csAddresses) == 0:
return None
elif len(csAddresses) > 1:
# アドレス情報が複数ある場合
raise IaasException("EPROCESS-000722", [
instanceNo,
])
csAddress = csAddresses[0]
# Platformのチェック
platformNo = csAddress["PLATFORM_NO"]
if self.client.getPlatformNo() != str(platformNo):
# PlatformNoが異なる場合、データ不整合なので警告ログを出す
self.logger.warn(None, "EPROCESS-000723", [
csAddress["IPADDRESS"], csAddress["PLATFORM_NO"],
self.client.getPlatformNo()
])
return None
return csAddress
def describeAddress(self, publicIp):
address = self.describeAddresses(publicIp)
if not address or len(address) == 0:
#アドレスが存在しない場合
raise IaasException("EPROCESS-000117", [
publicIp,
])
if len(address) > 1:
#アドレスを複数参照できた場合
raise IaasException("EPROCESS-000118", [
publicIp,
])
return address[0]
def deleteVirtualMachine(self, cloudService, instanceName, storageAccount, \
instanceNo, farmNo, instanceInfoInstanceName):
mediaLink = self.getMediaLink(cloudService, instanceName)
self.logger.debug(
' Virtual Machine(role or deployment) %s is going to be deleted'
% (instanceName))
self.logger.debug(' Media Link: %s' % (mediaLink))
roleList = self.listVirtualMachines(cloudService)
if roleList is None:
return None
if len(roleList) == 1:
# 最後のVMなので、Delete Deploymentを使う必要あり
status = self._deleteDeployment(cloudService, instanceName, \
instanceNo, farmNo, instanceInfoInstanceName)
else:
status = self._deleteRole(cloudService, instanceName, \
instanceNo, farmNo, instanceInfoInstanceName)
# 異常系テストコード
#status = 'Failed'
if status != 'Succeeded':
self.logger.debug(' Async job did not succeed. Status: %s' %
(status))
self.conn.error(farmNo, None, None, instanceNo, \
instanceInfoInstanceName, "AzureInstanceDeleteFail",["AZURE", instanceName, status])
raise IaasException("EPROCESS-000904", [instanceName])
return status
def describeInstance(self, instanceid):
nodes = self.describeInstances(instanceid)
if not nodes or len(nodes) == 0:
#インスタンスが存在しない場合
raise IaasException("EPROCESS-000101", [
instanceid,
])
if len(nodes) > 1:
#インスタンスを複数参照できた場合
raise IaasException("EPROCESS-000102", [
instanceid,
])
return nodes[0]
def describeLoadBalancer(self, loadBalancerName):
loadBalancerDescriptions = self.describeLoadBalancers(loadBalancerName)
if len(loadBalancerDescriptions) == 0:
#インスタンスが存在しない場合
raise IaasException("EPROCESS-000131", [
loadBalancerName,
])
if len(loadBalancerDescriptions) > 1:
#インスタンスを複数参照できた場合
raise IaasException("EPROCESS-000132", [
loadBalancerName,
])
return loadBalancerDescriptions[0]
def createVirtualMachine(self, serverName, flavorNm, imageId,
availabilityZoneId, networkId, userData,
securityGroupId, keyName):
# フレーバーIDからフレーバーオブジェクトへの変換
flavorObject = self._findFlavorByName(flavorNm)
if flavorObject is None:
self.logger.error(' Flavor Not Found: %s' % (flavorId))
raise IaasException("EPROCESS-001001")
# イメージIDからイメージオブジェクトへの変換
imageObject = self._findImageById(imageId)
if imageObject is None:
self.logger.error(' Image Not Found: %s' % (imageId))
raise IaasException("EPROCESS-001001")
# NICリストの作成
nics = [{"net-id": networkId, "v4-fixed-ip": "", "port-id": ""}]
# セキュリティグループリストの作成
securityGroupList = [securityGroupId]
# VM作成
try:
novaResponse = self.nova.servers.create(
serverName,
flavor=flavorObject,
image=imageObject,
availability_zone=availabilityZoneId,
nics=nics,
userdata=userData,
security_groups=securityGroupList,
key_name=keyName)
except:
self.logger.error(traceback.format_exc())
raise
# 作成完了まで待つ
serverId = novaResponse.id
instanceObj = self._waitServerStatus(serverId, 'ACTIVE')
status = instanceObj.status
if status != 'ACTIVE' and status != 'ERROR':
# タイムアウト
self.logger.error('The operation timed out.')
# 呼び出し側で例外を補足して、異なる例外を送出しているため、下記例外は失われる。
raise IaasException("EPROCESS-001011")
return instanceObj
def waitCreateVolume(self, instanceNo, volumeNo):
tableAWSVOL = self.conn.getTable("AWS_VOLUME")
awsVolume = self.conn.selectOne(
tableAWSVOL.select(tableAWSVOL.c.VOLUME_NO == volumeNo))
volumeId = awsVolume["VOLUME_ID"]
# ボリュームの作成待ち
volume = None
try:
volume = self.waitVolume(volumeId)
if volume.status != "available":
#ボリューム作成失敗時
raise IaasException("EPROCESS-000113", [
volumeId,
volume.status,
])
# ログ出力
self.logger.info(None, "IPROCESS-100122", [
volumeId,
])
except Exception:
self.logger.error(traceback.format_exc())
# ボリューム作成失敗時
awsVolume["VOLUME_ID"] = None
awsVolume["STATUS"] = None
sql = tableAWSVOL.update(
tableAWSVOL.c.VOLUME_NO == awsVolume["VOLUME_NO"],
values=awsVolume)
self.conn.execute(sql)
raise
#イベントログ出力
tableCPNT = self.conn.getTable("COMPONENT")
component = self.conn.selectOne(
tableCPNT.select(
tableCPNT.c.COMPONENT_NO == awsVolume["COMPONENT_NO"]))
componentName = None
if component:
componentName = component["COMPONENT_NAME"]
tableINS = self.conn.getTable("INSTANCE")
instance = self.conn.selectOne(
tableINS.select(tableINS.c.INSTANCE_NO == instanceNo))
self.conn.debug(instance["FARM_NO"], awsVolume["COMPONENT_NO"],
componentName, instanceNo, instance["INSTANCE_NAME"],
"AwsEbsCreateFinish",
["EC2", awsVolume["VOLUME_ID"], awsVolume["SIZE"]])
# データベース更新
updateDict = self.conn.selectOne(
tableAWSVOL.select(tableAWSVOL.c.VOLUME_NO == volumeNo))
updateDict["STATUS"] = volume.status
sql = tableAWSVOL.update(
tableAWSVOL.c.VOLUME_NO == updateDict["VOLUME_NO"],
values=updateDict)
self.conn.execute(sql)
def waitDetachVolume(self, instanceNo, volumeNo) :
tableOSVOL = self.conn.getTable("OPENSTACK_VOLUME")
osVolume = self.conn.selectOne(tableOSVOL.select(tableOSVOL.c.VOLUME_NO==volumeNo))
volumeId = osVolume["VOLUME_ID"]
instanceId = osVolume["INSTANCE_ID"]
volume = None
try :
volume = self.waitVolume(volumeId)
# TODO: デタッチ情報がすぐに更新されない問題に暫定的に対応
for i in range(0, 10):
volume = self.waitVolume(volumeId)
if volume.status == "available":
break
else:
time.sleep(10)
#タイムアウト後判定
if volume.status != "available":
# デタッチに失敗した場合
raise IaasException("EPROCESS-001016", [instanceId, volumeId, volume.status,])
# ログ出力
self.logger.info(None, "IPROCESS-100826", [volumeId, instanceId,])
except Exception:
self.logger.error(traceback.format_exc())
# デタッチに失敗した場合
updateDict = self.conn.selectOne(tableOSVOL.select(tableOSVOL.c.VOLUME_NO==volumeNo))
updateDict["STATUS"] = "error"
updateDict["INSTANCE_ID"] = None
sql = tableOSVOL.update(tableOSVOL.c.VOLUME_NO ==updateDict["VOLUME_NO"], values=updateDict)
self.conn.execute(sql)
raise
#イベントログ出力
tableCPNT = self.conn.getTable("COMPONENT")
component = self.conn.selectOne(tableCPNT.select(tableCPNT.c.COMPONENT_NO==osVolume["COMPONENT_NO"]))
componentName = None
if component:
componentName = component["COMPONENT_NAME"]
tableINS = self.conn.getTable("INSTANCE")
instance = self.conn.selectOne(tableINS.select(tableINS.c.INSTANCE_NO==instanceNo))
self.conn.debug(instance["FARM_NO"], osVolume["COMPONENT_NO"], componentName, instanceNo, instance["INSTANCE_NAME"],
"OpenStackVolumeDetachFinish",[instance["INSTANCE_NAME"], osVolume["VOLUME_ID"], osVolume["DEVICE"]])
# データベースの更新
updateDict = self.conn.selectOne(tableOSVOL.select(tableOSVOL.c.VOLUME_NO==volumeNo))
updateDict["STATUS"] = volume.status
updateDict["INSTANCE_ID"] = None
updateDict["DEVICE"] = None
sql = tableOSVOL.update(tableOSVOL.c.VOLUME_NO ==updateDict["VOLUME_NO"], values=updateDict)
self.conn.execute(sql)
def terminateInstance(self, instanceid):
result = self._async_request('destroyVirtualMachine', id=instanceid)
node = None
if 'virtualmachine' in result:
node = result['virtualmachine']
else:
raise IaasException("EPROCESS-000704", [])
return node
def rebootInstance(self, instanceid):
params = {'id': instanceid}
result = self._async_request('rebootVirtualMachine', **params)
node = None
if 'virtualmachine' in result:
node = result['virtualmachine']
else:
raise IaasException("EPROCESS-000717", [])
return node
def changeInstance(self, instanceid, serviceofferingid):
params = {'id': instanceid, 'serviceofferingid': serviceofferingid}
result = self._sync_request('changeServiceForVirtualMachine', **params)
node = None
if 'virtualmachine' in result:
node = result['virtualmachine']
else:
raise IaasException("EPROCESS-000715", [])
return node
def getPasswordData(self, instanceId):
try:
result = self._sync_request('getVMPassword', id=instanceId)
password = result['password']
encryptedpassword = password['encryptedpassword']
except Exception:
raise IaasException("EPROCESS-000721", [
instanceId,
])
return encryptedpassword
def checkAssociatedAddress(self, addressNo):
# アドレスが関連付けられているかどうかのチェック
table = self.conn.getTable("CLOUDSTACK_ADDRESS")
csAddress = self.conn.selectOne(
table.select(table.c.ADDRESS_NO == addressNo))
address_id = csAddress["ADDRESS_ID"]
instanceId = csAddress["INSTANCE_ID"]
address = self.client.describePublicIpAddress(address_id)
if "virtualmachineid" not in address:
# アドレスがどのインスタンスにも関連付けられていない場合
raise IaasException("EPROCESS-000711", [
address["ipaddress"],
address["virtualmachineid"],
])
elif instanceId != str(address["virtualmachineid"]):
# アドレスが他インスタンスに関連付けられている場合
raise IaasException("EPROCESS-000712", [
address["ipaddress"],
address["virtualmachineid"],
])
def checkAvailableAddress(self, instanceNo, addressNo):
table = self.conn.getTable("AWS_ADDRESS")
awsAddress = self.conn.selectOne(
table.select(table.c.ADDRESS_NO == addressNo))
publicIp = awsAddress["PUBLIC_IP"]
address = self.client.describeAddress(publicIp)
if isNotEmpty(address.instanceId):
# アドレスが何らかのインスタンスに関連付けられている場合
raise IaasException("EPROCESS-000119", [
publicIp,
address.instanceId,
])
