Python CCIManager.cancel_instance方法代码示例

# 需要导入模块: from SoftLayer import CCIManager [as 别名]
# 或者: from SoftLayer.CCIManager import cancel_instance [as 别名]
 def execute(self, args):
     cci = CCIManager(self.client)
     cci_id = resolve_id(cci.resolve_ids, args.get('<identifier>'), 'CCI')
     if args['--really'] or no_going_back(cci_id):
         cci.cancel_instance(cci_id)
     else:
         CLIAbort('Aborted')

# 需要导入模块: from SoftLayer import CCIManager [as 别名]
# 或者: from SoftLayer.CCIManager import cancel_instance [as 别名]
    def on_delete(self, req, resp, tenant_id, server_id):
        client = req.env["sl_client"]
        cci = CCIManager(client)

        try:
            cci.cancel_instance(server_id)
        except SoftLayerAPIError as e:
            if "active transaction" in e.faultString:
                return bad_request(
                    resp, message="Can not cancel an instance when there is already" " an active transaction", code=409
                )
            raise
        resp.status = 204

# 需要导入模块: from SoftLayer import CCIManager [as 别名]
# 或者: from SoftLayer.CCIManager import cancel_instance [as 别名]
class SoftLayer(object):

    def __init__(self, config, client=None):
        self.config = config
        if client is None:
            client = Client(
                auth=self.config['auth'],
                endpoint_url=self.config['endpoint_url'])
        self.client = client
        self.ssh = SshKeyManager(client)
        self.instances = CCIManager(client)

    @classmethod
    def get_config(cls):
        provider_conf = client_conf.get_client_settings()
        if 'SL_SSH_KEY' in os.environ:
            provider_conf['ssh_key'] = os.environ['SL_SSH_KEY']
        if not ('auth' in provider_conf and 'endpoint_url' in provider_conf):
            raise ConfigError("Missing digital ocean api credentials")
        return provider_conf

    def get_ssh_keys(self):
        keys = map(SSHKey, self.ssh.list_keys())
        if 'ssh_key' in self.config:
            keys = [k for k in keys if k.name == self.config['ssh_key']]
        log.debug(
            "Using SoftLayer ssh keys: %s" % ", ".join(k.name for k in keys))
        return keys

    def get_instances(self):
        return map(Instance, self.instances.list_instances())

    def get_instance(self, instance_id):
        return Instance(self.instances.get_instance(instance_id))

    def launch_instance(self, params):
        return Instance(self.instances.create_instance(**params))

    def terminate_instance(self, instance_id):
        self.instances.cancel_instance(instance_id)

    def wait_on(self, instance):
        # Wait up to 5 minutes, in 30 sec increments
        result = self._wait_on_instance(instance, 30, 10)
        if not result:
            raise ProviderError("Could not provision instance before timeout")
        return result

    def _wait_on_instance(self, instance, limit, delay=10):
        # Redo cci.wait to give user feedback in verbose mode.
        for count, new_instance in enumerate(itertools.repeat(instance.id)):
            instance = self.get_instance(new_instance)
            if not instance.get('activeTransaction', {}).get('id') and \
               instance.get('provisionDate'):
                return True
            if count >= limit:
                return False
            if count and count % 3 == 0:
                log.debug("Waiting for instance:%s ip:%s waited:%ds" % (
                    instance.name, instance.ip_address, count*delay))
            time.sleep(delay)

# 需要导入模块: from SoftLayer import CCIManager [as 别名]
# 或者: from SoftLayer.CCIManager import cancel_instance [as 别名]

#.........这里部分代码省略.........
                    'primaryIpAddress': {'operation': '_= 1.2.3.4'},
                    'primaryBackendIpAddress': {'operation': '_= 4.3.2.1'}
                }},
            mask=ANY,
        ))

    def test_resolve_ids_ip(self):
        service = self.client['Account']
        _id = self.cci._get_ids_from_ip('172.16.240.2')
        self.assertEqual(_id, [100, 104])

        _id = self.cci._get_ids_from_ip('nope')
        self.assertEqual(_id, [])

        # Now simulate a private IP test
        service.getVirtualGuests.side_effect = [[], [{'id': 99}]]
        _id = self.cci._get_ids_from_ip('10.0.1.87')
        self.assertEqual(_id, [99])

    def test_resolve_ids_hostname(self):
        _id = self.cci._get_ids_from_hostname('cci-test1')
        self.assertEqual(_id, [100, 104])

    def test_get_instance(self):
        result = self.cci.get_instance(100)
        self.client['Virtual_Guest'].getObject.assert_called_once_with(
            id=100, mask=ANY)
        self.assertEqual(Virtual_Guest.getObject, result)

    def test_get_create_options(self):
        results = self.cci.get_create_options()
        self.assertEqual(Virtual_Guest.getCreateObjectOptions, results)

    def test_cancel_instance(self):
        self.cci.cancel_instance(1)
        self.client['Virtual_Guest'].deleteObject.assert_called_once_with(id=1)

    def test_reload_instance(self):
        post_uri = 'http://test.sftlyr.ws/test.sh'
        self.cci.reload_instance(1, post_uri=post_uri, ssh_keys=[1701])
        service = self.client['Virtual_Guest']
        f = service.reloadOperatingSystem
        f.assert_called_once_with('FORCE',
                                  {'customProvisionScriptUri': post_uri,
                                   'sshKeyIds': [1701]}, id=1)

    @patch('SoftLayer.managers.cci.CCIManager._generate_create_dict')
    def test_create_verify(self, create_dict):
        create_dict.return_value = {'test': 1, 'verify': 1}
        self.cci.verify_create_instance(test=1, verify=1)
        create_dict.assert_called_once_with(test=1, verify=1)
        f = self.client['Virtual_Guest'].generateOrderTemplate
        f.assert_called_once_with({'test': 1, 'verify': 1})

    @patch('SoftLayer.managers.cci.CCIManager._generate_create_dict')
    def test_create_instance(self, create_dict):
        create_dict.return_value = {'test': 1, 'verify': 1}
        self.cci.create_instance(test=1, verify=1)
        create_dict.assert_called_once_with(test=1, verify=1)
        self.client['Virtual_Guest'].createObject.assert_called_once_with(
            {'test': 1, 'verify': 1})

    def test_generate_os_and_image(self):
        self.assertRaises(
            ValueError,
            self.cci._generate_create_dict,