Merge branch 'feature/tdd' into develop

.gitignore

@@ -1 +1,3 @@
+*.tfstate
+*.tfstate.backup
 *.pyc

VERSION

@@ -0,0 +1 @@
+0.0.1

python_terraform/__init__.py

@@ -11,13 +11,16 @@ class Terraform:
         self.targets = [] if targets is None else targets
         self.variables = dict() if variables is None else variables
         
-        self.state = state
-        self.state_data = None
+        self.state_filename = state
+        self.state_data = dict()
         self.parallelism = 50
 
-    def apply(self, targets=None, variables=None):
+    def apply(self, targets=None, variables=None, **kargs):
         """
         refer to https://terraform.io/docs/commands/apply.html
+        :param variables: variables in dict type
+        :param targets: targets in list
+        :returns return_code, stdout, stderr
         """
         variables = self.variables if variables is None else variables
         targets = self.targets if targets is None else targets
@@ -25,13 +28,20 @@ class Terraform:
         parameters = []
         parameters += self._generate_targets(targets)
         parameters += self._generate_var_string(variables)
-        parameters += ['-parallelism=%s' % self.parallelism]
+        parameters += self._gen_param_string(kargs)
+
         parameters = \
-            ['terraform', 'apply', '-state=%s' % self.state] + parameters
+            ['terraform', 'apply', '-state=%s' % self.state_filename] + parameters
 
         cmd = ' '.join(parameters)
         return self._run_cmd(cmd)
 
+    def _gen_param_string(self, kargs):
+        params = []
+        for key, value in kargs.items():
+            params += ['%s=%s' % (key, value)]
+        return params
+
     def _run_cmd(self, cmd):
         log.debug('command: ' + cmd)
 
@@ -43,10 +53,10 @@ class Terraform:
 
         if ret_code == 0:
             log.debug('error: ' + err)
-            self.read_state()
+            self.read_state_file()
         return ret_code, out, err
 
-    def destroy(self, targets=None, variables=None):
+    def destroy(self, targets=None, variables=None, **kwargs):
         variables = self.variables if variables is None else variables
         targets = self.targets if targets is None else targets
 
@@ -55,7 +65,7 @@ class Terraform:
         parameters += self._generate_var_string(variables)
 
         parameters = \
-            ['terraform', 'destroy', '-force', '-state=%s' % self.state] + \
+            ['terraform', 'destroy', '-force', '-state=%s' % self.state_filename] + \
             parameters
         cmd = ' '.join(parameters)
         return self._run_cmd(cmd)
@@ -68,15 +78,18 @@ class Terraform:
         parameters += self._generate_targets(targets)
         parameters += self._generate_var_string(variables)
         parameters = \
-            ['terraform', 'refresh', '-state=%s' % self.state] + \
+            ['terraform', 'refresh', '-state=%s' % self.state_filename] + \
             parameters
         cmd = ' '.join(parameters)
         return self._run_cmd(cmd)
 
-    def read_state(self, state=None):
-        state = self.state if state is None else state
-        if os.path.exists(state):
-            with open(state) as f:
+    def read_state_file(self):
+        """
+        read .tfstate file
+        :return: states file in dict type
+        """
+        if os.path.exists(self.state_filename):
+            with open(self.state_filename) as f:
                 json_data = json.load(f)
             self.state_data = json_data
             log.debug("state_data=%s" % str(self.state_data))
@@ -86,11 +99,11 @@ class Terraform:
 
     def is_any_aws_instance_alive(self):
         self.refresh()
-        if not os.path.exists(self.state):
+        if not os.path.exists(self.state_filename):
             log.debug("can't find %s " % self.state_data)
             return False
 
-        self.read_state()
+        self.read_state_file()
         try:
             main_module = self._get_main_module()
             for resource_key, info in main_module['resources'].items():
@@ -136,6 +149,11 @@ class Terraform:
             return None
 
     def get_output_value(self, output_name):
+        """
+
+        :param output_name:
+        :return:
+        """
         try:
             main_module = self._get_main_module()
             return main_module['outputs'][output_name]

release.py

