def get(self, app):
client_map = {
'vm': VmClient,
'iam': IamClient,
'disk': DiskClient,
'mongodb': MongodbClient,
'mps': MpsClient,
'streambus': StreambusClient,
'ipanti': IpantiClient,
'rds': RdsClient,
'redis': RedisClient,
'monitor': MonitorClient,
'vpc': VpcClient,
'xdata': XdataClient,
'nc': NcClient,
'oss': OssClient,
}
profile_manager = ProfileManager()
cli_config = profile_manager.load_current_profile()
if cli_config is None:
return None
logger = get_logger(app.pargs.debug)
config = Config(cli_config.endpoint, cli_config.scheme)
credential = Credential(cli_config.access_key, cli_config.secret_key)
if self.__service not in client_map:
return None
client = client_map[self.__service](credential, config, logger)
return client
def __init__(self, config, instance_data, log_level=Logger(FATAL)):
credential = Credential(config["access_key"], config["secret_key"])
self.client = RedisClient(credential, Config(str(config["cap_host"]), SCHEME_HTTP, 60), log_level)
self.instance_data = instance_data
self.config = config
self.region_id = instance_data["region_id"]
self.header = {'x-jdcloud-erp': base64.b64encode(config["erp"])}
def setClient(conf):
access_key = str(conf["access_key"])
secret_key = str(conf["secret_key"])
credential = Credential(access_key, secret_key)
gw_config = Config(str(conf["gateway"]), SCHEME_HTTP)
client = RedisClient(credential, gw_config, Logger(conf["logger_level"]))
return client
def setClient(conf):
access_key = str(conf["access_key"])
secret_key = str(conf["secret_key"])
credential = Credential(access_key, secret_key)
gw_config = Config(str(conf["gateway"]), SCHEME_HTTP)
# client = MemcachedClient(credential, gw_config, Logger(ERROR))
client = MemcachedClient(credential, gw_config)
return client
def setUp(self):
access_key = '2FFA9E233949CAFA49B5CBAE9DB3A151'
secret_key = '9D561D6F3430FA91A4899F8C546C27D0'
self.credential = Credential(access_key, secret_key)
config = Config('apigw-kong-internal.default.mesh.jdcloud.com:8000',
scheme=SCHEME_HTTP)
#self.client = VmClient(self.credential, config)
self.client = JdmeshClient(self.credential, config)
def get(self, app):
client_map = {
'rds': RdsClient,
'kubernetes': KubernetesClient,
'streamcomputer': StreamcomputerClient,
'ipanti': IpantiClient,
'oss': OssClient,
'redis': RedisClient,
'deploy': DeployClient,
'sop': SopClient,
'function': FunctionClient,
'portal': PortalClient,
'clouddnsservice': ClouddnsserviceClient,
'cps': CpsClient,
'cdn': CdnClient,
'streambus': StreambusClient,
'httpdns': HttpdnsClient,
'mps': MpsClient,
'disk': DiskClient,
'nc': NcClient,
'vm': VmClient,
'pod': PodClient,
'ams': AmsClient,
'jdro': JdroClient,
'zfs': ZfsClient,
'datastar': DatastarClient,
'kms': KmsClient,
'elite': EliteClient,
'iam': IamClient,
'iothub': IothubClient,
'jcq': JcqClient,
'baseanti': BaseantiClient,
'ias': IasClient,
'mongodb': MongodbClient,
'live': LiveClient,
'jdfusion': JdfusionClient,
'vpc': VpcClient,
'monitor': MonitorClient,
'xdata': XdataClient,
'cr': CrClient,
}
profile_manager = ProfileManager()
cli_config = profile_manager.load_current_profile()
if cli_config is None:
return None
logger = get_logger(app.pargs.debug)
config = Config(cli_config.endpoint, cli_config.scheme, int(cli_config.timeout))
credential = Credential(cli_config.access_key, cli_config.secret_key)
if self.__service not in client_map:
return None
client = client_map[self.__service](credential, config, logger)
return client
def testDescribeMetrics(self):
access_key = 'ak'
secret_key = 'sk'
credential = Credential(access_key, secret_key)
client = MonitorClient(credential)
params = DescribeMetricsParameters('vm')
request = DescribeMetricsRequest(params)
resp = client.send(request)
self.assertTrue(resp.error is None)
def testHeadBucket(self):
access_key = 'ak'
secret_key = 'sk'
credential = Credential(access_key, secret_key)
client = OssClient(credential)
params = HeadBucketParameters('cn-north-1', 'bucke01')
request = HeadBucketRequest(params)
resp = client.send(request)
self.assertTrue(resp.error is None)
print resp.requestId
def setUp(self):
access_key = 'ak'
secret_key = 'sk'
self.credential = Credential(access_key, secret_key)
# 指定使用http方式访问vpc专用域名，超时为20s
config = Config('vm.internal.cn-north-1.jdcloud-api.com', SCHEME_HTTP,
20)
logger = Logger(
3
) # FATAL = 0 ERROR = 1 WARN = 2 INFO = 3；如果不想输出日志，可将日志级别设置为0（FATAL）；不设置logger，则默认为INFO
self.client = VmClient(self.credential, config, logger)
def attach(app, service, headers, region_id, container_id, pod_id=None):
def handle_signal(signum, frame):
h, w = web_socket.get_win_size()
resize_tty(h, w, app, service, headers, region_id, container_id, pod_id=pod_id)
web_socket.reg_winch_handler(handle_signal)
profile_manager = ProfileManager()
cli_config = profile_manager.load_current_profile()
credential = Credential(cli_config.access_key, cli_config.secret_key)
request = AttachRequest(service, WEBSOCKET_SCHEME, cli_config.endpoint, METHOD_GET, headers, region_id, container_id, pod_id=pod_id)
request.invoke_shell(credential)
h_o, w_o = web_socket.get_win_size()
resize_tty(h_o, w_o, app, service, headers, region_id, container_id, pod_id=pod_id)
def exec_start(app, region_id, container_id, exec_id):
def handle_signal(signum, frame):
h, w = web_socket.get_win_size()
resize_tty(h, w, app, region_id, container_id, exec_id)
web_socket.reg_winch_handler(handle_signal)
profile_manager = ProfileManager()
cli_config = profile_manager.load_current_profile()
credential = Credential(cli_config.access_key, cli_config.secret_key)
request = ExecStartRequest(WEBSOCKET_SCHEME, cli_config.endpoint,
METHOD_GET, region_id, container_id, exec_id)
request.invoke_shell(credential)
h_o, w_o = web_socket.get_win_size()
resize_tty(h_o, w_o, app, region_id, container_id, exec_id)
def __init__(self, access_key, secret_key, regionId, az, name, diskType,\
diskSizeGB, description=None, snapshotId=None, chargeSpec=None, maxCount=1):
self.regionId = regionId
self.az = az
self.name = name
# ssd or premium-hdd
self.diskType = diskType
# diskSizeGB: type of Integer
self.diskSizeGB = diskSizeGB
self.description = description
self.snapshotId = snapshotId
# :param chargeMode: (Optional) 计费模式，取值为：prepaid_by_duration，postpaid_by_usage或postpaid_by_duration，prepaid_by_duration表示预付费，postpaid_by_usage表示按用量后付费，postpaid_by_duration表示按配置后付费，默认为postpaid_by_duration
self.chargeSpec = chargeSpec
self.maxCount = maxCount
self.credential = Credential(access_key, secret_key)
self.client = DiskClient(self.credential)
print 'Client created...'
def __init__(self, access_key, secret_key, regionId, az, instanceType, imageId,\
name, password, maxCount=1, chargeSpec=None, description=None):
self.regionId = regionId
self.az = az
# E.G. 'g.s1.micro'
self.instanceType = instanceType
self.imageId = imageId
# instance name prefix
self.name = name
self.password = password
self.maxCount = maxCount
# Default None: postpaid_by_duration:按配置后付费
self.chargeSpec = chargeSpec
self.description = description
# InstanceDiskAttachmentSpec[]
self.dataDiskSpec = []
self.elasticIpSpec = None
self.credential = Credential(access_key, secret_key)
self.client = VmClient(self.credential)
print 'Client created...'
def __init__(self,
access_key,
secret_key,
regionId,
bandwidthMbps,
provider,
elasticIpAddress=None,
maxCount=1,
chargeSpec=None):
self.regionId = regionId
self.bandwidthMbps = bandwidthMbps
# bgp or no_bgp
self.provider = provider
# 指定弹性ip地址进行创建，当申请创建多个弹性ip时，必须为空
self.elasticIpAddress = elasticIpAddress
# 购买弹性ip数量；取值范围：[1,100]
self.maxCount = maxCount
self.chargeSpec = chargeSpec
self.credential = Credential(access_key, secret_key)
self.client = VpcClient(self.credential)
print 'Client created...'
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from jdcloud_sdk.core.credential import Credential
from jdcloud_sdk.services.vpc.client.VpcClient import *
from jdcloud_sdk.services.common.models.Filter import *
from jdcloud_sdk.services.vpc.apis.DescribeElasticIpsRequest import *
import json
access_key = 'ak'
secret_key = 'sk'
regionId = 'cn-north-1'
myCredential = Credential(access_key, secret_key)
myClient = VpcClient(myCredential)
# List of all the EIP IDs
eipList = ['fip-tj98zpg0ym', 'fip-0rsd6husd2', 'fip-7quu2vwtmu']
# Filter by EIP ID
myFilter = Filter('elasticIpIds', eipList)
myParam = DescribeElasticIpsParameters(regionId)
myParam.setFilters([myFilter])
myRequest = DescribeElasticIpsRequest(myParam)
resp = myClient.send(myRequest)
# output all the info of EIPs
print json.dumps(resp.result, indent=2)
eipID = []
# get the public IPs by order
def create_client(self, ak, sk, domain):
access_key = ak
secret_key = sk
self.credential = Credential(access_key, secret_key)
config = Config(domain, scheme=SCHEME_HTTP)
self.client = JdmeshClient(self.credential, config)
def setUp(self):
access_key = 'ak'
secret_key = 'sk'
self.credential = Credential(access_key, secret_key)
self.client = JcqClient(self.credential)
def getDiskClient(accessKey, secretKey):
credential = Credential(accessKey, secretKey)
logger = Logger(2)
config = Config(timeout=1000)
client = DiskClient(credential, logger=logger, config=config)
return client
def get(self, app):
client_map = {
'rds': RdsClient,
'kubernetes': KubernetesClient,
'vqd': VqdClient,
'streamcomputer': StreamcomputerClient,
'ipanti': IpantiClient,
'ssl': SslClient,
'domainservice': DomainserviceClient,
'jmr': JmrClient,
'oss': OssClient,
'redis': RedisClient,
'billing': BillingClient,
'deploy': DeployClient,
'sop': SopClient,
'function': FunctionClient,
'portal': PortalClient,
'jdccs': JdccsClient,
'logs': LogsClient,
'clouddnsservice': ClouddnsserviceClient,
'cps': CpsClient,
'cdn': CdnClient,
'streambus': StreambusClient,
'apigateway': ApigatewayClient,
'httpdns': HttpdnsClient,
'disk': DiskClient,
'sts': StsClient,
'nc': NcClient,
'vm': VmClient,
'nativecontainer': NativecontainerClient,
'iotcore': IotcoreClient,
'pod': PodClient,
'ams': AmsClient,
'jdro': JdroClient,
'zfs': ZfsClient,
'vod': VodClient,
'yundingdatapush': YundingdatapushClient,
'datastar': DatastarClient,
'kms': KmsClient,
'elite': EliteClient,
'ossopenapi': OssopenapiClient,
'iam': IamClient,
'iothub': IothubClient,
'sms': SmsClient,
'jcq': JcqClient,
'resourcetag': ResourcetagClient,
'baseanti': BaseantiClient,
'ias': IasClient,
'mongodb': MongodbClient,
'jdfusion': JdfusionClient,
'live': LiveClient,
'detection': DetectionClient,
'iotlink': IotlinkClient,
'renewal': RenewalClient,
'yunding': YundingClient,
'vpc': VpcClient,
'monitor': MonitorClient,
'xdata': XdataClient,
'containerregistry': ContainerregistryClient,
'partner': PartnerClient,
'lb': LbClient,
'industrydata': IndustrydataClient,
}
profile_manager = ProfileManager()
cli_config = profile_manager.load_current_profile()
if cli_config is None:
return None
logger = get_logger(app.pargs.debug)
config = Config(cli_config.endpoint, cli_config.scheme,
int(cli_config.timeout))
credential = Credential(cli_config.access_key, cli_config.secret_key)
if self.__service not in client_map:
return None
client = client_map[self.__service](credential, config, logger)
return client