def stop_instance(self, instance_id):
status = self.get_instance_status_by_id(instance_id)
if status != ECS_STATUS_RUNNING:
logger.warning("instance [%s] is not in [%s],current status [%s], cannot stop it", instance_id,
",".join([ECS_STATUS_RUNNING]), status)
return None
request = StopInstanceRequest()
request.set_InstanceId(instance_id)
response = self.execute(request)
return response
def stop_instance(self, instanceid):
"""
停止实例
:param instanceid:
:return:
"""
client = AcsClient(self.AccessKeyId, self.AccessKeySecret, instanceid)
request = StopInstanceRequest()
request.set_accept_format('json')
response = client.do_action_with_exception(request)
res = json.loads(str(response, encoding='utf-8'))
return res
def deleteMachine(self):
clt = self.createECS_Client()
# 必须先停止 ecs，才可以删除
request = StopInstanceRequest()
request.set_InstanceId(self.instanceID)
logger.debug("stop instance: " + self.instanceID)
for retry in range(0, MAX_RETRY):
resp = self._send_request(clt, request)
if resp['code'] != 0 and resp['msg'][
'Code'] != 'IncorrectInstanceStatus':
logger.warn("stop instance failed, due to: " + str(resp))
continue
else:
break
logger.debug("resp: " + str(resp))
if resp['code'] != 0 and resp['msg'][
'Code'] != 'IncorrectInstanceStatus':
return resp
request = DeleteInstanceRequest()
request.set_InstanceId(self.instanceID)
logger.debug("delete instance: " + self.instanceID)
while True:
resp = self._send_request(clt, request)
if resp['code'] == 0:
logger.debug("delete instance OK, return %s" % resp['msg'])
break
logger.debug("response code: %s", str(response['code']))
if resp['code'] != 'IncorrectInstanceStatus':
logger.error("delete instance failed with %s" % resp['msg'])
ret['code'] = 1
ret['msg'] = "delete instance failed with" + str(resp['msg'])
return ret
logger.warn("delete instance failed with IncorrectInstanceStatus")
time.sleep(1)
logger.debug("delete instance done.")
"""删除 EIP
request = UnassociateEipAddressRequest()
request.set_InstanceId(self.instanceID)
request.set_AllocationId(self.assoID)
"""
ret = {}
ret['code'] = 0
ret['msg'] = "delete machine succ"
ret['Hostname'] = self.instanceID
ret['InstanceID'] = self.instanceID
ret['InnerAddress'] = ""
ret['EipAddress'] = ""
ret['LockReason'] = ""
ret['ExpiredTime'] = ""
return ret
def stopInstance(InstanceId):
request = StopInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(InstanceId)
response = client.do_action_with_exception(request)
response = json.loads(str(response, encoding='utf-8'))
return response
def stop_instance(client, instance_id):
request = StopInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(instance_id)
request.set_StoppedMode("StopCharging")
try:
response = client.do_action_with_exception(request)
except (ServerException, ClientException) as e:
print(e.error_code)
print("关机失败")
raise e
print("关机成功!")
pass
def stop_host(self, instance_id):
client = AcsClient(self.access_key_id, self.secret_access_key,
self.region_id)
request = StopInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(instance_id)
response = client.do_action_with_exception(request)
# python2: print(response)
print(str(response, encoding='utf-8'))
def _stop_instance(self):
"""Stop the instance."""
client = self._connect()
request = StopInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(self.running_instance_id)
client.do_action_with_exception(request)
self._wait_on_instance('Stopped', self.timeout)
def stop_instance(self, instance_id, force_stop=False):
""" Stop an ECS instance that is in the Running state.
:param instance_id: The Ecs instance ID.
:param force_stop: Specifies whether to forcibly stop the instance.
:return:
"""
request = StopInstanceRequest()
request.set_InstanceId(instance_id)
request.set_ForceStop(force_stop)
logging.info("Stop %s command submit successfully.", instance_id)
self._send_request(request)
def stop_instance(self, InstanceId):
request = StopInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(InstanceId)
status = self.check_ecs_status(InstanceId)
if status:
try:
response = self.__client.do_action_with_exception(request)
print('%s 实例已关闭' % InstanceId)
except Exception as e:
print(e)
print('%s 实例关闭失败！！！' % InstanceId)
else:
print('%s 实例状态不为Running,无法关闭!!!!' % InstanceId)
def act_stop(self, request, *args, **kwargs):
obj = get_object_or_404(ServerConfigModel, pk=kwargs['pk'])
# 创建 AcsClient 实例
_request = StopInstanceRequest()
_request.set_accept_format('json')
_request.set_InstanceId(obj.instance_id)
try:
self.acsclient.do_action_with_exception(_request)
obj.server_status.running_status = 0
obj.server_status.save()
self.message_user(request, 'Stop Successful', messages.SUCCESS)
except Exception as e:
obj.server_status.running_status = 2
obj.server_status.save()
self.message_user(request, 'Stop Failed: %s' % e.message,
messages.ERROR)
co_path = request.path.split('/')
co_path[-2] = ''
return redirect('/'.join(co_path).replace('//', '/'))
def stop_and_delete(self, instance_id):
"""
:argument instance_id
:return:
"""
request = StopInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(instance_id)
try:
response = self.client.do_action_with_exception(request)
logging.info("Start to stop Ecs : %s" % instance_id)
if ResponseUtil.success(response):
logging.info("Start to delete Ecs : %s" % instance_id)
time.sleep(60)
request = DeleteInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(instance_id)
response = self.client.do_action_with_exception(request)
if ResponseUtil.success(response):
return True, None
return False, str(response, encoding='utf-8')
return False, str(response, encoding='utf-8')
except Exception as e:
logging.error("Failed to delete ecs, cause by exception : ", e)
return False, e
def free():
instance_list = acdb.db.load_or("instance_list", [])
region_instance_id_list = [[e["RegionId"], e["InstanceId"]]
for e in instance_list]
# Stop ECS instance
for (region_id, instance_id) in region_instance_id_list:
client = AcsClient(
conf.secret["aliyun"]["access_key"],
conf.secret["aliyun"]["access_secret"],
region_id,
)
req = StopInstanceRequest()
req.set_accept_format("json")
req.set_InstanceId(instance_id)
client.do_action_with_exception(req)
print("Stop", region_id, instance_id)
print("Wait")
for _ in range(1 << 32):
if sum([
e["Status"] == "Stopped" for e in info(region_instance_id_list)
]) == len(region_instance_id_list):
break
time.sleep(30)
# Delete ECS instance
for (region_id, instance_id) in region_instance_id_list:
client = AcsClient(
conf.secret["aliyun"]["access_key"],
conf.secret["aliyun"]["access_secret"],
region_id,
)
req = DeleteInstanceRequest()
req.set_accept_format("json")
req.set_InstanceId(instance_id)
client.do_action_with_exception(req)
print("Delete", instance_id)
acdb.db.save("instance_list", [])
# DeleteSecurityGroupRequest -> DeleteVSwitchRequest -> DeleteVpcRequest
# DetachPolicyFromRoleRequest -> DeleteRoleRequest
# DeleteTrailRequest
# (OSS)delete_object -> delete_bucket
##################################################################################
###############################################################
# ECS
# ECS,Security Groupの削除
# ※ ECS Instanceは停止の状態ではないと、削除できない
###############################################################
# ECS Insatanceの停止
from aliyunsdkecs.request.v20140526.StopInstanceRequest import StopInstanceRequest
request = StopInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(INSTANCE_ID)
response = client.do_action_with_exception(request)
print(str(response, encoding='utf-8'))
# ECS Insatanceの削除
from aliyunsdkecs.request.v20140526.DeleteInstanceRequest import DeleteInstanceRequest
request = DeleteInstanceRequest()
request.set_accept_format('json')
request.set_InstanceId(INSTANCE_ID)
response = client.do_action_with_exception(request)
print(str(response, encoding='utf-8'))
def Stop_Instance(self, instance_id):
request = StopInstanceRequest()
request.set_InstanceId(instance_id)
self._send_request(request)
def stop_instance_by_id(instanceid, DryRun=False):
request_stop_instance = StopInstanceRequest()
request_stop_instance.set_InstanceId(instanceid)
request_stop_instance.set_StoppedMode('StopCharging')
request_stop_instance.set_ConfirmStop(False)
request_stop_instance.set_ForceStop(False)
request_stop_instance.set_DryRun(DryRun)
return sendrequest(request_stop_instance)
from aliyunsdkcore.client import AcsClient
from aliyunsdkecs.request.v20140526.StopInstanceRequest import StopInstanceRequest
client = AcsClient('access_key_id', 'access_key_secret', 'region_id')
request = StopInstanceRequest()
request.set_InstanceId('ECS实例ID')
response = client.do_action_with_exception(request)
print(response)
def stop(self):
request = StopInstanceRequest()
request.set_InstanceId(self.instance_id)
_do_request(self._client, request, {})
def stop_instance(instance_id):
request = StopInstanceRequest()
request.set_InstanceId(instance_id)
_send_request(request)
def stop_instance(conn, instance_id):
request = StopInstanceRequest()
request.set_InstanceId(instance_id)
request.set_ForceStop('true')
_send_request(conn, request)
def stop_instance(conn, instance_id):
logging.debug("stop instance %s" % instance_id)
request = StopInstanceRequest()
request.set_InstanceId(instance_id)
request.set_ForceStop('true')
_send_request(conn, request)