add --dataset-only option to dataset import, this allows to upload da…

…taset file only after the import is interrupted

and also unified all quotes in .py files

fifo/api/dataset.py

@@ -9,15 +9,15 @@
 
 dataset_fmt = {
     'uuid':
-    {'title': 'UUID', 'len': 36, 'fmt': "%36s", 'get': lambda e: d(e, ['dataset'])},
+    {'title': 'UUID', 'len': 36, 'fmt': '%36s', 'get': lambda e: d(e, ['dataset'])},
     'name':
-    {'title': 'Name', 'len': 10, 'fmt': "%-10s", 'get': lambda e: d(e, ['name'])},
+    {'title': 'Name', 'len': 10, 'fmt': '%-10s', 'get': lambda e: d(e, ['name'])},
     'version':
-    {'title': 'Version', 'len': 7, 'fmt': "%-7s", 'get': lambda e: d(e, ['version'])},
+    {'title': 'Version', 'len': 7, 'fmt': '%-7s', 'get': lambda e: d(e, ['version'])},
     'type':
-    {'title': 'Type', 'len': 5, 'fmt': "%-5s", 'get': lambda e: d(e, ['type'])},
+    {'title': 'Type', 'len': 5, 'fmt': '%-5s', 'get': lambda e: d(e, ['type'])},
     'description':
-    {'title': 'Description', 'len': 10, 'fmt': "%-30s", 'get': lambda e: d(e, ['description'])},
+    {'title': 'Description', 'len': 10, 'fmt': '%-30s', 'get': lambda e: d(e, ['description'])},
 }
 
 def _write_bindata(response, f):
@@ -36,64 +36,69 @@ def _write_bindata(response, f):
         try:
             data = response.read(amt)
         except httplib.IncompleteRead, e:
-            vprint("Incomplete read captured")
+            vprint('Incomplete read captured')
             data = e.partial
 
 def dataset_get(args):
-    response = args.endpoint.get_bindata(args.uuid, "/dataset.gz")
+    response = args.endpoint.get_bindata(args.uuid, '/dataset.gz')
     if response:
-        vprint("Headers:", response.getheaders())
+        vprint('Headers:', response.getheaders())
         _write_bindata(response, args.out or sys.stdout)
 
 def import_dataset(args):
     j = json.load(args.manifest)
     uuid = j['uuid']
-    response = args.endpoint._post_attr(uuid, [], j)
-    if response == 201:
-        print "Manifest imported, uploading dataset now ..."
-        response = args.endpoint._put_file([uuid],  "/dataset.gz", args.dataset)
-        if response == 204:
-            print "Import complete!"
+    if not args.dataset_only:
+        response = args.endpoint._post_attr(uuid, [], j)
+        if response == 201:
+            print 'Manifest imported'
         else:
-            print "Dataset upload failed."
+            print 'Manifest upload failed.'
+            exit(1)
+
+    print 'Uploading dataset now ...'
+    response = args.endpoint._put_file([uuid],  '/dataset.gz', args.dataset)
+    if response == 204:
+        print 'Import complete!'
     else:
-        print "Manifest upload failed."
+        print 'Dataset upload failed.'
+        exit(1)
 
 class Dataset(Entity):
     def __init__(self, wiggle):
         self._wiggle = wiggle
-        self._resource = "datasets"
+        self._resource = 'datasets'
 
     def name_of(self, obj):
-        return obj["name"] + "-" + obj["version"]
-
+        return obj['name'] + '-' + obj['version']
 
     def make_parser(self, subparsers):
         parser_datasets = subparsers.add_parser('datasets', help='dataset related commands')
         parser_datasets.set_defaults(endpoint=self)
         subparsers_datasets = parser_datasets.add_subparsers(help='dataset commands')
         self.add_metadata_parser(subparsers_datasets)
         parser_datasets_list = subparsers_datasets.add_parser('list', help='lists datasets')
