def __init__(self, args):
self._args = args
self._compute_client = None
self._resource_client = None
self._network_client = None
self.debug = False
if args.debug:
self.debug = True
self.credentials = self._get_credentials(args)
if not self.credentials:
self.fail("Failed to get credentials. Either pass as parameters, set environment variables, "
"or define a profile in ~/.azure/credentials.")
if self.credentials.get('subscription_id', None) is None:
self.fail("Credentials did not include a subscription_id value.")
self.log("setting subscription_id")
self.subscription_id = self.credentials['subscription_id']
if self.credentials.get('client_id') is not None and \
self.credentials.get('secret') is not None and \
self.credentials.get('tenant') is not None:
self.azure_credentials = ServicePrincipalCredentials(client_id=self.credentials['client_id'],
secret=self.credentials['secret'],
tenant=self.credentials['tenant'])
elif self.credentials.get('ad_user') is not None and self.credentials.get('password') is not None:
tenant = self.credentials.get('tenant')
if tenant is not None:
self.azure_credentials = UserPassCredentials(self.credentials['ad_user'], self.credentials['password'], tenant=tenant)
else:
self.azure_credentials = UserPassCredentials(self.credentials['ad_user'], self.credentials['password'])
else:
self.fail("Failed to authenticate with provided credentials. Some attributes were missing. "
"Credentials must include client_id, secret and tenant or ad_user and password.")
def _determine_auth(**kwargs):
'''
Acquire Azure ARM Credentials
'''
if 'profile' in kwargs:
azure_credentials = __salt__['config.option'](kwargs['profile'])
kwargs.update(azure_credentials)
service_principal_creds_kwargs = ['client_id', 'secret', 'tenant']
user_pass_creds_kwargs = ['username', 'password']
try:
if kwargs.get('cloud_environment') and kwargs.get(
'cloud_environment').startswith('http'):
cloud_env = get_cloud_from_metadata_endpoint(
kwargs['cloud_environment'])
else:
cloud_env_module = importlib.import_module(
'msrestazure.azure_cloud')
cloud_env = getattr(
cloud_env_module,
kwargs.get('cloud_environment', 'AZURE_PUBLIC_CLOUD'))
except (AttributeError, ImportError, MetadataEndpointError):
raise sys.exit(
'The Azure cloud environment {0} is not available.'.format(
kwargs['cloud_environment']))
if set(service_principal_creds_kwargs).issubset(kwargs):
if not (kwargs['client_id'] and kwargs['secret'] and kwargs['tenant']):
raise SaltInvocationError(
'The client_id, secret, and tenant parameters must all be '
'populated if using service principals.')
else:
credentials = ServicePrincipalCredentials(
kwargs['client_id'],
kwargs['secret'],
tenant=kwargs['tenant'],
cloud_environment=cloud_env)
elif set(user_pass_creds_kwargs).issubset(kwargs):
if not (kwargs['username'] and kwargs['password']):
raise SaltInvocationError(
'The username and password parameters must both be '
'populated if using username/password authentication.')
else:
credentials = UserPassCredentials(kwargs['username'],
kwargs['password'],
cloud_environment=cloud_env)
else:
raise SaltInvocationError(
'Unable to determine credentials. '
'A subscription_id with username and password, '
'or client_id, secret, and tenant or a profile with the '
'required parameters populated')
if 'subscription_id' not in kwargs:
raise SaltInvocationError('A subscription_id must be specified')
subscription_id = salt.utils.stringutils.to_str(kwargs['subscription_id'])
return credentials, subscription_id, cloud_env
def get_conn(
Client=ComputeManagementClient, # pylint: disable=invalid-name
ClientConfig=ComputeManagementClientConfiguration): # pylint: disable=invalid-name
'''
Return a conn object for the passed VM data
'''
subscription_id = config.get_cloud_config_value('subscription_id',
get_configured_provider(),
__opts__,
search_global=False)
username = config.get_cloud_config_value('username',
get_configured_provider(),
__opts__,
search_global=False)
password = config.get_cloud_config_value('password',
get_configured_provider(),
__opts__,
search_global=False)
credentials = UserPassCredentials(username, password)
client = Client(
ClientConfig(
credentials,
subscription_id=subscription_id,
))
return client
def fetch_region_pricing(offer, region):
now = datetime.utcnow()
record = AzurePricing.query.filter(
and_(AzurePricing.offer == offer,
AzurePricing.region == region)).order_by(desc(
AzurePricing.date)).first()
if record and record.date > now - azure_fetch_freq:
return
if not record:
record = AzurePricing(offer=offer, region=region)
try:
azure_subscription_id = app.config['AZURE_SUBSCRIPTION_ID']
azure_ad_username = app.config['AZURE_AD_USERNAME']
azure_ad_password = app.config['AZURE_AD_PASSWORD']
azure_credentials = UserPassCredentials(azure_ad_username,
azure_ad_password)
azure_commerce_client = UsageManagementClient(azure_credentials,
azure_subscription_id)
azure_resource_client = ResourceManagementClient(
azure_credentials, azure_subscription_id)
azure_resource_client.providers.register('Microsoft.Commerce')
except Exception, e:
logging.error(
"Error during azure UserPassCredentials instantiation in app.ms_azure.pricing.fetch_region_pricing"
)
global COMMERCE_CREDENTIALS_ERROR_EMAIL_SENT
if not COMMERCE_CREDENTIALS_ERROR_EMAIL_SENT:
azure_commerce_userpasscredentials_error_email(
traceback.format_exc())
COMMERCE_CREDENTIALS_ERROR_EMAIL_SENT = True
return
def __init__(self, user, passwd, subscription_id, resource_group):
self.subscription_id = subscription_id
self.resource_group = resource_group
self.dns_label_prefix = self.name_generator.haikunate()
self.credentials = UserPassCredentials(user, passwd)
self.client = ResourceManagementClient(self.credentials,
self.subscription_id)
def public_ip_creation(req):
usr_mail = req.session['email']
usr_pass = req.session['azure_pwd']
subid = str(req.session['subid'])
try:
credentials = UserPassCredentials(usr_mail, usr_pass)
network_client = NetworkManagementClient(credentials, subid)
public_ip_parameter = {
'location': req.POST['location'],
'public_ip_allocation_method': 'Static',
'public_ip_address_version': 'IPv4',
'idle_timeout_in_minutes': 4 #value must be in between 4 to 30
}
res = network_client.public_ip_addresses.create_or_update(
req.POST['resgroup'], req.POST['public_ip_name'],
public_ip_parameter)
res1 = res.result()
except Exception as e:
return HttpResponse(e)
else:
return HttpResponse("Your public ip address is " +
str(res1.ip_address))
def vpn_creation(req):
usr_mail = req.session['email']
usr_pass = req.session['azure_pwd']
subid = str(req.session['subid'])
try:
credentials = UserPassCredentials(usr_mail, usr_pass)
network_client = NetworkManagementClient(credentials, subid)
resource_client = ResourceManagementClient(credentials, subid)
res_obj = resource_client.resource_groups.get(req.POST['drop1'])
vpn_parameter = {
'location': res_obj.location,
'address_space': {
'address_prefixes': [req.POST['vpn_address']]
}
}
network_client.virtual_networks.create_or_update(
req.POST['drop1'], req.POST['vpn_name'], vpn_parameter)
except Exception as e:
return HttpResponse(e)
else:
return HttpResponse("Successfully Created")
def __init__(self):
credentials = UserPassCredentials(CONF.azure.username,
CONF.azure.password)
LOG.info(_LI('Login with Azure username and password.'))
self.resource = ResourceManagementClient(credentials,
CONF.azure.subscription_id)
self.compute = ComputeManagementClient(credentials,
CONF.azure.subscription_id)
self.network = NetworkManagementClient(credentials,
CONF.azure.subscription_id)
try:
self.resource.providers.register('Microsoft.Network')
LOG.info(_LI("Register Microsoft.Network"))
self.resource.providers.register('Microsoft.Compute')
LOG.info(_LI("Register Microsoft.Compute"))
except Exception as e:
msg = six.text_type(e)
ex = exception.ProviderRegisterFailure(reason=msg)
LOG.exception(msg)
raise ex
try:
self.resource.resource_groups.create_or_update(
CONF.azure.resource_group, {'location': CONF.azure.location})
LOG.info(_LI("Create/Update Resource Group"))
except Exception as e:
msg = six.text_type(e)
ex = exception.ResourceGroupCreateFailure(reason=msg)
LOG.exception(msg)
raise ex
def get_conn(Client=None, ClientConfig=None):
'''
Return a conn object for the passed VM data
'''
if Client is not None:
Client = ComputeManagementClient
if ClientConfig is not None:
ClientConfig = ComputeManagementClientConfiguration
subscription_id = config.get_cloud_config_value('subscription_id',
get_configured_provider(),
__opts__,
search_global=False)
username = config.get_cloud_config_value('username',
get_configured_provider(),
__opts__,
search_global=False)
password = config.get_cloud_config_value('password',
get_configured_provider(),
__opts__,
search_global=False)
credentials = UserPassCredentials(username, password)
client = Client(
ClientConfig(
credentials,
subscription_id=subscription_id,
))
return client
def get_credentials(self, auth_data):
auths = auth_data.getAuthInfo(self.type)
if not auths:
raise Exception("No auth data has been specified to Azure.")
else:
auth = auths[0]
if 'subscription_id' in auth and 'username' in auth and 'password' in auth:
subscription_id = auth['subscription_id']
if self.credentials and self.auth.compare(auth_data, self.type):
return self.credentials, subscription_id
else:
self.auth = auth_data
self.credentials = UserPassCredentials(auth['username'], auth['password'])
elif 'subscription_id' in auth and 'client_id' in auth and 'secret' in auth and 'tenant' in auth:
subscription_id = auth['subscription_id']
if self.credentials and self.auth.compare(auth_data, self.type):
return self.credentials, subscription_id
else:
self.auth = auth_data
self.credentials = ServicePrincipalCredentials(client_id=auth['client_id'],
secret=auth['secret'],
tenant=auth['tenant'])
else:
raise Exception("No correct auth data has been specified to Azure: "
"subscription_id, username and password or"
"subscription_id, client_id, secret and tenant")
return self.credentials, subscription_id
def delstorage(req):
mail = req.session['email']
password = req.session['azure_pwd']
subid = str(req.session['subid'])
credentials = UserPassCredentials(mail, password)
storage_client = StorageManagementClient(credentials, subid)
resource_client = ResourceManagementClient(credentials, subid)
lst_del_str = req.GET.getlist('abc')
try:
'''for rg in resource_client.resource_groups.list():
for item in resource_client.resource_groups.list_resources(rg.name):
if "Microsoft.Storage/storageAccounts" == item.type and item.name in lst_del_str:
storage_client.storage_accounts.delete(rg.name,item.name)
'''
lst = lst_del_str[0].split(",")
storage_client.storage_accounts.delete(lst[1], lst[0])
except Exception as e:
return HttpResponse(e)
else:
return HttpResponse("Successfully deleted")
def __init__(self, args):
self._args = args
self._cloud_environment = None
self._compute_client = None
self._resource_client = None
self._network_client = None
self.debug = False
if args.debug:
self.debug = True
self.credentials = self._get_credentials(args)
if not self.credentials:
self.fail("Failed to get credentials. Either pass as parameters, set environment variables, "
"or define a profile in ~/.azure/credentials.")
# if cloud_environment specified, look up/build Cloud object
raw_cloud_env = self.credentials.get('cloud_environment')
if not raw_cloud_env:
self._cloud_environment = azure_cloud.AZURE_PUBLIC_CLOUD # SDK default
else:
# try to look up "well-known" values via the name attribute on azure_cloud members
all_clouds = [x[1] for x in inspect.getmembers(azure_cloud) if isinstance(x[1], azure_cloud.Cloud)]
matched_clouds = [x for x in all_clouds if x.name == raw_cloud_env]
if len(matched_clouds) == 1:
self._cloud_environment = matched_clouds[0]
elif len(matched_clouds) > 1:
self.fail("Azure SDK failure: more than one cloud matched for cloud_environment name '{0}'".format(raw_cloud_env))
else:
if not urlparse.urlparse(raw_cloud_env).scheme:
self.fail("cloud_environment must be an endpoint discovery URL or one of {0}".format([x.name for x in all_clouds]))
try:
self._cloud_environment = azure_cloud.get_cloud_from_metadata_endpoint(raw_cloud_env)
except Exception as e:
self.fail("cloud_environment {0} could not be resolved: {1}".format(raw_cloud_env, e.message))
if self.credentials.get('subscription_id', None) is None:
self.fail("Credentials did not include a subscription_id value.")
self.log("setting subscription_id")
self.subscription_id = self.credentials['subscription_id']
if self.credentials.get('client_id') is not None and \
self.credentials.get('secret') is not None and \
self.credentials.get('tenant') is not None:
self.azure_credentials = ServicePrincipalCredentials(client_id=self.credentials['client_id'],
secret=self.credentials['secret'],
tenant=self.credentials['tenant'],
cloud_environment=self._cloud_environment)
elif self.credentials.get('ad_user') is not None and self.credentials.get('password') is not None:
tenant = self.credentials.get('tenant')
if not tenant:
tenant = 'common'
self.azure_credentials = UserPassCredentials(self.credentials['ad_user'],
self.credentials['password'],
tenant=tenant,
cloud_environment=self._cloud_environment)
else:
self.fail("Failed to authenticate with provided credentials. Some attributes were missing. "
"Credentials must include client_id, secret and tenant or ad_user and password.")
def authenticate(req):
msg = ""
if 'email' in req.POST:
email = req.POST['email']
if email == "":
return render(req, "validation_msg.html",
{"message": "Plase fill email"})
else:
msg = "email is missing"
return render(req, 'validation_msg.html', {"message": msg})
if 'password' in req.POST:
password = req.POST['password']
if password == "":
msg = "password is missing"
return render(req, 'validation_msg.html', {"message": msg})
else:
msg = "password is missing"
return render(req, 'validation_msg.html', {"message": msg})
if 'subid' in req.POST:
subid = str(req.POST['subid'])
if subid == "":
msg = "subid is missing"
return render(req, 'validation_msg.html', {"message": msg})
else:
msg = "subid is missing"
return render(req, 'validation_msg.html', {"message": msg})
try:
req.session['email'] = email
req.session['password'] = password
req.session['subid'] = subid
credentials = UserPassCredentials(email, password)
resource_client = ResourceManagementClient(credentials, subid)
msg += "Valid user!!!!"
#fo = open("netrc","ab")
#machine = "portal.azure.com"+email
#str1 ="\nmachine "+machine+"\n"+"login "+email+"\n"+"password "+password
#fo.write(str1)
return render(req, 'validation_msg.html', {"message": msg})
except Exception as e:
msg += "EROOR: "
msg += str(e)
return render(req, 'validation_msg.html', {"message": msg})
def get_credentials(config_data):
return UserPassCredentials(
config_data["username"],
config_data["password"],
)
def __init__(self, config: dict, channel=None):
"""INITIALIZE AZURE PROVIDER. USES AZURE PYTHON SDK TO PROVIDE EXECUTION RESOURCES
ARGS:
- :parm config (dict): Dictionary with all the config options.
KWargs:
- :param channel (None): A channel is not required for Azure.
"""
self.config = self.read_configs(config)
self.config_logger()
if not _azure_enabled:
raise OptionalModuleMissing(['azure'], "Azure Provider requires the azure module.")
credentials = UserPassCredentials(self.config['username'], self.config['pass'])
subscription_id = self.config['subscriptionId']
self.resource_client = ResourceManagementClient(credentials, subscription_id)
self.storage_client = StorageManagementClient(credentials, subscription_id)
self.resource_group_name = 'my_resource_group'
self.deployer = Deployer(subscription_id, self.resource_group_name, self.read_configs(config))
self.channel = channel
self.config = config
self.sitename = config['site']
self.current_blocksize = 0
self.resources = {}
self.instances = []
self.config = config
options = self.config["execution"]["block"]["options"]
logger.warn("Options %s", options)
self.instance_type = options.get("azure_template_file", "template.json")
self.image_id = options["imageId"]
self.key_name = options["keyName"]
self.region = options.get("region", 'us-east-2')
self.max_nodes = (
self.config["execution"]["block"].get("maxBlocks", 1) * self.config["execution"]["block"].get("nodes", 1))
try:
self.initialize_boto_client()
except Exception as e:
logger.error("Site:[{0}] Failed to initialize".format(self))
raise e
try:
self.statefile = self.config["execution"]["block"]["options"].get("stateFile", '.ec2site_{0}.json'.format(
self.sitename))
self.read_state_file(self.statefile)
except Exception as e:
self.create_vpc().id
logger.info("No State File. Cannot load previous options. Creating new infrastructure")
self.write_state_file()
def login(self):
"""Method to authenticate"""
try:
credentials = UserPassCredentials(userName, userPass)
print('Authenticated Successfully.')
except:
print(
'Either your AD login/password is incorrect, or you are using an MFA. \n'
+ 'MFA use with this script is not supported at this time')
sys.exit(1)
self.connecting_clients(credentials)
def __init__(self):
self.credentials = UserPassCredentials(
config.AD_LOGIN_USER,
config.AD_LOGIN_PASS,
resource="https://graph.windows.net"
)
self.tenant_id = config.AD_TENANT_ID
self.client = GraphRbacManagementClient(
self.credentials,
self.tenant_id
)
def __init__(self, cluster_id, cluster_name, config, plugin_config):
self.config = config
self.plugin_config = plugin_config
#TODO: Deal with different auth types
self.aad_credentials = UserPassCredentials(
self.config.get("aadUsername"), self.config.get("aadPassword"))
self.subscription_id = self.config.get('aadSubscriptionId')
#TODO: check how to simplify that since clusters are unique to Azure
self.hdi_cluster_name = self.config.get('hdiClusterName')
self.hdi_cluster_rg = self.config.get('hdiResourceGroup')
def main():
credentials = UserPassCredentials(mailadmin,
passwordadmin,
resource="https://graph.windows.net")
graphrbac_client = GraphRbacManagementClient(credentials, tenantid)
param = UserUpdateParameters(password_profile=PasswordProfile(
password=newpassword, force_change_password_next_login=False))
user = graphrbac_client.users.update(mail, param)
def __init__(self,
subscription_id,
username,
password,
label='azure',
template_file='template.json',
init_blocks=1,
min_blocks=0,
max_blocks=1,
nodes_per_block=1,
state_file=None):
self.configure_logger()
if not _azure_enabled:
raise OptionalModuleMissing(
['azure'], "Azure Provider requires the azure module.")
credentials = UserPassCredentials(username, password)
self.resource_client = ResourceManagementClient(
credentials, subscription_id)
self.storage_client = StorageManagementClient(credentials,
subscription_id)
self.resource_group_name = 'my_resource_group'
self.deployer = Deployer(subscription_id, self.resource_group_name,
self.read_configs(config))
self.channel = channel
self.config = config
self.provisioned_blocks = 0
self.resources = {}
self.instances = []
self.max_nodes = max_blocks * nodes_per_block
try:
self.initialize_boto_client()
except Exception as e:
logger.error("Azure '{}' failed to initialize.".format(self.label))
raise e
try:
if state_file is None:
state_file = '.azure_{}.json'.format(self.label)
self.read_state_file(state_file)
except Exception as e:
self.create_vpc().id
logger.info(
"No State File. Cannot load previous options. Creating new infrastructure."
)
self.write_state_file()
def __init__(self, args):
self._args = args
self._compute_client = None
self._resource_client = None
self._network_client = None
self.debug = False
if args.debug:
self.debug = True
self.credentials = self._get_credentials(args)
if not self.credentials:
self.fail("Failed to get credentials. Either pass as parameters, set environment variables, "
"or define a profile in ~/.azure/credentials.")
if self.credentials.get('subscription_id', None) is None:
self.fail("Credentials did not include a subscription_id value.")
self.log("setting subscription_id")
self.subscription_id = self.credentials['subscription_id']
if self.credentials.get('client_id') is not None and \
self.credentials.get('secret') is not None and \
self.credentials.get('tenant') is not None:
self.azure_credentials = ServicePrincipalCredentials(client_id=self.credentials['client_id'],
secret=self.credentials['secret'],
tenant=self.credentials['tenant'])
elif self.credentials.get('ad_user') is not None and \
self.credentials.get('password') is not None and \
self.credentials.get('client_id') is not None and \
self.credentials.get('authority') is not None:
# ADAL support
# Default value for resource
resource = self.credentials['resource']
if resource is None:
resource = 'https://management.core.windows.net/'
# Get context
context = adal.AuthenticationContext(self.credentials['authority'])
# Get token
raw_token = context.acquire_token_with_username_password(resource,
self.credentials['ad_user'],
self.credentials['password'],
self.credentials['client_id'])
# From CamelCase to underscore
token = {}
for key, value in raw_token.items():
token[re.sub( '(?<!^)(?=[A-Z])', '_', key).lower()] = value
# Get azure credentials
self.azure_credentials = BasicTokenAuthentication(token)
elif self.credentials.get('ad_user') is not None and self.credentials.get('password') is not None:
self.azure_credentials = UserPassCredentials(self.credentials['ad_user'], self.credentials['password'])
else:
self.fail("Failed to authenticate with provided credentials. Some attributes were missing. "
"Credentials must include client_id, secret and tenant or ad_user and password.")
def __init__(self,
resource_group_name,
template_path,
parameters,
user_email="*****@*****.**",
user_password="******",
subscription_id="0003c64e-455e-4794-8665-a59c04a8961b"):
# region ---- Set instance fields ----
self.resource_group_name = resource_group_name
self.deployment_name = "taivo_python_deployment"
self.template_path = template_path
self.parameters = parameters
self.credentials = UserPassCredentials(user_email, user_password)
self.resource_client = ResourceManagementClient(
self.credentials, subscription_id)
self.compute_client = ComputeManagementClient(self.credentials,
subscription_id)
self.network_client = NetworkManagementClient(self.credentials,
subscription_id)
self.storage_client = StorageManagementClient(self.credentials,
subscription_id)
# endregion
# region ---- Set up logging ----
LOG_FORMAT = '%(asctime)-15s [%(name)s] - %(message)s'
LOG_LEVEL = logging.INFO
formatter = logging.Formatter(LOG_FORMAT)
ch = logging.StreamHandler()
ch.setLevel(LOG_LEVEL)
ch.setFormatter(formatter)
self.log = logging.getLogger(__name__)
self.log.setLevel(LOG_LEVEL)
self.log.addHandler(ch)
# endregion
# region ---- Find if resource group exists ----
already_exists = self.resource_client.resource_groups.check_existence(
self.resource_group_name)
if already_exists:
self.log.info("Resource group already exists:")
resources = self.resource_client.resource_groups.list_resources(
self.resource_group_name)
#for res in resources:
# self.log.info(Deployer.stringify_resource(res))
else:
self.log.info("Resource group does not exist yet.")
# endregion
pass
def __init__(self):
self.credentials = ServicePrincipalCredentials(
client_id=CLIENT_ID,
secret=SECRET,
tenant=TENANT,
)
self.cr = UserPassCredentials('*****@*****.**', 'Roshan@123')
self.monitor_client = MonitorManagementClient(self.cr, subscription_id)
self.compute_client = ComputeManagementClient(self.cr, subscription_id)
self.network_client = NetworkManagementClient(self.cr, subscription_id)
self.resource_client = ResourceManagementClient(
self.cr, subscription_id)
def azure_credentials():
try: # ServicePrincipalCredentials first
credentials = ServicePrincipalCredentials(
client_id=os.environ['AZURE_CLIENT_ID'],
secret=os.environ['AZURE_CLIENT_SECRET'],
tenant=os.environ['AZURE_TENANT_ID'])
except KeyError:
credentials = UserPassCredentials(
username=os.environ['AZURE_USERNAME'],
password=os.environ['AZURE_PASSWORD'])
return credentials
def get_credentials(self, auth_method, **kwargs):
if auth_method == 'Service Principal':
credentials = ServicePrincipalCredentials(
client_id=kwargs['client_id'],
secret=kwargs['secret'],
tenant=kwargs['tenant_id'])
elif auth_method == 'User ID Password':
credentials = UserPassCredentials(username=kwargs['user_id'],
password=kwargs['password'])
else:
credentials = None
return credentials
def __init__(self, config_file='/work/config.yaml'):
"""Set config file (default:/work/config.yaml)"""
config_file = '/work/config.yaml'
f = open(config_file)
data = yaml.load(f)
f.close()
username = data['username']
password = data['password']
subscription_id = data['subscription_id']
credentials = UserPassCredentials(username, password)
self._computemanagement_client = ComputeManagementClient(
credentials, subscription_id)
def get_access_token(
subscription_id=None,
user=None,
password=None,
tenant=None,
is_china=False,
timeout=None):
"""
Open Azure API session using AzureSDK and return Token
:param subscription_id: Azure Subscription ID
:type subscription_id: str
:param user: UserName or Client ID
:type user: str
:param password: Password or Secret ID
:type password: str
:param tenant: Tenant ID
:type tenant: str
:param is_china: China Option
:type is_china: bool
:return: Token
:rtype: dict
"""
for field_name in ['subscription_id', 'user', 'password']:
if locals().get(field_name, None) is None:
raise AttributeError("field [%s] is required" % field_name)
try:
if not tenant:
credentials = UserPassCredentials(user, password, china=is_china)
else:
credentials = ServicePrincipalCredentials(
client_id=user, secret=password, tenant=tenant, china=is_china, timeout=timeout
)
except Exception as e:
msg = 'Login Azure FAILED with message : %s' % str(e)
logger.error(msg)
raise AuthenticationError(msg)
rm = ResourceManagementClient(credentials, subscription_id)
if rm.config.generate_client_request_id:
return credentials.token
else:
msg = 'login azure failed'
logger.error(msg)
raise AuthenticationError(msg)
def network_content1(req):
credentials = UserPassCredentials(req.session['email'],
req.session['azure_pwd'])
resource_client = ResourceManagementClient(credentials,
str(req.session['subid']))
lst = resource_client.resource_groups.list()
lst_rg = []
for item in lst:
lst_rg.append(item.name)
return render(req, "vertical_pilles.html", {"lst_rg": lst_rg})
def lst_rg(req):
lst_rg = []
email = req.session['email']
password = req.session['azure_pwd']
subid = str(req.session['subid'])
try:
credentials = UserPassCredentials(email, password)
resource_client = ResourceManagementClient(credentials, subid)
except Exception as e:
return HttpResponse(e)
for item in resource_client.resource_groups.list():
lst_rg.append(item.name)
return render(req, 'lst_rg.html', {"lst_rg": lst_rg})
def __init__(self,
username=CONF.azure.username,
password=CONF.azure.password,
subscription_id=CONF.azure.subscription_id,
resource_group=CONF.azure.resource_group,
location=CONF.azure.location):
credentials = UserPassCredentials(username, password)
LOG.info(_LI('Login with Azure username and password.'))
self.compute = ComputeManagementClient(credentials, subscription_id)
self.resource = ResourceManagementClient(credentials, subscription_id)
try:
self.resource.resource_groups.create_or_update(
CONF.azure.resource_group, {'location': location})
LOG.info(_LI("Create/Update Resource Group"))
except Exception as e:
msg = six.text_type(e)
ex = exception.VolumeBackendAPIException(reason=msg)
LOG.exception(msg)
raise ex