@@ -0,0 +1,104 @@
+import subprocess
+import click
+import os
+from distutils.version import StrictVersion
+import shutil
+import re
+
+
+def get_version():
+    p = get_version_file_path()
+    with open(p) as f:
+        version = f.read()
+        version = version.strip()
+        if not version:
+            raise ValueError("could not read version")
+        return version
+
+
+def write_version(version_tuple):
+    p = get_version_file_path()
+    with open(p, 'w+') as f:
+        f.write('.'.join([str(i) for i in version_tuple]))
+
+
+def get_version_file_path():
+    p = os.path.join(os.path.dirname(
+        os.path.abspath(__file__)), 'VERSION')
+    return p
+
+
+def release_patch(version_tuple):
+    patch_version = version_tuple[2] + 1
+    new_version = version_tuple[:2] + (patch_version,)
+    click.echo('new version: %s' % str(new_version))
+    write_version(new_version)
+    return new_version
+
+
+def release_minor(version_tuple):
+    minor = version_tuple[1] + 1
+    new_version = version_tuple[:1] + (minor, 0)
+    click.echo('new version: %s' % str(new_version))
+    write_version(new_version)
+    return new_version
+
+
+def release_major(version_tuple):
+    major = version_tuple[0] + 1
+    new = (major, 0, 0)
+    click.echo('new version: %s' % str(new))
+    write_version(new)
+    return new
+
+
+@click.command()
+@click.option('--release', '-r', type=click.Choice(['major', 'minor', 'patch']), default='patch')
+@click.option('--url', prompt=True, default=lambda: os.environ.get('FURY_URL', ''))
+def main(release, url):
+    version_tuple = StrictVersion(get_version()).version
+    click.echo('old version: %s' % str(version_tuple))
+
+    if release == 'major':
+        new_v = release_major(version_tuple)
+    elif release == 'minor':
+        new_v = release_minor(version_tuple)
+    else:
+        new_v = release_patch(version_tuple)
+
+    new_v_s = '.'.join([str(i) for i in new_v])
+
+    os.chdir(os.path.dirname(os.path.abspath(__file__)))
+    subprocess.call("python setup.py sdist", shell=True)
+
+    pkg_file = ''
+    for f in os.listdir('dist'):
+        r = re.compile(r'.*(%s\.tar\.gz)' % re.escape(new_v_s))
+        result = r.match(f)
+        if result:
+            click.echo(f + ' is ready')
+            pkg_file = f
+
+            break
+
+    if not pkg_file:
+        raise ValueError
+
+    this_folder = os.path.dirname(os.path.abspath(__file__))
+    dist_folder = os.path.join(this_folder, 'dist')
+    pkg_file_name = pkg_file
+    pkg_file = os.path.join(dist_folder, pkg_file)
+
+    shutil.move(pkg_file, this_folder)
+    shutil.rmtree(dist_folder)
+    os.remove('MANIFEST')
+    is_release = click.confirm('ready to release?')
+
+    if is_release:
+        subprocess.call('curl -F package=@%s %s' % (pkg_file_name, url),
+                        shell=True)
+        os.remove(pkg_file_name)
+
+
+if __name__ == '__main__':
+    main()

setup.py

@@ -5,19 +5,29 @@ from distutils.core import setup
 import os
 
 dependencies = []
-module_name = 'terraform'
+module_name = 'python-terraform'
 
 
+def get_version():
+    p = os.path.join(os.path.dirname(
+        os.path.abspath(__file__)), "VERSION")
+    with open(p) as f:
+        version = f.read()
+        version = version.strip()
+        if not version:
+            raise ValueError("could not read version")
+        return version
+
 setup(
     name=module_name,
-    version="0.0.1",
+    version=get_version(),
     url='https://github.com/beelit94/python-terraform',
     license='BSD',
     author='Freddy Tan',
     author_email='beelit94@gmail.com',
     description='This is a python module provide a wrapper of terraform command line tool',
     long_description=__doc__,
-    packages=[module_name],
+    packages=['python_terraform'],
     include_package_data=True,
     package_data={},
     zip_safe=False,

test/test.tf

@@ -0,0 +1,24 @@
+variable "access_key" {}
+variable "secret_key" {}
+
+provider "aws" {
+    access_key = "${var.access_key}"
+    secret_key = "${var.secret_key}"
+    region = "us-west-2"
+}
+
+resource "aws_instance" "ubuntu-1404" {
+  ami = "ami-9abea4fb"
+  instance_type = "t2.micro"
+  security_groups = ["terraform-salty-splunk"]
+  tags {
+    Name = "python-terraform-test"
+  }
+//  key_name = "${aws_key_pair.key.key_name}"
+//  connection {
+//    type = "ssh"
+//    user = "ubuntu"
+//    key_file = "${var.key_path}"
+//    timeout = "10m"
+//  }
+}

test/test_terraform.py

@@ -1,20 +1,15 @@
-from terraform import Terraform
+from python_terraform import Terraform
 
 
 class TestTerraform:
-	def test_apply(self):
+    def test_apply_and_destory(self):
         tf = Terraform()
+        ret_code, out, err = tf.apply()
 
-		tf.apply()
-
-	def test_refresh(self):
-		tf = Terraform()
-
-		tf.refresh()
-
-	def test_destroy(self):
-		tf = Terraform()
-
-		tf.destroy()
+        print out
+        print err
+        # assert ret_code, 0
 
+        ret_code, out, err = tf.destroy()
 
+        assert ret_code, 0