idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
242,900 | def create ( cls , name , datacenter , subnet = None , gateway = None , background = False ) : if not background and not cls . intty ( ) : background = True datacenter_id_ = int ( Datacenter . usable_id ( datacenter ) ) vlan_params = { 'name' : name , 'datacenter_id' : datacenter_id_ , } if subnet : vlan_params [ 'subnet' ] = subnet if gateway : vlan_params [ 'gateway' ] = gateway result = cls . call ( 'hosting.vlan.create' , vlan_params ) if not background : # interactive mode, run a progress bar cls . echo ( 'Creating your vlan.' ) cls . display_progress ( result ) cls . echo ( 'Your vlan %s has been created.' % name ) return result | Create a new vlan . | 199 | 6 |
242,901 | def update ( cls , id , params ) : cls . echo ( 'Updating your vlan.' ) result = cls . call ( 'hosting.vlan.update' , cls . usable_id ( id ) , params ) return result | Update an existing vlan . | 55 | 6 |
242,902 | def from_name ( cls , name ) : result = cls . list ( ) vlans = { } for vlan in result : vlans [ vlan [ 'name' ] ] = vlan [ 'id' ] return vlans . get ( name ) | Retrieve vlan id associated to a name . | 60 | 10 |
242,903 | def usable_id ( cls , id ) : try : qry_id = int ( id ) except Exception : qry_id = None if not qry_id : msg = 'unknown identifier %s' % id cls . error ( msg ) return qry_id | Retrieve id from input which can be num or id . | 60 | 12 |
242,904 | def _attach ( cls , iface_id , vm_id ) : oper = cls . call ( 'hosting.vm.iface_attach' , vm_id , iface_id ) return oper | Attach an iface to a vm . | 47 | 8 |
242,905 | def create ( cls , ip_version , datacenter , bandwidth , vlan , vm , ip , background ) : if not background and not cls . intty ( ) : background = True datacenter_id_ = int ( Datacenter . usable_id ( datacenter ) ) iface_params = { 'ip_version' : ip_version , 'datacenter_id' : datacenter_id_ , 'bandwidth' : bandwidth , } if vlan : iface_params [ 'vlan' ] = Vlan . usable_id ( vlan ) if ip : iface_params [ 'ip' ] = ip result = cls . call ( 'hosting.iface.create' , iface_params ) if background and not vm : return result # interactive mode, run a progress bar cls . echo ( 'Creating your iface.' ) cls . display_progress ( result ) iface_info = cls . _info ( result [ 'iface_id' ] ) cls . echo ( 'Your iface has been created with the following IP ' 'addresses:' ) for _ip in iface_info [ 'ips' ] : cls . echo ( 'ip%d:\t%s' % ( _ip [ 'version' ] , _ip [ 'ip' ] ) ) if not vm : return result vm_id = Iaas . usable_id ( vm ) result = cls . _attach ( result [ 'iface_id' ] , vm_id ) if background : return result cls . echo ( 'Attaching your iface.' ) cls . display_progress ( result ) return result | Create a new iface | 362 | 5 |
242,906 | def _detach ( cls , iface_id ) : iface = cls . _info ( iface_id ) opers = [ ] vm_id = iface . get ( 'vm_id' ) if vm_id : cls . echo ( 'The iface is still attached to the vm %s.' % vm_id ) cls . echo ( 'Will detach it.' ) opers . append ( cls . call ( 'hosting.vm.iface_detach' , vm_id , iface_id ) ) return opers | Detach an iface from a vm . | 123 | 9 |
242,907 | def update ( cls , id , bandwidth , vm , background ) : if not background and not cls . intty ( ) : background = True iface_params = { } iface_id = cls . usable_id ( id ) if bandwidth : iface_params [ 'bandwidth' ] = bandwidth if iface_params : result = cls . call ( 'hosting.iface.update' , iface_id , iface_params ) if background : return result # interactive mode, run a progress bar cls . echo ( 'Updating your iface %s.' % id ) cls . display_progress ( result ) if not vm : return vm_id = Iaas . usable_id ( vm ) opers = cls . _detach ( iface_id ) if opers : cls . echo ( 'Detaching iface.' ) cls . display_progress ( opers ) result = cls . _attach ( iface_id , vm_id ) if background : return result cls . echo ( 'Attaching your iface.' ) cls . display_progress ( result ) | Update this iface . | 243 | 5 |
242,908 | def get_destinations ( cls , domain , source ) : forwards = cls . list ( domain , { 'items_per_page' : 500 } ) for fwd in forwards : if fwd [ 'source' ] == source : return fwd [ 'destinations' ] return [ ] | Retrieve forward information . | 64 | 5 |
242,909 | def update ( cls , domain , source , dest_add , dest_del ) : result = None if dest_add or dest_del : current_destinations = cls . get_destinations ( domain , source ) fwds = current_destinations [ : ] if dest_add : for dest in dest_add : if dest not in fwds : fwds . append ( dest ) if dest_del : for dest in dest_del : if dest in fwds : fwds . remove ( dest ) if ( ( len ( current_destinations ) != len ( fwds ) ) or ( current_destinations != fwds ) ) : cls . echo ( 'Updating mail forward %s@%s' % ( source , domain ) ) options = { 'destinations' : fwds } result = cls . call ( 'domain.forward.update' , domain , source , options ) return result | Update a domain mail forward destinations . | 203 | 7 |
242,910 | def list ( gandi , domain , limit ) : options = { 'items_per_page' : limit } mailboxes = gandi . mail . list ( domain , options ) output_list ( gandi , [ mbox [ 'login' ] for mbox in mailboxes ] ) return mailboxes | List mailboxes created on a domain . | 64 | 8 |
242,911 | def info ( gandi , email ) : login , domain = email output_keys = [ 'login' , 'aliases' , 'fallback' , 'quota' , 'responder' ] mailbox = gandi . mail . info ( domain , login ) output_mailbox ( gandi , mailbox , output_keys ) return mailbox | Display information about a mailbox . | 72 | 6 |
242,912 | def delete ( gandi , email , force ) : login , domain = email if not force : proceed = click . confirm ( 'Are you sure to delete the ' 'mailbox %s@%s ?' % ( login , domain ) ) if not proceed : return result = gandi . mail . delete ( domain , login ) return result | Delete a mailbox . | 71 | 4 |
242,913 | def from_name ( cls , name ) : disks = cls . list ( { 'name' : name } ) if len ( disks ) == 1 : return disks [ 0 ] [ 'id' ] elif not disks : return raise DuplicateResults ( 'disk name %s is ambiguous.' % name ) | Retrieve a disk id associated to a name . | 66 | 10 |
242,914 | def list_create ( cls , datacenter = None , label = None ) : options = { 'items_per_page' : DISK_MAXLIST } if datacenter : datacenter_id = int ( Datacenter . usable_id ( datacenter ) ) options [ 'datacenter_id' ] = datacenter_id # implement a filter by label as API doesn't handle it images = cls . safe_call ( 'hosting.disk.list' , options ) if not label : return images return [ img for img in images if label . lower ( ) in img [ 'name' ] . lower ( ) ] | List available disks for vm creation . | 141 | 7 |
242,915 | def disk_param ( name , size , snapshot_profile , cmdline = None , kernel = None ) : disk_params = { } if cmdline : disk_params [ 'cmdline' ] = cmdline if kernel : disk_params [ 'kernel' ] = kernel if name : disk_params [ 'name' ] = name if snapshot_profile is not None : disk_params [ 'snapshot_profile' ] = snapshot_profile if size : disk_params [ 'size' ] = size return disk_params | Return disk parameter structure . | 111 | 5 |
242,916 | def update ( cls , resource , name , size , snapshot_profile , background , cmdline = None , kernel = None ) : if isinstance ( size , tuple ) : prefix , size = size if prefix == '+' : disk_info = cls . info ( resource ) current_size = disk_info [ 'size' ] size = current_size + size disk_params = cls . disk_param ( name , size , snapshot_profile , cmdline , kernel ) result = cls . call ( 'hosting.disk.update' , cls . usable_id ( resource ) , disk_params ) if background : return result # interactive mode, run a progress bar cls . echo ( 'Updating your disk.' ) cls . display_progress ( result ) | Update this disk . | 167 | 4 |
242,917 | def _detach ( cls , disk_id ) : disk = cls . _info ( disk_id ) opers = [ ] if disk . get ( 'vms_id' ) : for vm_id in disk [ 'vms_id' ] : cls . echo ( 'The disk is still attached to the vm %s.' % vm_id ) cls . echo ( 'Will detach it.' ) opers . append ( cls . call ( 'hosting.vm.disk_detach' , vm_id , disk_id ) ) return opers | Detach a disk from a vm . | 125 | 8 |
242,918 | def delete ( cls , resources , background = False ) : if not isinstance ( resources , ( list , tuple ) ) : resources = [ resources ] resources = [ cls . usable_id ( item ) for item in resources ] opers = [ ] for disk_id in resources : opers . extend ( cls . _detach ( disk_id ) ) if opers : cls . echo ( 'Detaching your disk(s).' ) cls . display_progress ( opers ) opers = [ ] for disk_id in resources : oper = cls . call ( 'hosting.disk.delete' , disk_id ) opers . append ( oper ) if background : return opers cls . echo ( 'Deleting your disk.' ) cls . display_progress ( opers ) return opers | Delete this disk . | 178 | 4 |
242,919 | def _attach ( cls , disk_id , vm_id , options = None ) : options = options or { } oper = cls . call ( 'hosting.vm.disk_attach' , vm_id , disk_id , options ) return oper | Attach a disk to a vm . | 56 | 7 |
242,920 | def create ( cls , name , vm , size , snapshotprofile , datacenter , source , disk_type = 'data' , background = False ) : if isinstance ( size , tuple ) : prefix , size = size if source : size = None disk_params = cls . disk_param ( name , size , snapshotprofile ) disk_params [ 'datacenter_id' ] = int ( Datacenter . usable_id ( datacenter ) ) disk_params [ 'type' ] = disk_type if source : disk_id = int ( Image . usable_id ( source , disk_params [ 'datacenter_id' ] ) ) result = cls . call ( 'hosting.disk.create_from' , disk_params , disk_id ) else : result = cls . call ( 'hosting.disk.create' , disk_params ) if background and not vm : return result # interactive mode, run a progress bar cls . echo ( 'Creating your disk.' ) cls . display_progress ( result ) if not vm : return vm_id = Iaas . usable_id ( vm ) result = cls . _attach ( result [ 'disk_id' ] , vm_id ) if background : return result cls . echo ( 'Attaching your disk.' ) cls . display_progress ( result ) | Create a disk and attach it to a vm . | 293 | 10 |
242,921 | def compatcallback ( f ) : if getattr ( click , '__version__' , '0.0' ) >= '2.0' : return f return update_wrapper ( lambda ctx , value : f ( ctx , None , value ) , f ) | Compatibility callback decorator for older click version . | 57 | 10 |
242,922 | def list_sub_commmands ( self , cmd_name , cmd ) : ret = { } if isinstance ( cmd , click . core . Group ) : for sub_cmd_name in cmd . commands : sub_cmd = cmd . commands [ sub_cmd_name ] sub = self . list_sub_commmands ( sub_cmd_name , sub_cmd ) if sub : if isinstance ( sub , dict ) : for n , c in sub . items ( ) : ret [ '%s %s' % ( cmd_name , n ) ] = c else : ret [ '%s %s' % ( cmd_name , sub [ 0 ] ) ] = sub [ 1 ] elif isinstance ( cmd , click . core . Command ) : return ( cmd . name , cmd ) return ret | Return all commands for a group | 175 | 6 |
242,923 | def load_commands ( self ) : command_folder = os . path . join ( os . path . dirname ( __file__ ) , '..' , 'commands' ) command_dirs = { 'gandi.cli' : command_folder } if 'GANDICLI_PATH' in os . environ : for _path in os . environ . get ( 'GANDICLI_PATH' ) . split ( ':' ) : # remove trailing separator if any path = _path . rstrip ( os . sep ) command_dirs [ os . path . basename ( path ) ] = os . path . join ( path , 'commands' ) for module_basename , dir in list ( command_dirs . items ( ) ) : for filename in sorted ( os . listdir ( dir ) ) : if filename . endswith ( '.py' ) and '__init__' not in filename : submod = filename [ : - 3 ] module_name = module_basename + '.commands.' + submod __import__ ( module_name , fromlist = [ module_name ] ) | Load cli commands from submodules . | 244 | 8 |
242,924 | def invoke ( self , ctx ) : ctx . obj = GandiContextHelper ( verbose = ctx . obj [ 'verbose' ] ) click . Group . invoke ( self , ctx ) | Invoke command in context . | 44 | 6 |
242,925 | def from_name ( cls , name ) : sshkeys = cls . list ( { 'name' : name } ) if len ( sshkeys ) == 1 : return sshkeys [ 0 ] [ 'id' ] elif not sshkeys : return raise DuplicateResults ( 'sshkey name %s is ambiguous.' % name ) | Retrieve a sshkey id associated to a name . | 71 | 11 |
242,926 | def usable_id ( cls , id ) : try : # id is maybe a sshkey name qry_id = cls . from_name ( id ) if not qry_id : qry_id = int ( id ) except DuplicateResults as exc : cls . error ( exc . errors ) except Exception : qry_id = None if not qry_id : msg = 'unknown identifier %s' % id cls . error ( msg ) return qry_id | Retrieve id from input which can be name or id . | 105 | 12 |
242,927 | def create ( cls , name , value ) : sshkey_params = { 'name' : name , 'value' : value , } result = cls . call ( 'hosting.ssh.create' , sshkey_params ) return result | Create a new ssh key . | 53 | 6 |
242,928 | def get_api_connector ( cls ) : if cls . _api is None : # pragma: no cover cls . load_config ( ) cls . debug ( 'initialize connection to remote server' ) apihost = cls . get ( 'api.host' ) if not apihost : raise MissingConfiguration ( ) apienv = cls . get ( 'api.env' ) if apienv and apienv in cls . apienvs : apihost = cls . apienvs [ apienv ] cls . _api = XMLRPCClient ( host = apihost , debug = cls . verbose ) return cls . _api | Initialize an api connector for future use . | 152 | 9 |
242,929 | def call ( cls , method , * args , * * kwargs ) : api = None empty_key = kwargs . pop ( 'empty_key' , False ) try : api = cls . get_api_connector ( ) apikey = cls . get ( 'api.key' ) if not apikey and not empty_key : cls . echo ( "No apikey found, please use 'gandi setup' " "command" ) sys . exit ( 1 ) except MissingConfiguration : if api and empty_key : apikey = '' elif not kwargs . get ( 'safe' ) : cls . echo ( "No configuration found, please use 'gandi setup' " "command" ) sys . exit ( 1 ) else : return [ ] # make the call cls . debug ( 'calling method: %s' % method ) for arg in args : cls . debug ( 'with params: %r' % arg ) try : resp = api . request ( method , apikey , * args , * * { 'dry_run' : kwargs . get ( 'dry_run' , False ) , 'return_dry_run' : kwargs . get ( 'return_dry_run' , False ) } ) cls . dump ( 'responded: %r' % resp ) return resp except APICallFailed as err : if kwargs . get ( 'safe' ) : return [ ] if err . code == 530040 : cls . echo ( "Error: It appears you haven't purchased any credits " "yet.\n" "Please visit https://www.gandi.net/credit/buy to " "learn more and buy credits." ) sys . exit ( 1 ) if err . code == 510150 : cls . echo ( "Invalid API key, please use 'gandi setup' command." ) sys . exit ( 1 ) if isinstance ( err , DryRunException ) : if kwargs . get ( 'return_dry_run' , False ) : return err . dry_run else : for msg in err . dry_run : # TODO use trads with %s cls . echo ( msg [ 'reason' ] ) cls . echo ( '\t' + ' ' . join ( msg [ 'attr' ] ) ) sys . exit ( 1 ) error = UsageError ( err . errors ) setattr ( error , 'code' , err . code ) raise error | Call a remote api method and return the result . | 538 | 10 |
242,930 | def safe_call ( cls , method , * args ) : return cls . call ( method , * args , safe = True ) | Call a remote api method but don t raise if an error occurred . | 29 | 14 |
242,931 | def json_call ( cls , method , url , * * kwargs ) : # retrieve api key if needed empty_key = kwargs . pop ( 'empty_key' , False ) send_key = kwargs . pop ( 'send_key' , True ) return_header = kwargs . pop ( 'return_header' , False ) try : apikey = cls . get ( 'apirest.key' ) if not apikey and not empty_key : cls . echo ( "No apikey found for REST API, please use " "'gandi setup' command" ) sys . exit ( 1 ) if send_key : if 'headers' in kwargs : kwargs [ 'headers' ] . update ( { 'X-Api-Key' : apikey } ) else : kwargs [ 'headers' ] = { 'X-Api-Key' : apikey } except MissingConfiguration : if not empty_key : return [ ] # make the call cls . debug ( 'calling url: %s %s' % ( method , url ) ) cls . debug ( 'with params: %r' % kwargs ) try : resp , resp_headers = JsonClient . request ( method , url , * * kwargs ) cls . dump ( 'responded: %r' % resp ) if return_header : return resp , resp_headers return resp except APICallFailed as err : cls . echo ( 'An error occured during call: %s' % err . errors ) sys . exit ( 1 ) | Call a remote api using json format | 349 | 7 |
242,932 | def intty ( cls ) : # XXX: temporary hack until we can detect if we are in a pipe or not return True if hasattr ( sys . stdout , 'isatty' ) and sys . stdout . isatty ( ) : return True return False | Check if we are in a tty . | 58 | 9 |
242,933 | def pretty_echo ( cls , message ) : if cls . intty ( ) : if message : from pprint import pprint pprint ( message ) | Display message using pretty print formatting . | 34 | 7 |
242,934 | def dump ( cls , message ) : if cls . verbose > 2 : msg = '[DUMP] %s' % message cls . echo ( msg ) | Display dump message if verbose level allows it . | 36 | 10 |
242,935 | def debug ( cls , message ) : if cls . verbose > 1 : msg = '[DEBUG] %s' % message cls . echo ( msg ) | Display debug message if verbose level allows it . | 35 | 10 |
242,936 | def log ( cls , message ) : if cls . verbose > 0 : msg = '[INFO] %s' % message cls . echo ( msg ) | Display info message if verbose level allows it . | 35 | 10 |
242,937 | def exec_output ( cls , command , shell = True , encoding = 'utf-8' ) : proc = Popen ( command , shell = shell , stdout = PIPE ) stdout , _stderr = proc . communicate ( ) if proc . returncode == 0 : return stdout . decode ( encoding ) return '' | Return execution output | 72 | 3 |
242,938 | def update_progress ( cls , progress , starttime ) : width , _height = click . get_terminal_size ( ) if not width : return duration = datetime . utcnow ( ) - starttime hours , remainder = divmod ( duration . seconds , 3600 ) minutes , seconds = divmod ( remainder , 60 ) size = int ( width * .6 ) status = "" if isinstance ( progress , int ) : progress = float ( progress ) if not isinstance ( progress , float ) : progress = 0 status = 'error: progress var must be float\n' cls . echo ( type ( progress ) ) if progress < 0 : progress = 0 status = 'Halt...\n' if progress >= 1 : progress = 1 # status = 'Done...\n' block = int ( round ( size * progress ) ) text = ( '\rProgress: [{0}] {1:.2%} {2} {3:0>2}:{4:0>2}:{5:0>2} ' '' . format ( '#' * block + '-' * ( size - block ) , progress , status , hours , minutes , seconds ) ) sys . stdout . write ( text ) sys . stdout . flush ( ) | Display an ascii progress bar while processing operation . | 272 | 11 |
242,939 | def display_progress ( cls , operations ) : start_crea = datetime . utcnow ( ) # count number of operations, 3 steps per operation if not isinstance ( operations , ( list , tuple ) ) : operations = [ operations ] count_operations = len ( operations ) * 3 updating_done = False while not updating_done : op_score = 0 for oper in operations : op_ret = cls . call ( 'operation.info' , oper [ 'id' ] ) op_step = op_ret [ 'step' ] if op_step in cls . _op_scores : op_score += cls . _op_scores [ op_step ] else : cls . echo ( '' ) msg = 'step %s unknown, exiting' % op_step if op_step == 'ERROR' : msg = ( 'An error has occured during operation ' 'processing: %s' % op_ret [ 'last_error' ] ) elif op_step == 'SUPPORT' : msg = ( 'An error has occured during operation ' 'processing, you must contact Gandi support.' ) cls . echo ( msg ) sys . exit ( 1 ) cls . update_progress ( float ( op_score ) / count_operations , start_crea ) if op_score == count_operations : updating_done = True time . sleep ( cls . _poll_freq ) cls . echo ( '\r' ) | Display progress of Gandi operations . | 321 | 7 |
242,940 | def load_modules ( self ) : module_folder = os . path . join ( os . path . dirname ( __file__ ) , '..' , 'modules' ) module_dirs = { 'gandi.cli' : module_folder } if 'GANDICLI_PATH' in os . environ : for _path in os . environ . get ( 'GANDICLI_PATH' ) . split ( ':' ) : # remove trailing separator if any path = _path . rstrip ( os . sep ) module_dirs [ os . path . basename ( path ) ] = os . path . join ( path , 'modules' ) for module_basename , dir in list ( module_dirs . items ( ) ) : for filename in sorted ( os . listdir ( dir ) ) : if filename . endswith ( '.py' ) and '__init__' not in filename : submod = filename [ : - 3 ] module_name = module_basename + '.modules.' + submod __import__ ( module_name , fromlist = [ module_name ] ) # save internal map of loaded module classes for subclass in GandiModule . __subclasses__ ( ) : self . _modules [ subclass . __name__ . lower ( ) ] = subclass | Import CLI commands modules . | 279 | 5 |
242,941 | def request ( self , method , apikey , * args , * * kwargs ) : dry_run = kwargs . get ( 'dry_run' , False ) return_dry_run = kwargs . get ( 'return_dry_run' , False ) if return_dry_run : args [ - 1 ] [ '--dry-run' ] = True try : func = getattr ( self . endpoint , method ) return func ( apikey , * args ) except ( socket . error , requests . exceptions . ConnectionError ) : msg = 'Gandi API service is unreachable' raise APICallFailed ( msg ) except xmlrpclib . Fault as err : msg = 'Gandi API has returned an error: %s' % err if dry_run : args [ - 1 ] [ '--dry-run' ] = True ret = func ( apikey , * args ) raise DryRunException ( msg , err . faultCode , ret ) raise APICallFailed ( msg , err . faultCode ) except TypeError as err : msg = 'An unknown error has occurred: %s' % err raise APICallFailed ( msg ) | Make a xml - rpc call to remote API . | 255 | 11 |
242,942 | def request ( cls , method , url , * * kwargs ) : user_agent = 'gandi.cli/%s' % __version__ headers = { 'User-Agent' : user_agent , 'Content-Type' : 'application/json; charset=utf-8' } if kwargs . get ( 'headers' ) : headers . update ( kwargs . pop ( 'headers' ) ) try : response = requests . request ( method , url , headers = headers , * * kwargs ) response . raise_for_status ( ) try : return response . json ( ) , response . headers except ValueError as err : return response . text , response . headers except ( socket . error , requests . exceptions . ConnectionError ) : msg = 'Remote API service is unreachable' raise APICallFailed ( msg ) except Exception as err : if isinstance ( err , requests . HTTPError ) : try : resp = response . json ( ) except Exception : msg = 'An unknown error has occurred: %s' % err raise APICallFailed ( msg ) if resp . get ( 'message' ) : error = resp . get ( 'message' ) if resp . get ( 'errors' ) : error = cls . format_errors ( resp . get ( 'errors' ) ) msg = '%s: %s' % ( err , error ) else : msg = 'An unknown error has occurred: %s' % err raise APICallFailed ( msg ) | Make a http call to a remote API and return a json response . | 323 | 14 |
242,943 | def docker ( gandi , vm , args ) : if not [ basedir for basedir in os . getenv ( 'PATH' , '.:/usr/bin' ) . split ( ':' ) if os . path . exists ( '%s/docker' % basedir ) ] : gandi . echo ( """'docker' not found in $PATH, required for this command \ to work See https://docs.docker.com/installation/#installation to install, or use: # curl https://get.docker.io/ | sh""" ) return if vm : gandi . configure ( True , 'dockervm' , vm ) else : vm = gandi . get ( 'dockervm' ) if not vm : gandi . echo ( """ No docker vm specified. You can create one: $ gandi vm create --hostname docker --image "Ubuntu 14.04 64 bits LTS (HVM)" \\ --run 'wget -O - https://get.docker.io/ | sh' Then configure it using: $ gandi docker --vm docker ps Or to both change target vm and spawn a process (note the -- separator): $ gandi docker --vm myvm -- run -i -t debian bash """ ) # noqa return return gandi . docker . handle ( vm , args ) | Manage docker instance | 283 | 4 |
242,944 | def query ( cls , resources , time_range , query , resource_type , sampler ) : if not isinstance ( resources , ( list , tuple ) ) : resources = [ resources ] now = time . time ( ) start_utc = datetime . utcfromtimestamp ( now - time_range ) end_utc = datetime . utcfromtimestamp ( now ) date_format = '%Y-%m-%d %H:%M:%S' start = start_utc . strftime ( date_format ) end = end_utc . strftime ( date_format ) query = { 'start' : start , 'end' : end , 'query' : query , 'resource_id' : resources , 'resource_type' : resource_type , 'sampler' : sampler } return cls . call ( 'hosting.metric.query' , query ) | Query statistics for given resources . | 199 | 6 |
242,945 | def required_max_memory ( cls , id , memory ) : best = int ( max ( 2 ** math . ceil ( math . log ( memory , 2 ) ) , 2048 ) ) actual_vm = cls . info ( id ) if ( actual_vm [ 'state' ] == 'running' and actual_vm [ 'vm_max_memory' ] != best ) : return best | Recommend a max_memory setting for this vm given memory . If the VM already has a nice setting return None . The max_memory param cannot be fixed too high because page table allocation would cost too much for small memory profile . Use a range as below . | 85 | 52 |
242,946 | def need_finalize ( cls , resource ) : vm_id = cls . usable_id ( resource ) params = { 'type' : 'hosting_migration_vm' , 'step' : 'RUN' , 'vm_id' : vm_id } result = cls . call ( 'operation.list' , params ) if not result or len ( result ) > 1 : raise MigrationNotFinalized ( 'Cannot find VM %s ' 'migration operation.' % resource ) need_finalize = result [ 0 ] [ 'params' ] [ 'inner_step' ] == 'wait_finalize' if not need_finalize : raise MigrationNotFinalized ( 'VM %s migration does not need ' 'finalization.' % resource ) | Check if vm migration need to be finalized . | 166 | 9 |
242,947 | def check_can_migrate ( cls , resource ) : vm_id = cls . usable_id ( resource ) result = cls . call ( 'hosting.vm.can_migrate' , vm_id ) if not result [ 'can_migrate' ] : if result [ 'matched' ] : matched = result [ 'matched' ] [ 0 ] cls . echo ( 'Your VM %s cannot be migrated yet. Migration will ' 'be available when datacenter %s is opened.' % ( resource , matched ) ) else : cls . echo ( 'Your VM %s cannot be migrated.' % resource ) return False return True | Check if virtual machine can be migrated to another datacenter . | 141 | 13 |
242,948 | def from_hostname ( cls , hostname ) : result = cls . list ( { 'hostname' : str ( hostname ) } ) if result : return result [ 0 ] [ 'id' ] | Retrieve virtual machine id associated to a hostname . | 46 | 11 |
242,949 | def wait_for_sshd ( cls , vm_id ) : cls . echo ( 'Waiting for the vm to come online' ) version , ip_addr = cls . vm_ip ( vm_id ) give_up = time . time ( ) + 300 last_error = None while time . time ( ) < give_up : try : inet = socket . AF_INET if version == 6 : inet = socket . AF_INET6 sd = socket . socket ( inet , socket . SOCK_STREAM , socket . IPPROTO_TCP ) sd . settimeout ( 5 ) sd . connect ( ( ip_addr , 22 ) ) sd . recv ( 1024 ) return except socket . error as err : if err . errno == errno . EHOSTUNREACH and version == 6 : cls . error ( '%s is not reachable, you may be missing ' 'IPv6 connectivity' % ip_addr ) last_error = err time . sleep ( 1 ) except Exception as err : last_error = err time . sleep ( 1 ) cls . error ( 'VM did not spin up (last error: %s)' % last_error ) | Insist on having the vm booted and sshd listening | 261 | 10 |
242,950 | def ssh_keyscan ( cls , vm_id ) : cls . echo ( 'Wiping old key and learning the new one' ) _version , ip_addr = cls . vm_ip ( vm_id ) cls . execute ( 'ssh-keygen -R "%s"' % ip_addr ) for _ in range ( 5 ) : output = cls . exec_output ( 'ssh-keyscan "%s"' % ip_addr ) if output : with open ( os . path . expanduser ( '~/.ssh/known_hosts' ) , 'a' ) as f : f . write ( output ) return True time . sleep ( .5 ) | Wipe this old key and learn the new one from a freshly created vm . This is a security risk for this VM however we dont have another way to learn the key yet so do this for the user . | 146 | 42 |
242,951 | def scp ( cls , vm_id , login , identity , local_file , remote_file ) : cmd = [ 'scp' ] if identity : cmd . extend ( ( '-i' , identity , ) ) version , ip_addr = cls . vm_ip ( vm_id ) if version == 6 : ip_addr = '[%s]' % ip_addr cmd . extend ( ( local_file , '%s@%s:%s' % ( login , ip_addr , remote_file ) , ) ) cls . echo ( 'Running %s' % ' ' . join ( cmd ) ) for _ in range ( 5 ) : ret = cls . execute ( cmd , False ) if ret : break time . sleep ( .5 ) return ret | Copy file to remote VM . | 168 | 6 |
242,952 | def ssh ( cls , vm_id , login , identity , args = None ) : cmd = [ 'ssh' ] if identity : cmd . extend ( ( '-i' , identity , ) ) version , ip_addr = cls . vm_ip ( vm_id ) if version == 6 : cmd . append ( '-6' ) if not ip_addr : cls . echo ( 'No IP address found for vm %s, aborting.' % vm_id ) return cmd . append ( '%s@%s' % ( login , ip_addr , ) ) if args : cmd . extend ( args ) cls . echo ( 'Requesting access using: %s ...' % ' ' . join ( cmd ) ) return cls . execute ( cmd , False ) | Spawn an ssh session to virtual machine . | 168 | 8 |
242,953 | def is_deprecated ( cls , label , datacenter = None ) : images = cls . list ( datacenter , label ) images_visibility = dict ( [ ( image [ 'label' ] , image [ 'visibility' ] ) for image in images ] ) return images_visibility . get ( label , 'all' ) == 'deprecated' | Check if image if flagged as deprecated . | 80 | 8 |
242,954 | def from_label ( cls , label , datacenter = None ) : result = cls . list ( datacenter = datacenter ) image_labels = dict ( [ ( image [ 'label' ] , image [ 'disk_id' ] ) for image in result ] ) return image_labels . get ( label ) | Retrieve disk image id associated to a label . | 73 | 10 |
242,955 | def from_sysdisk ( cls , label ) : disks = cls . safe_call ( 'hosting.disk.list' , { 'name' : label } ) if len ( disks ) : return disks [ 0 ] [ 'id' ] | Retrieve disk id from available system disks | 54 | 8 |
242,956 | def usable_id ( cls , id , datacenter = None ) : try : qry_id = int ( id ) except Exception : # if id is a string, prefer a system disk then a label qry_id = cls . from_sysdisk ( id ) or cls . from_label ( id , datacenter ) if not qry_id : msg = 'unknown identifier %s' % id cls . error ( msg ) return qry_id | Retrieve id from input which can be label or id . | 103 | 12 |
242,957 | def list ( cls , datacenter = None , flavor = None , match = '' , exact_match = False ) : if not datacenter : dc_ids = [ dc [ 'id' ] for dc in Datacenter . filtered_list ( ) ] kmap = { } for dc_id in dc_ids : vals = cls . safe_call ( 'hosting.disk.list_kernels' , dc_id ) for key in vals : kmap . setdefault ( key , [ ] ) . extend ( vals . get ( key , [ ] ) ) # remove duplicates for key in kmap : kmap [ key ] = list ( set ( kmap [ key ] ) ) else : dc_id = Datacenter . usable_id ( datacenter ) kmap = cls . safe_call ( 'hosting.disk.list_kernels' , dc_id ) if match : for flav in kmap : if exact_match : kmap [ flav ] = [ x for x in kmap [ flav ] if match == x ] else : kmap [ flav ] = [ x for x in kmap [ flav ] if match in x ] if flavor : if flavor not in kmap : cls . error ( 'flavor %s not supported here' % flavor ) return dict ( [ ( flavor , kmap [ flavor ] ) ] ) return kmap | List available kernels for datacenter . | 302 | 8 |
242,958 | def is_available ( cls , disk , kernel ) : kmap = cls . list ( disk [ 'datacenter_id' ] , None , kernel , True ) for flavor in kmap : if kernel in kmap [ flavor ] : return True return False | Check if kernel is available for disk . | 57 | 8 |
242,959 | def clone ( cls , name , vhost , directory , origin ) : paas_info = cls . info ( name ) if 'php' in paas_info [ 'type' ] and not vhost : cls . error ( 'PHP instances require indicating the VHOST to clone ' 'with --vhost <vhost>' ) paas_access = '%s@%s' % ( paas_info [ 'user' ] , paas_info [ 'git_server' ] ) remote_url = 'ssh+git://%s/%s.git' % ( paas_access , vhost ) command = 'git clone %s %s --origin %s' % ( remote_url , directory , origin ) init_git = cls . execute ( command ) if init_git : cls . echo ( 'Use `git push %s master` to push your code to the ' 'instance.' % ( origin ) ) cls . echo ( 'Then `$ gandi deploy` to build and deploy your ' 'application.' ) | Clone a PaaS instance s vhost into a local git repository . | 231 | 16 |
242,960 | def attach ( cls , name , vhost , remote_name ) : paas_access = cls . get ( 'paas_access' ) if not paas_access : paas_info = cls . info ( name ) paas_access = '%s@%s' % ( paas_info [ 'user' ] , paas_info [ 'git_server' ] ) remote_url = 'ssh+git://%s/%s.git' % ( paas_access , vhost ) ret = cls . execute ( 'git remote add %s %s' % ( remote_name , remote_url , ) ) if ret : cls . echo ( 'Added remote `%s` to your local git repository.' % ( remote_name ) ) cls . echo ( 'Use `git push %s master` to push your code to the ' 'instance.' % ( remote_name ) ) cls . echo ( 'Then `$ gandi deploy` to build and deploy your ' 'application.' ) | Attach an instance s vhost to a remote from the local repository . | 225 | 14 |
242,961 | def cache ( cls , id ) : sampler = { 'unit' : 'days' , 'value' : 1 , 'function' : 'sum' } query = 'webacc.requests.cache.all' metrics = Metric . query ( id , 60 * 60 * 24 , query , 'paas' , sampler ) cache = { 'hit' : 0 , 'miss' : 0 , 'not' : 0 , 'pass' : 0 } for metric in metrics : what = metric [ 'cache' ] . pop ( ) for point in metric [ 'points' ] : value = point . get ( 'value' , 0 ) cache [ what ] += value return cache | return the number of query cache for the last 24H | 147 | 11 |
242,962 | def create ( cls , name , size , type , quantity , duration , datacenter , vhosts , password , snapshot_profile , background , sshkey ) : if not background and not cls . intty ( ) : background = True datacenter_id_ = int ( Datacenter . usable_id ( datacenter ) ) paas_params = { 'name' : name , 'size' : size , 'type' : type , 'duration' : duration , 'datacenter_id' : datacenter_id_ , } if password : paas_params [ 'password' ] = password if quantity : paas_params [ 'quantity' ] = quantity paas_params . update ( cls . convert_sshkey ( sshkey ) ) if snapshot_profile : paas_params [ 'snapshot_profile' ] = snapshot_profile result = cls . call ( 'paas.create' , paas_params ) if not background : # interactive mode, run a progress bar cls . echo ( 'Creating your PaaS instance.' ) cls . display_progress ( result ) cls . echo ( 'Your PaaS instance %s has been created.' % name ) if vhosts : paas_info = cls . info ( name ) Vhost . create ( paas_info , vhosts , True , background ) return result | Create a new PaaS instance . | 300 | 8 |
242,963 | def console ( cls , id ) : oper = cls . call ( 'paas.update' , cls . usable_id ( id ) , { 'console' : 1 } ) cls . echo ( 'Activation of the console on your PaaS instance' ) cls . display_progress ( oper ) console_url = Paas . info ( cls . usable_id ( id ) ) [ 'console' ] access = 'ssh %s' % console_url cls . execute ( access ) | Open a console to a PaaS instance . | 111 | 10 |
242,964 | def from_vhost ( cls , vhost ) : result = Vhost ( ) . list ( ) paas_hosts = { } for host in result : paas_hosts [ host [ 'name' ] ] = host [ 'paas_id' ] return paas_hosts . get ( vhost ) | Retrieve paas instance id associated to a vhost . | 71 | 12 |
242,965 | def from_hostname ( cls , hostname ) : result = cls . list ( { 'items_per_page' : 500 } ) paas_hosts = { } for host in result : paas_hosts [ host [ 'name' ] ] = host [ 'id' ] return paas_hosts . get ( hostname ) | Retrieve paas instance id associated to a host . | 77 | 11 |
242,966 | def list_names ( cls ) : ret = dict ( [ ( item [ 'id' ] , item [ 'name' ] ) for item in cls . list ( { 'items_per_page' : 500 } ) ] ) return ret | Retrieve paas id and names . | 53 | 8 |
242,967 | def from_cn ( cls , common_name ) : # search with cn result_cn = [ ( cert [ 'id' ] , [ cert [ 'cn' ] ] + cert [ 'altnames' ] ) for cert in cls . list ( { 'status' : [ 'pending' , 'valid' ] , 'items_per_page' : 500 , 'cn' : common_name } ) ] # search with altname result_alt = [ ( cert [ 'id' ] , [ cert [ 'cn' ] ] + cert [ 'altnames' ] ) for cert in cls . list ( { 'status' : [ 'pending' , 'valid' ] , 'items_per_page' : 500 , 'altname' : common_name } ) ] result = result_cn + result_alt ret = { } for id_ , fqdns in result : for fqdn in fqdns : ret . setdefault ( fqdn , [ ] ) . append ( id_ ) cert_id = ret . get ( common_name ) if not cert_id : return return cert_id | Retrieve a certificate by its common name . | 247 | 9 |
242,968 | def usable_ids ( cls , id , accept_multi = True ) : try : qry_id = [ int ( id ) ] except ValueError : try : qry_id = cls . from_cn ( id ) except Exception : qry_id = None if not qry_id or not accept_multi and len ( qry_id ) != 1 : msg = 'unknown identifier %s' % id cls . error ( msg ) return qry_id if accept_multi else qry_id [ 0 ] | Retrieve id from input which can be an id or a cn . | 115 | 15 |
242,969 | def package_list ( cls , options = None ) : options = options or { } try : return cls . safe_call ( 'cert.package.list' , options ) except UsageError as err : if err . code == 150020 : return [ ] raise | List possible certificate packages . | 57 | 5 |
242,970 | def advice_dcv_method ( cls , csr , package , altnames , dcv_method , cert_id = None ) : params = { 'csr' : csr , 'package' : package , 'dcv_method' : dcv_method } if cert_id : params [ 'cert_id' ] = cert_id result = cls . call ( 'cert.get_dcv_params' , params ) if dcv_method == 'dns' : cls . echo ( 'You have to add these records in your domain zone :' ) cls . echo ( '\n' . join ( result [ 'message' ] ) ) | Display dcv_method information . | 147 | 7 |
242,971 | def create_csr ( cls , common_name , private_key = None , params = None ) : params = params or [ ] params = [ ( key , val ) for key , val in params if val ] subj = '/' + '/' . join ( [ '=' . join ( value ) for value in params ] ) cmd , private_key = cls . gen_pk ( common_name , private_key ) if private_key . endswith ( '.crt' ) or private_key . endswith ( '.key' ) : csr_file = re . sub ( r'\.(crt|key)$' , '.csr' , private_key ) else : csr_file = private_key + '.csr' cmd = cmd % { 'csr' : csr_file , 'key' : private_key , 'subj' : subj } result = cls . execute ( cmd ) if not result : cls . echo ( 'CSR creation failed' ) cls . echo ( cmd ) return return csr_file | Create CSR . | 236 | 4 |
242,972 | def get_common_name ( cls , csr ) : from tempfile import NamedTemporaryFile fhandle = NamedTemporaryFile ( ) fhandle . write ( csr . encode ( 'latin1' ) ) fhandle . flush ( ) output = cls . exec_output ( 'openssl req -noout -subject -in %s' % fhandle . name ) if not output : return common_name = output . split ( '=' ) [ - 1 ] . strip ( ) fhandle . close ( ) return common_name | Read information from CSR . | 117 | 6 |
242,973 | def process_csr ( cls , common_name , csr = None , private_key = None , country = None , state = None , city = None , organisation = None , branch = None ) : if csr : if branch or organisation or city or state or country : cls . echo ( 'Following options are only used to generate' ' the CSR.' ) else : params = ( ( 'CN' , common_name ) , ( 'OU' , branch ) , ( 'O' , organisation ) , ( 'L' , city ) , ( 'ST' , state ) , ( 'C' , country ) ) params = [ ( key , val ) for key , val in params if val ] csr = cls . create_csr ( common_name , private_key , params ) if csr and os . path . exists ( csr ) : with open ( csr ) as fcsr : csr = fcsr . read ( ) return csr | Create a PK and a CSR if needed . | 211 | 10 |
242,974 | def pretty_format_cert ( cls , cert ) : crt = cert . get ( 'cert' ) if crt : crt = ( '-----BEGIN CERTIFICATE-----\n' + '\n' . join ( [ crt [ index * 64 : ( index + 1 ) * 64 ] for index in range ( int ( len ( crt ) / 64 ) + 1 ) ] ) . rstrip ( '\n' ) + # noqa '\n-----END CERTIFICATE-----' ) return crt | Pretty display of a certificate . | 116 | 6 |
242,975 | def info ( gandi , resource , format ) : result = gandi . webacc . info ( resource ) if format : output_json ( gandi , format , result ) return result output_base = { 'name' : result [ 'name' ] , 'algorithm' : result [ 'lb' ] [ 'algorithm' ] , 'datacenter' : result [ 'datacenter' ] [ 'name' ] , 'state' : result [ 'state' ] , 'ssl' : 'Disable' if result [ 'ssl_enable' ] is False else 'Enabled' } output_keys = [ 'name' , 'state' , 'datacenter' , 'ssl' , 'algorithm' ] output_generic ( gandi , output_base , output_keys , justify = 14 ) gandi . echo ( 'Vhosts :' ) for vhost in result [ 'vhosts' ] : output_vhosts = [ 'vhost' , 'ssl' ] vhost [ 'vhost' ] = vhost [ 'name' ] vhost [ 'ssl' ] = 'None' if vhost [ 'cert_id' ] is None else 'Exists' output_sub_generic ( gandi , vhost , output_vhosts , justify = 14 ) gandi . echo ( '' ) gandi . echo ( 'Backends :' ) for server in result [ 'servers' ] : try : ip = gandi . ip . info ( server [ 'ip' ] ) iface = gandi . iface . info ( ip [ 'iface_id' ] ) server [ 'name' ] = gandi . iaas . info ( iface [ 'vm_id' ] ) [ 'hostname' ] output_servers = [ 'name' , 'ip' , 'port' , 'state' ] except Exception : warningmsg = ( '\tBackend with ip address %s no longer exists.' '\n\tYou should remove it.' % server [ 'ip' ] ) gandi . echo ( warningmsg ) output_servers = [ 'ip' , 'port' , 'state' ] output_sub_generic ( gandi , server , output_servers , justify = 14 ) gandi . echo ( '' ) gandi . echo ( 'Probe :' ) output_probe = [ 'state' , 'host' , 'interval' , 'method' , 'response' , 'threshold' , 'timeout' , 'url' , 'window' ] result [ 'probe' ] [ 'state' ] = ( 'Disable' if result [ 'probe' ] [ 'enable' ] is False else 'Enabled' ) output_sub_generic ( gandi , result [ 'probe' ] , output_probe , justify = 14 ) return result | Display information about a webaccelerator | 615 | 8 |
242,976 | def delete ( gandi , webacc , vhost , backend , port ) : result = [ ] if webacc : result = gandi . webacc . delete ( webacc ) if backend : backends = backend for backend in backends : if 'port' not in backend : if not port : backend [ 'port' ] = click . prompt ( 'Please set a port for ' 'backends. If you want to ' ' different port for ' 'each backend, use `-b ' 'ip:port`' , type = int ) else : backend [ 'port' ] = port result = gandi . webacc . backend_remove ( backend ) if vhost : vhosts = vhost for vhost in vhosts : result = gandi . webacc . vhost_remove ( vhost ) return result | Delete a webaccelerator a vhost or a backend | 175 | 12 |
242,977 | def add ( gandi , resource , vhost , zone_alter , backend , port , ssl , private_key , poll_cert ) : result = [ ] if backend : backends = backend for backend in backends : # Check if a port is set for each backend, else set a default port if 'port' not in backend : if not port : backend [ 'port' ] = click . prompt ( 'Please set a port for ' 'backends. If you want to ' ' different port for ' 'each backend, use `-b ' 'ip:port`' , type = int ) else : backend [ 'port' ] = port result = gandi . webacc . backend_add ( resource , backend ) if vhost : if not gandi . hostedcert . activate_ssl ( vhost , ssl , private_key , poll_cert ) : return vhosts = vhost for vhost in vhosts : params = { 'vhost' : vhost } if zone_alter : params [ 'zone_alter' ] = zone_alter result = gandi . webacc . vhost_add ( resource , params ) return result | Add a backend or a vhost on a webaccelerator | 247 | 13 |
242,978 | def enable ( gandi , resource , backend , port , probe ) : result = [ ] if backend : backends = backend for backend in backends : if 'port' not in backend : if not port : backend [ 'port' ] = click . prompt ( 'Please set a port for ' 'backends. If you want to ' ' different port for ' 'each backend, use `-b ' 'ip:port`' , type = int ) else : backend [ 'port' ] = port result = gandi . webacc . backend_enable ( backend ) if probe : if not resource : gandi . echo ( 'You need to indicate the Webaccelerator name' ) return result = gandi . webacc . probe_enable ( resource ) return result | Enable a backend or a probe on a webaccelerator | 162 | 12 |
242,979 | def disable ( gandi , resource , backend , port , probe ) : result = [ ] if backend : backends = backend for backend in backends : if 'port' not in backend : if not port : backend [ 'port' ] = click . prompt ( 'Please set a port for ' 'backends. If you want to ' ' different port for ' 'each backend, use `-b ' 'ip:port`' , type = int ) else : backend [ 'port' ] = port result = gandi . webacc . backend_disable ( backend ) if probe : if not resource : gandi . echo ( 'You need to indicate the Webaccelerator name' ) return result = gandi . webacc . probe_disable ( resource ) return result | Disable a backend or a probe on a webaccelerator | 162 | 12 |
242,980 | def probe ( gandi , resource , enable , disable , test , host , interval , http_method , http_response , threshold , timeout , url , window ) : result = gandi . webacc . probe ( resource , enable , disable , test , host , interval , http_method , http_response , threshold , timeout , url , window ) output_keys = [ 'status' , 'timeout' ] output_generic ( gandi , result , output_keys , justify = 14 ) return result | Manage a probe for a webaccelerator | 105 | 10 |
242,981 | def domain_list ( gandi ) : domains = gandi . dns . list ( ) for domain in domains : gandi . echo ( domain [ 'fqdn' ] ) return domains | List domains manageable by REST API . | 41 | 7 |
242,982 | def list ( gandi , fqdn , name , sort , type , rrset_type , text ) : domains = gandi . dns . list ( ) domains = [ domain [ 'fqdn' ] for domain in domains ] if fqdn not in domains : gandi . echo ( 'Sorry domain %s does not exist' % fqdn ) gandi . echo ( 'Please use one of the following: %s' % ', ' . join ( domains ) ) return output_keys = [ 'name' , 'ttl' , 'type' , 'values' ] result = gandi . dns . records ( fqdn , sort_by = sort , text = text ) if text : gandi . echo ( result ) return result for num , rec in enumerate ( result ) : if type and rec [ 'rrset_type' ] != type : continue if rrset_type and rec [ 'rrset_type' ] != rrset_type : continue if name and rec [ 'rrset_name' ] != name : continue if num : gandi . separator_line ( ) output_dns_records ( gandi , rec , output_keys ) return result | Display records for a domain . | 261 | 6 |
242,983 | def create ( gandi , fqdn , name , type , value , ttl ) : domains = gandi . dns . list ( ) domains = [ domain [ 'fqdn' ] for domain in domains ] if fqdn not in domains : gandi . echo ( 'Sorry domain %s does not exist' % fqdn ) gandi . echo ( 'Please use one of the following: %s' % ', ' . join ( domains ) ) return result = gandi . dns . add_record ( fqdn , name , type , value , ttl ) gandi . echo ( result [ 'message' ] ) | Create new record entry for a domain . | 137 | 8 |
242,984 | def update ( gandi , fqdn , name , type , value , ttl , file ) : domains = gandi . dns . list ( ) domains = [ domain [ 'fqdn' ] for domain in domains ] if fqdn not in domains : gandi . echo ( 'Sorry domain %s does not exist' % fqdn ) gandi . echo ( 'Please use one of the following: %s' % ', ' . join ( domains ) ) return content = '' if file : content = file . read ( ) elif not sys . stdin . isatty ( ) : content = click . get_text_stream ( 'stdin' ) . read ( ) content = content . strip ( ) if not content and not name and not type and not value : click . echo ( 'Cannot find parameters for zone content to update.' ) return if name and type and not value : click . echo ( 'You must provide one or more value parameter.' ) return result = gandi . dns . update_record ( fqdn , name , type , value , ttl , content ) gandi . echo ( result [ 'message' ] ) | Update record entry for a domain . | 248 | 7 |
242,985 | def delete ( gandi , fqdn , name , type , force ) : domains = gandi . dns . list ( ) domains = [ domain [ 'fqdn' ] for domain in domains ] if fqdn not in domains : gandi . echo ( 'Sorry domain %s does not exist' % fqdn ) gandi . echo ( 'Please use one of the following: %s' % ', ' . join ( domains ) ) return if not force : if not name and not type : prompt = ( "Are you sure to delete all records for domain %s ?" % fqdn ) elif name and not type : prompt = ( "Are you sure to delete all '%s' name records for " "domain %s ?" % ( name , fqdn ) ) else : prompt = ( "Are you sure to delete all '%s' records of type %s " "for domain %s ?" % ( name , type , fqdn ) ) proceed = click . confirm ( prompt ) if not proceed : return result = gandi . dns . del_record ( fqdn , name , type ) gandi . echo ( 'Delete successful.' ) return result | Delete record entry for a domain . | 255 | 7 |
242,986 | def keys_list ( gandi , fqdn ) : keys = gandi . dns . keys ( fqdn ) output_keys = [ 'uuid' , 'algorithm' , 'algorithm_name' , 'ds' , 'flags' , 'status' ] for num , key in enumerate ( keys ) : if num : gandi . separator_line ( ) output_generic ( gandi , key , output_keys , justify = 15 ) return keys | List domain keys . | 103 | 4 |
242,987 | def keys_info ( gandi , fqdn , key ) : key_info = gandi . dns . keys_info ( fqdn , key ) output_keys = [ 'uuid' , 'algorithm' , 'algorithm_name' , 'ds' , 'fingerprint' , 'public_key' , 'flags' , 'tag' , 'status' ] output_generic ( gandi , key_info , output_keys , justify = 15 ) return key_info | Display information about a domain key . | 107 | 7 |
242,988 | def keys_create ( gandi , fqdn , flag ) : key_info = gandi . dns . keys_create ( fqdn , int ( flag ) ) output_keys = [ 'uuid' , 'algorithm' , 'algorithm_name' , 'ds' , 'fingerprint' , 'public_key' , 'flags' , 'tag' , 'status' ] output_generic ( gandi , key_info , output_keys , justify = 15 ) return key_info | Create key for a domain . | 110 | 6 |
242,989 | def handle ( cls , vm , args ) : docker = Iaas . info ( vm ) if not docker : raise Exception ( 'docker vm %s not found' % vm ) if docker [ 'state' ] != 'running' : Iaas . start ( vm ) # XXX remote_addr = docker [ 'ifaces' ] [ 0 ] [ 'ips' ] [ 0 ] [ 'ip' ] port = unixpipe . setup ( remote_addr , 'root' , '/var/run/docker.sock' ) os . environ [ 'DOCKER_HOST' ] = 'tcp://localhost:%d' % port cls . echo ( 'using DOCKER_HOST=%s' % os . environ [ 'DOCKER_HOST' ] ) subprocess . call ( [ 'docker' ] + list ( args ) ) | Setup forwarding connection to given VM and pipe docker cmds over SSH . | 190 | 14 |
242,990 | def list ( gandi , state , id , limit , datacenter ) : options = { 'items_per_page' : limit , } if state : options [ 'state' ] = state if datacenter : options [ 'datacenter_id' ] = gandi . datacenter . usable_id ( datacenter ) output_keys = [ 'hostname' , 'state' ] if id : output_keys . append ( 'id' ) result = gandi . iaas . list ( options ) for num , vm in enumerate ( result ) : if num : gandi . separator_line ( ) output_vm ( gandi , vm , [ ] , output_keys ) return result | List virtual machines . | 154 | 4 |
242,991 | def info ( gandi , resource , stat ) : output_keys = [ 'hostname' , 'state' , 'cores' , 'memory' , 'console' , 'datacenter' , 'ip' ] justify = 14 if stat is True : sampler = { 'unit' : 'hours' , 'value' : 1 , 'function' : 'max' } time_range = 3600 * 24 query_vif = 'vif.bytes.all' query_vbd = 'vbd.bytes.all' resource = sorted ( tuple ( set ( resource ) ) ) datacenters = gandi . datacenter . list ( ) ret = [ ] for num , item in enumerate ( resource ) : if num : gandi . separator_line ( ) vm = gandi . iaas . info ( item ) output_vm ( gandi , vm , datacenters , output_keys , justify ) ret . append ( vm ) for disk in vm [ 'disks' ] : gandi . echo ( '' ) disk_out_keys = [ 'label' , 'kernel_version' , 'name' , 'size' ] output_image ( gandi , disk , datacenters , disk_out_keys , justify , warn_deprecated = False ) if stat is True : metrics_vif = gandi . metric . query ( vm [ 'id' ] , time_range , query_vif , 'vm' , sampler ) metrics_vbd = gandi . metric . query ( vm [ 'id' ] , time_range , query_vbd , 'vm' , sampler ) gandi . echo ( '' ) gandi . echo ( 'vm network stats' ) output_metric ( gandi , metrics_vif , 'direction' , justify ) gandi . echo ( 'disk network stats' ) output_metric ( gandi , metrics_vbd , 'direction' , justify ) return ret | Display information about a virtual machine . | 422 | 7 |
242,992 | def ssh ( gandi , resource , login , identity , wipe_key , wait , args ) : if '@' in resource : ( login , resource ) = resource . split ( '@' , 1 ) if wipe_key : gandi . iaas . ssh_keyscan ( resource ) if wait : gandi . iaas . wait_for_sshd ( resource ) gandi . iaas . ssh ( resource , login , identity , args ) | Spawn an SSH session to virtual machine . | 99 | 8 |
242,993 | def images ( gandi , label , datacenter ) : output_keys = [ 'label' , 'os_arch' , 'kernel_version' , 'disk_id' , 'dc' , 'name' ] datacenters = gandi . datacenter . list ( ) result = gandi . image . list ( datacenter , label ) for num , image in enumerate ( result ) : if num : gandi . separator_line ( ) output_image ( gandi , image , datacenters , output_keys ) # also display usable disks result = gandi . disk . list_create ( datacenter , label ) for disk in result : gandi . separator_line ( ) output_image ( gandi , disk , datacenters , output_keys ) return result | List available system images for virtual machines . | 172 | 8 |
242,994 | def kernels ( gandi , vm , datacenter , flavor , match ) : if vm : vm = gandi . iaas . info ( vm ) dc_list = gandi . datacenter . filtered_list ( datacenter , vm ) for num , dc in enumerate ( dc_list ) : if num : gandi . echo ( '\n' ) output_datacenter ( gandi , dc , [ 'dc_name' ] ) kmap = gandi . kernel . list ( dc [ 'id' ] , flavor , match ) for _flavor in kmap : gandi . separator_line ( ) output_kernels ( gandi , _flavor , kmap [ _flavor ] ) | List available kernels . | 157 | 4 |
242,995 | def datacenters ( gandi , id ) : output_keys = [ 'iso' , 'name' , 'country' , 'dc_code' , 'status' ] if id : output_keys . append ( 'id' ) result = gandi . datacenter . list ( ) for num , dc in enumerate ( result ) : if num : gandi . separator_line ( ) output_datacenter ( gandi , dc , output_keys , justify = 10 ) return result | List available datacenters . | 107 | 6 |
242,996 | def usable_id ( cls , id ) : hcs = cls . from_fqdn ( id ) if hcs : return [ hc_ [ 'id' ] for hc_ in hcs ] try : return int ( id ) except ( TypeError , ValueError ) : pass | Retrieve id from single input . | 64 | 7 |
242,997 | def infos ( cls , fqdn ) : if isinstance ( fqdn , ( list , tuple ) ) : ids = [ ] for fqd_ in fqdn : ids . extend ( cls . infos ( fqd_ ) ) return ids ids = cls . usable_id ( fqdn ) if not ids : return [ ] if not isinstance ( ids , ( list , tuple ) ) : ids = [ ids ] return [ cls . info ( id_ ) for id_ in ids ] | Display information about hosted certificates for a fqdn . | 123 | 11 |
242,998 | def create ( cls , key , crt ) : options = { 'crt' : crt , 'key' : key } return cls . call ( 'cert.hosted.create' , options ) | Add a new crt in the hosted cert store . | 46 | 11 |
242,999 | def list ( gandi , limit ) : options = { 'items_per_page' : limit } domains = gandi . domain . list ( options ) for domain in domains : gandi . echo ( domain [ 'fqdn' ] ) return domains | List domains . | 54 | 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.