-        parser_datasets_list.add_argument("--fmt", action=ListAction,
+        parser_datasets_list.add_argument('--fmt', action=ListAction,
                                           default=['uuid', 'name', 'version', 'type', 'description'])
-        parser_datasets_list.add_argument("-H", action='store_false')
-        parser_datasets_list.add_argument("-p", action='store_true')
+        parser_datasets_list.add_argument('-H', action='store_false')
+        parser_datasets_list.add_argument('-p', action='store_true')
         parser_datasets_list.set_defaults(func=show_list,
                                           fmt_def=dataset_fmt)
         parser_datasets_get = subparsers_datasets.add_parser('get', help='gets a dataset')
-        parser_datasets_get.add_argument("uuid")
+        parser_datasets_get.add_argument('uuid')
         parser_datasets_get.set_defaults(func=show_get)
         parser_datasets_delete = subparsers_datasets.add_parser('delete', help='gets a dataset')
-        parser_datasets_delete.add_argument("uuid")
+        parser_datasets_delete.add_argument('uuid')
         parser_datasets_delete.set_defaults(func=show_delete)
         parser_dataset_import = subparsers_datasets.add_parser('import', help='Imports the binary part of a dataset')
-        parser_dataset_import.add_argument('--manifest', '-m', help="manifest to upload",
+        parser_dataset_import.add_argument('--manifest', '-m', help='manifest to upload',
                                            type=argparse.FileType('r'))
-        parser_dataset_import.add_argument('--dataset', '-d', help="dataset to upload",
+        parser_dataset_import.add_argument('--dataset', '-d', help='dataset to upload',
                                            type=argparse.FileType('r'))
+        parser_dataset_import.add_argument('--dataset-only', action='store_true', default=False, help='skip manifest, import dataset only')
         parser_dataset_import.set_defaults(func=import_dataset)
         parser_dataset_export = subparsers_datasets.add_parser('export', help='Exports the dataset binary')
         parser_dataset_export.add_argument('uuid', help='uuid of the element to look at')
-        parser_dataset_export.add_argument('--out', '-o', help="File to write to", type=argparse.FileType('w'))
+        parser_dataset_export.add_argument('--out', '-o', help='File to write to', type=argparse.FileType('w'))
         parser_dataset_export.set_defaults(func=dataset_get)
 

fifo/api/dtrace.py

@@ -6,32 +6,32 @@
 
 dtrace_fmt = {
     'uuid':
-    {'title': 'UUID', 'len': 36, 'fmt': "%36s", 'get': lambda e: d(e, ['uuid'])},
+    {'title': 'UUID', 'len': 36, 'fmt': '%36s', 'get': lambda e: d(e, ['uuid'])},
     'name':
-    {'title': 'Name', 'len': 40, 'fmt': "%-40s", 'get': lambda e: d(e, ['name'])},
+    {'title': 'Name', 'len': 40, 'fmt': '%-40s', 'get': lambda e: d(e, ['name'])},
 }
 
 
 class Dtrace(Entity):
     def __init__(self, wiggle):
         self._wiggle = wiggle
-        self._resource = "dtrace"
+        self._resource = 'dtrace'
 
     def make_parser(self, subparsers):
         parser_dtraces = subparsers.add_parser('dtrace', help='dtrace related commands')
         parser_dtraces.set_defaults(endpoint=self)
         subparsers_dtraces = parser_dtraces.add_subparsers(help='dtrace commands')
         self.add_metadata_parser(subparsers_dtraces)
         parser_dtraces_list = subparsers_dtraces.add_parser('list', help='lists dtraces')
-        parser_dtraces_list.add_argument("--fmt", action=ListAction,
+        parser_dtraces_list.add_argument('--fmt', action=ListAction,
                                           default=['uuid', 'name'])
-        parser_dtraces_list.add_argument("-H", action='store_false')
-        parser_dtraces_list.add_argument("-p", action='store_true')
+        parser_dtraces_list.add_argument('-H', action='store_false')
+        parser_dtraces_list.add_argument('-p', action='store_true')
         parser_dtraces_list.set_defaults(func=show_list,
                                           fmt_def=dtrace_fmt)
         parser_dtraces_get = subparsers_dtraces.add_parser('get', help='gets a dtrace')
-        parser_dtraces_get.add_argument("uuid")
+        parser_dtraces_get.add_argument('uuid')
         parser_dtraces_get.set_defaults(func=show_get)
         parser_dtraces_delete = subparsers_dtraces.add_parser('delete', help='gets a dtrace')
-        parser_dtraces_delete.add_argument("uuid")
+        parser_dtraces_delete.add_argument('uuid')
         parser_dtraces_delete.set_defaults(func=show_delete)

fifo/api/groupings.py

@@ -6,68 +6,68 @@
 
 grouping_fmt = {
     'uuid':
-    {'title': 'UUID', 'len': 36, 'fmt': "%36s", 'get': lambda e: d(e, ['uuid'])},
+    {'title': 'UUID', 'len': 36, 'fmt': '%36s', 'get': lambda e: d(e, ['uuid'])},
     'name':
-    {'title': 'Name', 'len': 10, 'fmt': "%-10s", 'get': lambda e: d(e, ['name'])},
+    {'title': 'Name', 'len': 10, 'fmt': '%-10s', 'get': lambda e: d(e, ['name'])},
     'type':
-    {'title': 'Name', 'len': 10, 'fmt': "%-10s", 'get': lambda e: d(e, ['type'])},
+    {'title': 'Name', 'len': 10, 'fmt': '%-10s', 'get': lambda e: d(e, ['type'])},
     'elements':
-    {'title': 'elements', 'len': 36, 'fmt': "%36s", 'get': lambda e: ",".join(d(e, ['elements']))},
+    {'title': 'elements', 'len': 36, 'fmt': '%36s', 'get': lambda e: ','.join(d(e, ['elements']))},
     'groupings':
-    {'title': 'groupings', 'len': 36, 'fmt': "%36s", 'get': lambda e: ",".join(d(e, ['groupings']))},
+    {'title': 'groupings', 'len': 36, 'fmt': '%36s', 'get': lambda e: ','.join(d(e, ['groupings']))},
  }
 
 
 def create_grouping(args):
     res = args.endpoint.create(args.name, args.type)
     if res:
-        print "New " + args.type + " created: " + res["uuid"]
+        print 'New ' + args.type + ' created: ' + res['uuid']
     else:
-        print "Failed to create " + args.type
+        print 'Failed to create ' + args.type
         exit(1)
 
 def grouping_add(args):
     main = args.endpoint.get(args.uuid)
     if main['type'] != 'stack':
-        print "Only clusters can be added to stacks."
+        print 'Only clusters can be added to stacks.'
         exit(1)
     res = args.endpoint.get(args.target)
     if not res:
-        print "Could not find cluster " + args.target
+        print 'Could not find cluster ' + args.target
         exit(1)
     if not res['type'] == 'cluster':
-        print args.target + " is not a cluster."
+        print args.target + ' is not a cluster.'
         exit(1)
     res = args.endpoint.add_element(args.uuid, args.target)
     if res:
-        print "Successfully added cluster " + args.target + "."
+        print 'Successfully added cluster ' + args.target + '.'
     else:
-        print "Failed to add added cluster " + args.target + "."
+        print 'Failed to add added cluster ' + args.target + '.'
         exit(1)
 
 def grouping_remove(args):
     main = args.endpoint.get(args.uuid)
     if main['type'] != 'stack':
-        print "Only clusters can be added to stacks."
+        print 'Only clusters can be added to stacks.'
         exit(1)
     if main['type'] == 'cluster' and args.type == 'cluster':
-        print "Only VMs can be added to clusters."
+        print 'Only VMs can be added to clusters.'
         exit(1)
     res = args.endpoint.delete_element(args.uuid, args.target)
     if res:
-        print "Successfully removed " + args.type + " " + args.target + " from " + args.uuid
+        print 'Successfully removed ' + args.type + ' ' + args.target + ' from ' + args.uuid
     else:
-        print "Failed to removed " + args.type + " from " + args.uuid
+        print 'Failed to removed ' + args.type + ' from ' + args.uuid
         exit(1)
 
 
 class Grouping(Entity):
     def __init__(self, wiggle):
         self._wiggle = wiggle
-        self._resource = "groupings"
+        self._resource = 'groupings'
 
     def create(self, name, type):
-        return self._post({"name": name, "type": type})
+        return self._post({'name': name, 'type': type})
 
     def add_element(self, uuid, element):
         return self._put_attr(uuid, ['elements', element], {})
@@ -81,32 +81,32 @@ def make_parser(self, subparsers):
         subparsers_groupings = parser_groupings.add_subparsers(help='grouping commands')
         self.add_metadata_parser(subparsers_groupings)
         parser_groupings_list = subparsers_groupings.add_parser('list', help='lists groupings')
-        parser_groupings_list.add_argument("--fmt", action=ListAction,
+        parser_groupings_list.add_argument('--fmt', action=ListAction,
                                           default=['uuid', 'name', 'type'])
-        parser_groupings_list.add_argument("-H", action='store_false')
-        parser_groupings_list.add_argument("-p", action='store_true')
+        parser_groupings_list.add_argument('-H', action='store_false')
+        parser_groupings_list.add_argument('-p', action='store_true')
         parser_groupings_list.set_defaults(func=show_list,
                                           fmt_def=grouping_fmt)
         parser_groupings_get = subparsers_groupings.add_parser('get', help='gets a grouping')
-        parser_groupings_get.add_argument("uuid")
+        parser_groupings_get.add_argument('uuid')
         parser_groupings_get.set_defaults(func=show_get)
         parser_groupings_delete = subparsers_groupings.add_parser('delete', help='deletes a grouping')
-        parser_groupings_delete.add_argument("uuid")
+        parser_groupings_delete.add_argument('uuid')
         parser_groupings_delete.set_defaults(func=show_delete)
 
         parser_groupings_create = subparsers_groupings.add_parser('create', help='creates a new grouping')
-        parser_groupings_create.add_argument("--type", "-t", required=True, type=str, choices=["stack", "cluster"])
-        parser_groupings_create.add_argument("name")
+        parser_groupings_create.add_argument('--type', '-t', required=True, type=str, choices=['stack', 'cluster'])
+        parser_groupings_create.add_argument('name')
         parser_groupings_create.set_defaults(func=create_grouping)
 
         parser_groupings_add = subparsers_groupings.add_parser('add', help='Adds elements to a crouping')
-        parser_groupings_add.add_argument("uuid")
-        parser_groupings_add.add_argument("type", type=str, choices=["cluster"])
-        parser_groupings_add.add_argument("target")
+        parser_groupings_add.add_argument('uuid')
+        parser_groupings_add.add_argument('type', type=str, choices=['cluster'])
+        parser_groupings_add.add_argument('target')
         parser_groupings_add.set_defaults(func=grouping_add)
 
         parser_groupings_remove = subparsers_groupings.add_parser('remove', help='Removes elements to a crouping')
-        parser_groupings_remove.add_argument("uuid")
-        parser_groupings_remove.add_argument("type", type=str, choices=["vm", "cluster"])
-        parser_groupings_remove.add_argument("target")
+        parser_groupings_remove.add_argument('uuid')
+        parser_groupings_remove.add_argument('type', type=str, choices=['vm', 'cluster'])
+        parser_groupings_remove.add_argument('target')
         parser_groupings_remove.set_defaults(func=grouping_remove)

fifo/api/hypervisor.py

@@ -5,46 +5,46 @@
 
 hypervisor_fmt = {
     'uuid':
-    {'title': 'UUID', 'len': 36, 'fmt': "%36s", 'get': lambda e: d(e, ['uuid'])},
+    {'title': 'UUID', 'len': 36, 'fmt': '%36s', 'get': lambda e: d(e, ['uuid'])},
     'name':
-    {'title': 'Name', 'len': 30, 'fmt': "%30s", 'get': lambda e: d(e, ['alias'])},
+    {'title': 'Name', 'len': 30, 'fmt': '%30s', 'get': lambda e: d(e, ['alias'])},
     'free':
-    {'title': 'Free RAM', 'len': 10, 'fmt': "%10s",
-     'get': lambda e: str(d(e, ['resources', 'free-memory'])) + "MB"},
+    {'title': 'Free RAM', 'len': 10, 'fmt': '%10s',
+     'get': lambda e: str(d(e, ['resources', 'free-memory'])) + 'MB'},
     'used':
-    {'title': 'Used RAM', 'len': 10, 'fmt': "%10s",
-     'get': lambda e: str(d(e, ['resources', 'provisioned-memory'])) + "MB"},
+    {'title': 'Used RAM', 'len': 10, 'fmt': '%10s',
+     'get': lambda e: str(d(e, ['resources', 'provisioned-memory'])) + 'MB'},
     'reserved':
-    {'title': 'Reserved RAM', 'len': 10, 'fmt': "%10s",
-     'get': lambda e: str(d(e, ['resources', 'reserved-memory'])) + "MB"},
+    {'title': 'Reserved RAM', 'len': 10, 'fmt': '%10s',
+     'get': lambda e: str(d(e, ['resources', 'reserved-memory'])) + 'MB'},
     'total':
-    {'title': 'Total RAM', 'len': 10, 'fmt': "%10s",
-     'get': lambda e: str(d(e, ['resources', 'total-memory'])) + "MB"},
+    {'title': 'Total RAM', 'len': 10, 'fmt': '%10s',
+     'get': lambda e: str(d(e, ['resources', 'total-memory'])) + 'MB'},
     'smartos':
-    {'title': 'SmartOS Version', 'len': 20, 'fmt': "%-20s",
+    {'title': 'SmartOS Version', 'len': 20, 'fmt': '%-20s',
      'get': lambda e: d(e, ['sysinfo', 'Live Image'])},
     'ip':
-    {'title': 'IP', 'len': 20, 'fmt': "%20s",
+    {'title': 'IP', 'len': 20, 'fmt': '%20s',
      'get': lambda e: d(e, ['host'])},
 }
 
 class Hypervisor(Entity):
     def __init__(self, wiggle):
         self._wiggle = wiggle
-        self._resource = "hypervisors"
+        self._resource = 'hypervisors'
 
     def make_parser(self, subparsers):
         parser_hypervisors = subparsers.add_parser('hypervisors', help='hypervisor related commands')
         parser_hypervisors.set_defaults(endpoint=self)
         subparsers_hypervisors = parser_hypervisors.add_subparsers(help='hypervisor commands')
         self.add_metadata_parser(subparsers_hypervisors)
         parser_hypervisors_list = subparsers_hypervisors.add_parser('list', help='lists hypervisors')
-        parser_hypervisors_list.add_argument("--fmt", action=ListAction,
+        parser_hypervisors_list.add_argument('--fmt', action=ListAction,
                                              default=['uuid', 'name', 'free', 'used'])
-        parser_hypervisors_list.add_argument("-H", action='store_false')
-        parser_hypervisors_list.add_argument("-p", action='store_true')
+        parser_hypervisors_list.add_argument('-H', action='store_false')
+        parser_hypervisors_list.add_argument('-p', action='store_true')
         parser_hypervisors_list.set_defaults(func=show_list,
                                           fmt_def=hypervisor_fmt)
         parser_hypervisors_get = subparsers_hypervisors.add_parser('get', help='gets a hypervisor')
-        parser_hypervisors_get.add_argument("uuid")
+        parser_hypervisors_get.add_argument('uuid')
         parser_hypervisors_get.set_defaults(func=show_get)