def main():
module = AnsibleModule(argument_spec=dict(
name=dict(type='str'),
location=dict(type='str', choices=LOCATIONS, default='us/las'),
size=dict(type='int', default=1),
api_url=dict(type='str', default=None),
username=dict(type='str',
required=True,
aliases=['subscription_user'],
fallback=(env_fallback, ['PROFITBRICKS_USERNAME'])),
password=dict(type='str',
required=True,
aliases=['subscription_password'],
fallback=(env_fallback, ['PROFITBRICKS_PASSWORD']),
no_log=True),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(type='str', default='present'),
),
supports_check_mode=True)
if not HAS_PB_SDK:
module.fail_json(
msg=
'profitbricks is required for this module, run `pip install profitbricks`'
)
username = module.params.get('username')
password = module.params.get('password')
api_url = module.params.get('api_url')
if not api_url:
profitbricks = ProfitBricksService(username=username,
password=password)
else:
profitbricks = ProfitBricksService(username=username,
password=password,
host_base=api_url)
user_agent = 'profitbricks-sdk-python/%s Ansible/%s' % (sdk_version,
__version__)
profitbricks.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'absent':
try:
(changed) = delete_ipblock(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set IPBlock state: %s' %
to_native(e))
elif state == 'present':
try:
(ipblock_dict) = reserve_ipblock(module, profitbricks)
module.exit_json(**ipblock_dict)
except Exception as e:
module.fail_json(msg='failed to set IPBlocks state: %s' %
to_native(e))
def setUpClass(cls):
cls.resource = resource()
cls.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter
cls.datacenter = cls.client.create_datacenter(datacenter=Datacenter(
**cls.resource['datacenter']))
cls.client.wait_for_completion(cls.datacenter)
cls.image = find_image(cls.client, configuration.IMAGE_NAME)
# Create test volume
vol = Volume(**cls.resource['volume2'])
vol.image = cls.image['id']
cls.volume = cls.client.create_volume(
datacenter_id=cls.datacenter['id'], volume=vol)
cls.client.wait_for_completion(cls.volume)
# Create snapshot1
cls.snapshot1 = cls.client.create_snapshot(
datacenter_id=cls.datacenter['id'],
volume_id=cls.volume['id'],
name=cls.resource['snapshot']['name'],
description=cls.resource['snapshot']['description'])
cls.client.wait_for_completion(cls.snapshot1, timeout=600)
def main():
module = AnsibleModule(argument_spec=dict(
datacenter=dict(),
server=dict(),
name=dict(),
size=dict(type='int', default=10),
bus=dict(choices=['VIRTIO', 'IDE'], default='VIRTIO'),
image=dict(),
image_password=dict(default=None),
ssh_keys=dict(type='list', default=[]),
disk_type=dict(choices=['HDD', 'SSD'], default='HDD'),
licence_type=dict(default='UNKNOWN'),
count=dict(type='int', default=1),
auto_increment=dict(type='bool', default=True),
instance_ids=dict(type='list', default=[]),
subscription_user=dict(),
subscription_password=dict(),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(default='present'),
))
if not module.params.get('subscription_user'):
module.fail_json(msg='subscription_user parameter is required')
if not module.params.get('subscription_password'):
module.fail_json(msg='subscription_password parameter is required')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(username=subscription_user,
password=subscription_password)
state = module.params.get('state')
if state == 'absent':
if not module.params.get('datacenter'):
module.fail_json(
msg=
'datacenter parameter is required for running or stopping machines.'
)
try:
(changed) = delete_volume(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set volume state: %s' % str(e))
elif state == 'present':
if not module.params.get('datacenter'):
module.fail_json(
msg='datacenter parameter is required for new instance')
if not module.params.get('name'):
module.fail_json(msg='name parameter is required for new instance')
try:
(volume_dict_array) = create_volume(module, profitbricks)
module.exit_json(**volume_dict_array)
except Exception as e:
module.fail_json(msg='failed to set volume state: %s' % str(e))
def __init__(self):
''' Main execution path '''
self.data = {}
self.inventory = {} # Ansible Inventory
self.vars = {}
# Defaults, if not found in the settings file
self.cache_path = '.'
self.cache_max_age = 0
# # Read settings, environment variables, and CLI arguments
self.read_cli_args()
self.read_settings()
self.read_environment()
if not getattr(self, 'subscription_password', None) and getattr(
self, 'subscription_password_file', None):
self.subscription_password = read_password_file(
self.subscription_password_file)
self.cache_filename = self.cache_path + "/ansible-profitbricks.cache"
# Verify credentials and create client
if hasattr(self, 'subscription_user') and hasattr(
self, 'subscription_password'):
base_url = API_HOST
if hasattr(self, 'api_url'):
base_url = self.api_url
user_agent = 'profitbricks-sdk-python/%s - Ansible' % (sdk_version)
headers = {'User-Agent': user_agent}
self.client = ProfitBricksService(
username=self.subscription_user,
password=self.subscription_password,
host_base=base_url,
headers=headers)
else:
sys.stderr.write(
'ERROR: ProfitBricks credentials cannot be found.\n')
sys.exit(1)
if self.cache_max_age > 0:
if not self.is_cache_valid() or self.args.refresh:
self.data = self.fetch_resources('all')
self.build_inventory()
self.write_to_cache()
else:
self.load_from_cache()
print_data = self.get_from_local_source()
else:
print_data = self.get_from_api_source()
print(
json.dumps(print_data,
sort_keys=False,
indent=2,
separators=(',', ': ')))
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
self.requests = self.client.list_requests()
self.request = self.requests['items'][0]
def main():
module = AnsibleModule(argument_spec=dict(
datacenter=dict(type='str'),
server=dict(type='str'),
volume=dict(type='str'),
subscription_user=dict(
type='str', default=os.environ.get('PROFITBRICKS_USERNAME')),
subscription_password=dict(
type='str', default=os.environ.get('PROFITBRICKS_PASSWORD')),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(type='str', default='present'),
))
if not HAS_PB_SDK:
module.fail_json(msg='profitbricks required for this module')
if not module.params.get('subscription_user'):
module.fail_json(
msg='subscription_user parameter or ' +
'PROFITBRICKS_USERNAME environment variable is required.')
if not module.params.get('subscription_password'):
module.fail_json(
msg='subscription_password parameter or ' +
'PROFITBRICKS_PASSWORD environment variable is required.')
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required')
if not module.params.get('server'):
module.fail_json(msg='server parameter is required')
if not module.params.get('volume'):
module.fail_json(msg='volume parameter is required')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(username=subscription_user,
password=subscription_password)
user_agent = 'profitbricks-sdk-ruby/%s Ansible/%s' % (sdk_version,
__version__)
profitbricks.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'absent':
try:
(changed) = detach_volume(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set volume_attach state: %s' %
str(e))
elif state == 'present':
try:
attach_volume(module, profitbricks)
module.exit_json()
except Exception as e:
module.fail_json(msg='failed to set volume_attach state: %s' %
str(e))
def main():
module = AnsibleModule(
argument_spec=dict(
datacenter=dict(type='str', required=True),
server=dict(type='str', required=True),
nic=dict(type='str', required=True),
name=dict(type='str', required=True),
protocol=dict(type='str', choices=PROTOCOLS, required=False),
source_mac=dict(type='str', default=None),
source_ip=dict(type='str', default=None),
target_ip=dict(type='str', default=None),
port_range_start=dict(type='int', default=None),
port_range_end=dict(type='int', default=None),
icmp_type=dict(type='int', default=None),
icmp_code=dict(type='int', default=None),
subscription_user=dict(type='str', default=os.environ.get('PROFITBRICKS_USERNAME')),
subscription_password=dict(type='str', default=os.environ.get('PROFITBRICKS_PASSWORD')),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(type='str', default='present'),
)
)
if not HAS_PB_SDK:
module.fail_json(msg='profitbricks required for this module')
if not module.params.get('subscription_user'):
module.fail_json(msg='subscription_user parameter or ' +
'PROFITBRICKS_USERNAME environment variable is required.')
if not module.params.get('subscription_password'):
module.fail_json(msg='subscription_password parameter or ' +
'PROFITBRICKS_PASSWORD environment variable is required.')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(
username=subscription_user,
password=subscription_password)
user_agent = 'profitbricks-sdk-ruby/%s Ansible/%s' % (sdk_version, __version__)
profitbricks.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'absent':
try:
(changed) = delete_firewall_rule(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set firewall rule state: %s' % str(e))
elif state == 'present':
try:
(firewall_rule_dict) = create_firewall_rule(module, profitbricks)
module.exit_json(**firewall_rule_dict)
except Exception as e:
module.fail_json(msg='failed to set firewall rules state: %s' % str(e))
def setUpClass(cls):
cls.resource = resource()
cls.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
cls.datacenter = cls.client.create_datacenter(datacenter=Datacenter(
**cls.resource['datacenter']))
def main():
module = AnsibleModule(
argument_spec=dict(
datacenter=dict(),
server=dict(),
name=dict(default=str(uuid.uuid4()).replace('-','')[:10]),
lan=dict(),
subscription_user=dict(),
subscription_password=dict(no_log=True),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(default='present'),
)
)
if not HAS_PB_SDK:
module.fail_json(msg='profitbricks required for this module')
if not module.params.get('subscription_user'):
module.fail_json(msg='subscription_user parameter is required')
if not module.params.get('subscription_password'):
module.fail_json(msg='subscription_password parameter is required')
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required')
if not module.params.get('server'):
module.fail_json(msg='server parameter is required')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(
username=subscription_user,
password=subscription_password)
state = module.params.get('state')
if state == 'absent':
if not module.params.get('name'):
module.fail_json(msg='name parameter is required')
try:
(changed) = delete_nic(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set nic state: %s' % str(e))
elif state == 'present':
if not module.params.get('lan'):
module.fail_json(msg='lan parameter is required')
try:
(nic_dict) = create_nic(module, profitbricks)
module.exit_json(nics=nic_dict)
except Exception as e:
module.fail_json(msg='failed to set nic state: %s' % str(e))
def setUpClass(cls):
cls.resource = resource()
cls.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Find an Ubuntu image for testing.
for item in cls.client.list_images()['items']:
if (configuration.IMAGE_NAME in item['properties']['name'] and
item['properties']['location'] == configuration.LOCATION):
cls.image = item
def get_conn():
"""
Return a conn object for the passed VM data
"""
return ProfitBricksService(
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
),
)
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
ipblock1 = IPBlock(**self.resource['ipblock'])
ipblock1.size = 2
self.ipblock1 = self.client.reserve_ipblock(ipblock1)
ipblock2 = IPBlock(**self.resource['ipblock'])
self.ipblock2 = self.client.reserve_ipblock(ipblock2)
def main():
module = AnsibleModule(argument_spec=dict(
name=dict(),
description=dict(),
location=dict(choices=LOCATIONS, default='us/las'),
subscription_user=dict(),
subscription_password=dict(),
wait=dict(type='bool', default=True),
wait_timeout=dict(default=600),
state=dict(default='present'),
))
if not HAS_PB_SDK:
module.fail_json(msg='profitbricks required for this module')
if not module.params.get('subscription_user'):
module.fail_json(msg='subscription_user parameter is required')
if not module.params.get('subscription_password'):
module.fail_json(msg='subscription_password parameter is required')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(username=subscription_user,
password=subscription_password)
state = module.params.get('state')
if state == 'absent':
if not module.params.get('name'):
module.fail_json(
msg='name parameter is required deleting a virtual datacenter.'
)
try:
(changed) = remove_datacenter(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set datacenter state: %s' % str(e))
elif state == 'present':
if not module.params.get('name'):
module.fail_json(
msg='name parameter is required for a new datacenter')
if not module.params.get('location'):
module.fail_json(
msg='location parameter is required for a new datacenter')
try:
(datacenter_dict_array) = create_datacenter(module, profitbricks)
module.exit_json(**datacenter_dict_array)
except Exception as e:
module.fail_json(msg='failed to set datacenter state: %s' % str(e))
def setUpClass(cls):
cls.resource = resource()
cls.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
ipblock1 = IPBlock(**cls.resource['ipblock'])
ipblock1.size = 2
cls.ipblock1 = cls.client.reserve_ipblock(ipblock1)
ipblock2 = IPBlock(**cls.resource['ipblock'])
cls.ipblock2 = cls.client.reserve_ipblock(ipblock2)
def get_conn():
'''
Return a conn object for the passed VM data
'''
return ProfitBricksService(
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))
def setUpClass(cls):
cls.resource = resource()
cls.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
cls.datacenter = cls.client.create_datacenter(datacenter=Datacenter(
**cls.resource['datacenter']))
cls.client.wait_for_completion(cls.datacenter)
# Create test LAN.
cls.lan = cls.client.create_lan(datacenter_id=cls.datacenter['id'],
lan=LAN(**cls.resource['lan']))
cls.client.wait_for_completion(cls.lan)
# Create test server.
cls.server = cls.client.create_server(
datacenter_id=cls.datacenter['id'],
server=Server(**cls.resource['server']))
cls.client.wait_for_completion(cls.server)
# Create test NIC1.
nic1 = NIC(**cls.resource['nic'])
nic1.lan = cls.lan['id']
cls.nic1 = cls.client.create_nic(datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
nic=nic1)
cls.client.wait_for_completion(cls.nic1)
# Create test Firewall Rule
fwrule = FirewallRule(**cls.resource['fwrule'])
cls.fwrule = cls.client.create_firewall_rule(
datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
nic_id=cls.nic1['id'],
firewall_rule=fwrule)
cls.client.wait_for_completion(cls.fwrule)
# Create test Firewall Rule 2
fwrule2 = FirewallRule(**cls.resource['fwrule'])
fwrule2.port_range_start = 8080
fwrule2.port_range_end = 8080
fwrule2.name = "8080"
cls.fwrule2 = cls.client.create_firewall_rule(
datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
nic_id=cls.nic1['id'],
firewall_rule=fwrule2)
cls.client.wait_for_completion(cls.fwrule2)
def main():
module = AnsibleModule(
argument_spec=dict(
datacenter=dict(),
server=dict(),
volume=dict(),
subscription_user=dict(),
subscription_password=dict(),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(default='present'),
)
)
if not HAS_PB_SDK:
module.fail_json(msg='profitbricks required for this module')
if not module.params.get('subscription_user'):
module.fail_json(msg='subscription_user parameter is required')
if not module.params.get('subscription_password'):
module.fail_json(msg='subscription_password parameter is required')
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required')
if not module.params.get('server'):
module.fail_json(msg='server parameter is required')
if not module.params.get('volume'):
module.fail_json(msg='volume parameter is required')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(
username=subscription_user,
password=subscription_password)
state = module.params.get('state')
if state == 'absent':
try:
(changed) = detach_volume(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set volume_attach state: %s' % str(e))
elif state == 'present':
try:
attach_volume(module, profitbricks)
module.exit_json()
except Exception as e:
module.fail_json(msg='failed to set volume_attach state: %s' % str(e))
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test volume
volume = Volume(**self.resource['volume'])
self.volume = self.client.create_volume(
datacenter_id=self.datacenter['id'], volume=volume)
self.client.wait_for_completion(self.volume)
# Create test volume1
volume1 = Volume(**self.resource['volume'])
self.volume1 = self.client.create_volume(
datacenter_id=self.datacenter['id'], volume=volume1)
self.client.wait_for_completion(self.volume1)
# Create test snapshot
snapshot = Snapshot(**self.resource['snapshot'])
self.snapshot1 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=snapshot.name,
description=snapshot.description)
self.client.wait_for_completion(self.snapshot1)
# Create test snapshot2
self.snapshot2 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name="python sdk test snapshot",
description="snapshot test description")
self.client.wait_for_completion(self.snapshot2)
def setUpClass(cls):
cls.resource = resource()
cls.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
cls.datacenter = cls.client.create_datacenter(
datacenter=Datacenter(**cls.resource['datacenter']))
cls.client.wait_for_completion(cls.datacenter)
# Create test LAN.
cls.lan = cls.client.create_lan(
datacenter_id=cls.datacenter['id'],
lan=LAN(name=cls.resource['lan']['name'], public=False))
cls.client.wait_for_completion(cls.lan)
# Create test server.
cls.server = cls.client.create_server(
datacenter_id=cls.datacenter['id'],
server=Server(**cls.resource['server']))
cls.client.wait_for_completion(cls.server)
# Create test NIC1.
nic1 = NIC(**cls.resource['nic'])
nic1.lan = cls.lan['id']
cls.ips = ['10.0.0.1']
nic1.ips = cls.ips
cls.nic1 = cls.client.create_nic(
datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
nic=nic1)
cls.client.wait_for_completion(cls.nic1)
# Create test NIC2.
nic2 = NIC(**cls.resource['nic'])
nic2.lan = cls.lan['id']
cls.nic2 = cls.client.create_nic(
datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
nic=nic2)
cls.client.wait_for_completion(cls.nic2)
def main():
module = AnsibleModule(argument_spec=dict(
datacenter=dict(required=True),
server=dict(required=True),
name=dict(),
lan=dict(),
subscription_user=dict(required=True),
subscription_password=dict(required=True, no_log=True),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(default='present'),
),
required_if=(
('state', 'absent', ['name']),
('state', 'present', ['lan']),
))
if not HAS_PB_SDK:
module.fail_json(msg='profitbricks required for this module')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(username=subscription_user,
password=subscription_password)
state = module.params.get('state')
if state == 'absent':
try:
(changed) = delete_nic(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set nic state: %s' % str(e))
elif state == 'present':
try:
(nic_dict) = create_nic(module, profitbricks)
module.exit_json(nics=nic_dict) # @FIXME changed not calculated?
except Exception as e:
module.fail_json(msg='failed to set nic state: %s' % str(e))
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test LAN.
self.lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
self.client.wait_for_completion(self.lan)
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
self.client.wait_for_completion(self.server)
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
self.client.wait_for_completion(self.nic1)
# Create test NIC2.
nic2 = NIC(**self.resource['nic'])
nic2.lan = self.lan['id']
self.nic2 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic2)
self.client.wait_for_completion(self.nic2)
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Create volume
"""
from profitbricks.client import ProfitBricksService, Volume
datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022'
client = ProfitBricksService(
username='******', password='******')
i = Volume(
name='Explicitly created volume',
size=56,
image='<IMAGE/SNAPSHOT-ID>',
bus='VIRTIO')
response = client.create_volume(
datacenter_id=datacenter_id, volume=i)
"""Create snapshot
"""
from profitbricks.client import ProfitBricksService # noqa
def main():
module = AnsibleModule(argument_spec=dict(
datacenter=dict(),
name=dict(),
image=dict(),
cores=dict(type='int', default=2),
ram=dict(type='int', default=2048),
cpu_family=dict(choices=['AMD_OPTERON', 'INTEL_XEON'],
default='AMD_OPTERON'),
volume_size=dict(type='int', default=10),
disk_type=dict(choices=['HDD', 'SSD'], default='HDD'),
image_password=dict(default=None, no_log=True),
ssh_keys=dict(type='list', elements='str', default=[], no_log=False),
bus=dict(choices=['VIRTIO', 'IDE'], default='VIRTIO'),
lan=dict(type='int', default=1),
count=dict(type='int', default=1),
auto_increment=dict(type='bool', default=True),
instance_ids=dict(type='list', elements='str', default=[]),
subscription_user=dict(),
subscription_password=dict(no_log=True),
location=dict(choices=LOCATIONS, default='us/las'),
assign_public_ip=dict(type='bool', default=False),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
remove_boot_volume=dict(type='bool', default=True),
state=dict(default='present'),
))
if not HAS_PB_SDK:
module.fail_json(msg='profitbricks required for this module')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(username=subscription_user,
password=subscription_password)
state = module.params.get('state')
if state == 'absent':
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required ' +
'for running or stopping machines.')
try:
(changed) = remove_virtual_machine(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set instance state: %s' %
to_native(e),
exception=traceback.format_exc())
elif state in ('running', 'stopped'):
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required for ' +
'running or stopping machines.')
try:
(changed) = startstop_machine(module, profitbricks, state)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set instance state: %s' %
to_native(e),
exception=traceback.format_exc())
elif state == 'present':
if not module.params.get('name'):
module.fail_json(msg='name parameter is required for new instance')
if not module.params.get('image'):
module.fail_json(
msg='image parameter is required for new instance')
if not module.params.get('subscription_user'):
module.fail_json(msg='subscription_user parameter is ' +
'required for new instance')
if not module.params.get('subscription_password'):
module.fail_json(msg='subscription_password parameter is ' +
'required for new instance')
try:
(machine_dict_array) = create_virtual_machine(module, profitbricks)
module.exit_json(**machine_dict_array)
except Exception as e:
module.fail_json(msg='failed to set instance state: %s' %
to_native(e),
exception=traceback.format_exc())
def main():
module = AnsibleModule(
argument_spec=dict(
datacenter=dict(type='str'),
server=dict(type='str'),
name=dict(type='str'),
size=dict(type='int', default=10),
image=dict(type='str'),
image_password=dict(type='str', default=None),
ssh_keys=dict(type='list', default=[]),
bus=dict(type='str', choices=BUS_TYPES, default='VIRTIO'),
disk_type=dict(type='str', choices=DISK_TYPES, default='HDD'),
licence_type=dict(type='str', choices=LICENCE_TYPES, default='UNKNOWN'),
availability_zone=dict(type='str', choices=AVAILABILITY_ZONES, default=None),
count=dict(type='int', default=1),
auto_increment=dict(type='bool', default=True),
instance_ids=dict(type='list', default=[]),
subscription_user=dict(type='str', default=os.environ.get('PROFITBRICKS_USERNAME')),
subscription_password=dict(type='str', default=os.environ.get('PROFITBRICKS_PASSWORD')),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(type='str', default='present'),
)
)
if not module.params.get('subscription_user'):
module.fail_json(msg='subscription_user parameter or ' +
'PROFITBRICKS_USERNAME environment variable is required.')
if not module.params.get('subscription_password'):
module.fail_json(msg='subscription_password parameter or ' +
'PROFITBRICKS_PASSWORD environment variable is required.')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
profitbricks = ProfitBricksService(
username=subscription_user,
password=subscription_password)
user_agent = 'profitbricks-sdk-ruby/%s Ansible/%s' % (sdk_version, __version__)
profitbricks.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'absent':
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required for running or stopping machines.')
try:
(changed) = delete_volume(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set volume state: %s' % str(e))
elif state == 'present':
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required for new instance')
if not module.params.get('name'):
module.fail_json(msg='name parameter is required for new instance')
try:
(volume_dict_array) = create_volume(module, profitbricks)
module.exit_json(**volume_dict_array)
except Exception as e:
module.fail_json(msg='failed to set volume state: %s' % str(e))
def main(argv=None): # IGNORE:C0111
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version,
program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
program_license = '''%s
Created by J.Buchhammer on %s.
Copyright 2016 ProfitBricks GmbH. All rights reserved.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-u',
'--user',
dest='user',
required=True,
help='the login name')
parser.add_argument('-p',
'--password',
dest='password',
help='the login password')
parser.add_argument('-d',
'--datacenter',
'--datacenterid',
dest='datacenterid',
nargs='?',
const='*',
help='show server/storage of datacenter(s)')
parser.add_argument('-i',
'--image',
dest='show_images',
action="store_true",
help='show images and snapshots')
parser.add_argument('-b',
'--ipblock',
dest='show_ipblocks',
action="store_true",
help='show reserved IP blocks')
parser.add_argument('-n',
'--network',
dest='show_networks',
action="store_true",
help='show network assignments')
# parser.add_argument(
# '-r', '--request', dest='show_requests', action="store_true",
# help='show requests')
parser.add_argument("-v",
"--verbose",
dest="verbose",
action="count",
default=0,
help="set verbosity level [default: %(default)s]")
parser.add_argument('-V',
'--version',
action='version',
version=program_version_message)
# Process arguments
args = parser.parse_args()
global verbose
verbose = args.verbose # this is a global to be used in methods
user = args.user
password = args.password
datacenterid = args.datacenterid
print("Welcome to PB-API %s\n" % user)
if password is None:
password = getpass()
if verbose > 0:
print("Verbose mode on")
print("using python ", sys.version_info)
pbclient = ProfitBricksService(user, password)
if datacenterid is not None:
datacenters = {}
if datacenterid == '*':
# the default depth=1 is sufficient, higher values don't provide more details
datacenters = pbclient.list_datacenters()
else:
datacenters['items'] = []
datacenters['items'] = [
pbclient.get_datacenter(datacenterid, 1)
]
if verbose > 1:
print(pp(datacenters))
print("retrieved %i datacenters " % len(datacenters['items']))
# dump inventory to file
with open("pb_datacenter_inventory.csv", 'w') as csvfile:
csvwriter = csv.writer(csvfile,
delimiter=';',
lineterminator='\n')
csvwriter.writerow([
'DCID', 'DCName', 'Loc', 'RscType', 'RscID', 'RscName',
'State', 'LicType', 'Cores', 'RAM', '# NICs', '# Volumes',
'(Total) Storage', 'Connected to', 'Created', 'Modified'
])
for dc in datacenters['items']:
try:
dc_inv = get_dc_inventory(pbclient, dc)
if verbose:
print("DC %s has %i inventory entries" %
(dc['id'], len(dc_inv)))
for row in dc_inv:
csvwriter.writerow(row)
except Exception:
traceback.print_exc()
exit(2)
# end for(datacenters)
if args.show_images:
with open("pb_datacenter_images.csv", 'w') as csvfile:
csvwriter = csv.writer(csvfile,
delimiter=';',
lineterminator='\n')
csvwriter.writerow([
'Visibility', 'Loc', 'RscType', 'SubType', 'RscID',
'RscName', 'State', 'LicType', 'Size', 'Created',
'Modified'
])
img_inv = get_images(pbclient)
for row in img_inv:
csvwriter.writerow(row)
snap_inv = get_snapshots(pbclient)
for row in snap_inv:
csvwriter.writerow(row)
if args.show_ipblocks:
with open("pb_datacenter_ipblocks.csv", 'w') as csvfile:
csvwriter = csv.writer(csvfile,
delimiter=';',
lineterminator='\n')
csvwriter.writerow([
'Loc', 'RscType', 'RscID', 'State', 'Size', 'IP addresses'
])
ipblocks = get_ipblocks(pbclient)
for row in ipblocks:
csvwriter.writerow(row)
# file is automatically closed after with block
if args.show_networks:
# the default depth=1 is sufficient, higher values don't provide more details
datacenters = pbclient.list_datacenters()
print("retrieved %i datacenters " % len(datacenters['items']))
with open("pb_datacenter_networks.csv", 'w') as csvfile:
csvwriter = csv.writer(csvfile,
delimiter=';',
lineterminator='\n')
csvwriter.writerow([
'DCID', 'DCName', 'Loc', 'LAN ID', 'LAN name', 'public',
'State', '# NICs', 'NIC ID', 'MAC address', 'DHCP',
'IP(s)', 'NIC name', 'Firewall', 'Connected to', 'ID',
'Name'
])
for dc in datacenters['items']:
try:
dc_net = get_dc_network(pbclient, dc)
if verbose:
print("DC %s has %i network entries" %
(dc['id'], len(dc_net)))
for row in dc_net:
csvwriter.writerow(row)
except Exception:
traceback.print_exc()
exit(2)
# end for(datacenters)
# just for fun:
# if args.show_requests:
# get_requests(pbclient)
print("%s finished w/o errors" % program_name)
return 0
except KeyboardInterrupt:
# handle keyboard interrupt
return 0
except Exception:
traceback.print_exc()
sys.stderr.write("\n" + program_name + ": for help use --help\n")
return 2
def main(argv=None):
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version,
program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
program_license = '''%s
Created by Jürgen Buchhammer on %s.
Copyright 2016 ProfitBricks GmbH. All rights reserved.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-u', '--user', dest='user', help='the login name')
parser.add_argument('-p',
'--password',
dest='password',
help='the login password')
parser.add_argument('-L',
'--Login',
dest='loginfile',
default=None,
help='the login file to use')
parser.add_argument('-t',
'--type',
dest='metatype',
default="OVF",
help='type of VM meta data')
parser.add_argument('-m',
'--metadata',
dest='metafile',
required=True,
default=None,
help='meta data file')
parser.add_argument('-d',
'--datacenterid',
dest='datacenterid',
default=None,
help='datacenter of the new server')
parser.add_argument('-D',
'--DCname',
dest='dcname',
default=None,
help='new datacenter name')
parser.add_argument('-l',
'--location',
dest='location',
default=None,
help='location for new datacenter')
parser.add_argument('-v',
'--verbose',
dest="verbose",
action="count",
default=0,
help="set verbosity level [default: %(default)s]")
parser.add_argument('-V',
'--version',
action='version',
version=program_version_message)
# Process arguments
args = parser.parse_args()
global verbose
verbose = args.verbose
if verbose > 0:
print("Verbose mode on")
print("start {} with args {}".format(program_name, str(args)))
(user, password) = getLogin(args.loginfile, args.user, args.password)
if user is None or password is None:
raise ValueError("user or password resolved to None")
pbclient = ProfitBricksService(user, password)
if args.metatype == 'OVF':
metadata = OFVData(args.metafile)
metadata.parse()
else:
sys.stderr.write("Metadata type '{}' is not supported".format(
args.metatype))
return 1
# we need the DC first to have the location defined
dc_id = None
if args.datacenterid is None:
if args.dcname is None or args.location is None:
sys.stderr.write(
"Either '-d <id>' or '-D <name> -l <loc>' must be specified"
)
return 1
# else: we will create the DC later after parsing the meta data
else:
dc_id = args.datacenterid
if dc_id is None:
location = args.location
dc = Datacenter(name=args.dcname,
location=location,
description="created by pb_importVM")
print("create new DC {}".format(str(dc)))
response = pbclient.create_datacenter(dc)
dc_id = response['id']
result = wait_for_request(pbclient, response['requestId'])
print("wait loop returned {}".format(result))
else:
dc = pbclient.get_datacenter(dc_id)
location = dc['properties']['location']
print("use existing DC {} in location {}".format(
dc['properties']['name'], location))
# check if images exist
for disk in metadata.disks:
disk_name = disk['file']
images = get_disk_image_by_name(pbclient, location, disk_name)
if len(images) == 0:
raise ValueError(
"No HDD image with name '{}' found in location {}".format(
disk_name, location))
if len(images) > 1:
raise ValueError(
"Ambigous image name '{}' in location {}".format(
disk_name, location))
disk['image'] = images[0]['id']
# now we're ready to create the VM
# Server
server = Server(name=metadata.name,
cores=metadata.cpus,
ram=metadata.ram)
print("create server {}".format(str(Server)))
response = pbclient.create_server(dc_id, server)
srv_id = response['id']
result = wait_for_request(pbclient, response['requestId'])
print("wait loop returned {}".format(str(result)))
# NICs (note that createing LANs may be implicit)
for nic in metadata.nics:
dcnic = NIC(name=nic['nic'], lan=nic['lanid'])
print("create NIC {}".format(str(dcnic)))
response = pbclient.create_nic(dc_id, srv_id, dcnic)
nic_id = response['id']
result = wait_for_request(pbclient, response['requestId'])
print("wait loop returned {}".format(str(result)))
response = pbclient.get_nic(dc_id, srv_id, nic_id, 2)
mac = response['properties']['mac']
print("dcnic has MAC {} for {}".format(mac, nic_id))
# end for(nics)
# Volumes (we use the image name as volume name too
requests = []
for disk in metadata.disks:
dcvol = Volume(name=disk['file'],
size=disk['capacity'],
image=disk['image'],
licence_type=metadata.licenseType)
print("create Volume {}".format(str(dcvol)))
response = pbclient.create_volume(dc_id, dcvol)
requests.append(response['requestId'])
disk['volume_id'] = response['id']
# end for(disks)
if len(requests) != 0:
result = wait_for_requests(pbclient,
requests,
initial_wait=10,
scaleup=15)
print("wait loop returned {}".format(str(result)))
for disk in metadata.disks:
print("attach volume {}".format(disk))
response = pbclient.attach_volume(dc_id, srv_id, disk['volume_id'])
result = wait_for_request(pbclient, response['requestId'])
print("wait loop returned {}".format(str(result)))
# end for(disks)
print("import of VM succesfully finished")
return 0
except KeyboardInterrupt:
# handle keyboard interrupt
return 0
except Exception:
traceback.print_exc()
sys.stderr.write("\n" + program_name + ": for help use --help\n")
return 2
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from profitbricks.client import ProfitBricksService, Group, User
# Instantiate ProfitBricks connection
client = ProfitBricksService(username=os.getenv('PROFITBRICKS_USERNAME'),
password=os.getenv('PROFITBRICKS_PASSWORD'))
"""Create a group
"""
request = Group(name='demo-group',
create_datacenter=True,
create_snapshot=False,
reserve_ip=True,
access_activity_log=False)
group = client.create_group(request)
"""List groups
"""
groups = client.list_groups()
"""Create a user
"""
user_request = User(firstname='John',
def main():
module = AnsibleModule(argument_spec=dict(
datacenter=dict(type='str'),
name=dict(type='str'),
image=dict(type='str'),
cores=dict(type='int', default=2),
ram=dict(type='int', default=2048),
cpu_family=dict(
type='str', choices=CPU_FAMILIES, default='AMD_OPTERON'),
volume_size=dict(type='int', default=10),
disk_type=dict(type='str', choices=DISK_TYPES, default='HDD'),
availability_zone=dict(
type='str', choices=AVAILABILITY_ZONES, default='AUTO'),
volume_availability_zone=dict(
type='str', choices=AVAILABILITY_ZONES, default=None),
image_password=dict(type='str', default=None),
ssh_keys=dict(type='list', default=[]),
bus=dict(type='str', choices=BUS_TYPES, default='VIRTIO'),
lan=dict(type='int', default=1),
nat=dict(type='bool', default=None),
count=dict(type='int', default=1),
auto_increment=dict(type='bool', default=True),
instance_ids=dict(type='list', default=[]),
subscription_user=dict(
type='str', default=os.environ.get('PROFITBRICKS_USERNAME')),
subscription_password=dict(
type='str', default=os.environ.get('PROFITBRICKS_PASSWORD')),
location=dict(type='str', choices=LOCATIONS, default='us/las'),
assign_public_ip=dict(type='bool', default=False),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
remove_boot_volume=dict(type='bool', default=True),
state=dict(type='str', default='present'),
))
if not HAS_PB_SDK:
module.fail_json(msg='profitbricks required for this module')
if not module.params.get('subscription_user'):
module.fail_json(
msg='subscription_user parameter or ' +
'PROFITBRICKS_USERNAME environment variable is required.')
if not module.params.get('subscription_password'):
module.fail_json(
msg='subscription_password parameter or ' +
'PROFITBRICKS_PASSWORD environment variable is required.')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
profitbricks = ProfitBricksService(username=subscription_user,
password=subscription_password)
user_agent = 'profitbricks-sdk-ruby/%s Ansible/%s' % (sdk_version,
__version__)
profitbricks.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'absent':
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required ' +
'for running or stopping machines.')
try:
(changed) = remove_virtual_machine(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set instance state: %s' % str(e))
elif state in ('running', 'stopped'):
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required for ' +
'running or stopping machines.')
try:
(changed) = startstop_machine(module, profitbricks, state)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set instance state: %s' % str(e))
elif state == 'present':
if not module.params.get('name'):
module.fail_json(msg='name parameter is required for new instance')
datacenter_list = profitbricks.list_datacenters()
datacenter_id = _get_datacenter_id(datacenter_list,
module.params.get('datacenter'))
server_list = profitbricks.list_servers(datacenter_id)
if not _get_server_id(server_list, module.params.get('name')):
# create
if not module.params.get('image'):
module.fail_json(
msg='image parameter is required for new instance')
try:
(machine_dict_array) = create_virtual_machine(
module, profitbricks)
module.exit_json(**machine_dict_array)
except Exception as e:
module.fail_json(msg='failed to set instance state: %s' %
str(e))
else:
# update
try:
(machine_dict_array) = update_virtual_machine(
module, profitbricks)
module.exit_json(**machine_dict_array)
except Exception as e:
module.fail_json(msg='failed to set instance state: %s' %
str(e))
def main():
module = AnsibleModule(argument_spec=dict(
datacenter=dict(type='str'),
server=dict(type='str'),
name=dict(type='str', default=str(uuid4()).replace('-', '')[:10]),
lan=dict(type='int', default=None),
dhcp=dict(type='bool', default=None),
nat=dict(type='bool', default=None),
firewall_active=dict(type='bool', default=None),
ips=dict(type='list', default=None),
api_url=dict(type='str', default=None),
username=dict(type='str',
required=True,
aliases=['subscription_user'],
fallback=(env_fallback, ['PROFITBRICKS_USERNAME'])),
password=dict(type='str',
required=True,
aliases=['subscription_password'],
fallback=(env_fallback, ['PROFITBRICKS_PASSWORD']),
no_log=True),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(type='str', default='present'),
),
supports_check_mode=True)
if not HAS_PB_SDK:
module.fail_json(
msg=
'profitbricks is required for this module, run `pip install profitbricks`'
)
if not module.params.get('datacenter'):
module.fail_json(msg='datacenter parameter is required')
if not module.params.get('server'):
module.fail_json(msg='server parameter is required')
username = module.params.get('username')
password = module.params.get('password')
api_url = module.params.get('api_url')
if not api_url:
profitbricks = ProfitBricksService(username=username,
password=password)
else:
profitbricks = ProfitBricksService(username=username,
password=password,
host_base=api_url)
user_agent = 'profitbricks-sdk-python/%s Ansible/%s' % (sdk_version,
__version__)
profitbricks.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'absent':
if not module.params.get('name'):
module.fail_json(msg='name parameter is required')
try:
(changed) = delete_nic(module, profitbricks)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set nic state: %s' % to_native(e))
elif state == 'present':
if not module.params.get('lan'):
module.fail_json(msg='lan parameter is required')
try:
(nic_dict) = create_nic(module, profitbricks)
module.exit_json(**nic_dict)
except Exception as e:
module.fail_json(msg='failed to set nic state: %s' % to_native(e))
elif state == 'update':
try:
(nic_dict) = update_nic(module, profitbricks)
module.exit_json(**nic_dict)
except Exception as e:
module.fail_json(msg='failed to update nic: %s' % to_native(e))
def main(argv=None):
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version,
program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
program_license = '''%s
Created by J. Buchhammer on %s.
Copyright 2016 ProfitBricks GmbH. All rights reserved.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-u', '--user', dest='user', help='the login name')
parser.add_argument('-p',
'--password',
dest='password',
help='the login password')
parser.add_argument('-L',
'--Login',
dest='loginfile',
default=None,
help='the login file to use')
parser.add_argument('-d',
'--datacenterid',
dest='dc_id',
required=True,
default=None,
help='datacenter of the server')
parser.add_argument('-s',
'--serverid',
dest='serverid',
default=None,
help='ID of the server')
parser.add_argument('-n',
'--name',
dest='servername',
default=None,
help='name of the server')
parser.add_argument('-C',
'--command',
dest='command',
default=None,
help='remote shell command to use for shutdown')
parser.add_argument('-v',
'--verbose',
dest="verbose",
action="count",
help="set verbosity level [default: %(default)s]")
parser.add_argument('-V',
'--version',
action='version',
version=program_version_message)
# Process arguments
args = parser.parse_args()
global verbose
verbose = args.verbose
dc_id = args.dc_id
if verbose > 0:
print("Verbose mode on")
if args.serverid is None and args.servername is None:
parser.error("one of 'serverid' or 'name' must be specified")
(user, password) = getLogin(args.loginfile, args.user, args.password)
if user is None or password is None:
raise ValueError("user or password resolved to None")
pbclient = ProfitBricksService(user, password)
server = getServerStates(pbclient, dc_id, args.serverid,
args.servername)
if server is None:
raise Exception(1, "specified server not found")
print("using server {}(id={}) in state {}, {}".format(
server['name'], server['id'], server['state'], server['vmstate']))
# ! stop/start/reboot_server() simply return 'True' !
# this implies, that there's NO response nor requestId to track!
if server['vmstate'] == 'SHUTOFF':
print("VM is already shut off")
else:
if args.command is None:
print("no command specified for shutdown of VM")
else:
print("executing {}".format(args.command))
cmdrc = call(args.command, shell=True)
print("executing {} returned {}".format(args.command, cmdrc))
server = wait_for_server(pbclient,
dc_id,
server['id'],
indicator='vmstate',
state='SHUTOFF',
timeout=300)
# first we have to delete all attached volumes
volumes = pbclient.get_attached_volumes(dc_id, server['id'], 0)
for vol in volumes['items']:
print("deleting volume {} of server {}".format(
vol['id'], server['name']))
pbclient.delete_volume(dc_id, vol['id'])
pbclient.delete_server(dc_id, server['id'])
wait_for_datacenter(pbclient, dc_id)
except KeyboardInterrupt:
# handle keyboard interrupt #
pass
except Exception:
traceback.print_exc()
sys.stderr.write("\n" + program_name + ": for help use --help\n")
return 2
return 0
