github.com/mmatczuk/gohan@v0.0.0-20170206152520-30e45d9bdb69/extension/gohanscript/autogen/lib_openstack.go (about)

     1  package autogen
     2  
     3  // AUTO GENERATED CODE DO NOT MODIFY MANUALLY
     4  import (
     5  	"github.com/cloudwan/gohan/extension/gohanscript"
     6  	"github.com/cloudwan/gohan/extension/gohanscript/lib"
     7  	"github.com/rackspace/gophercloud"
     8  )
     9  
    10  func init() {
    11  
    12  	gohanscript.RegisterStmtParser("get_openstack_client",
    13  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    14  			return func(context *gohanscript.Context) (interface{}, error) {
    15  
    16  				var authURL string
    17  				iauthURL := stmt.Arg("auth_url", context)
    18  				if iauthURL != nil {
    19  					authURL = iauthURL.(string)
    20  				}
    21  				var userName string
    22  				iuserName := stmt.Arg("user_name", context)
    23  				if iuserName != nil {
    24  					userName = iuserName.(string)
    25  				}
    26  				var password string
    27  				ipassword := stmt.Arg("password", context)
    28  				if ipassword != nil {
    29  					password = ipassword.(string)
    30  				}
    31  				var domainName string
    32  				idomainName := stmt.Arg("domain_name", context)
    33  				if idomainName != nil {
    34  					domainName = idomainName.(string)
    35  				}
    36  				var tenantName string
    37  				itenantName := stmt.Arg("tenant_name", context)
    38  				if itenantName != nil {
    39  					tenantName = itenantName.(string)
    40  				}
    41  				var tenantID string
    42  				itenantID := stmt.Arg("tenant_id", context)
    43  				if itenantID != nil {
    44  					tenantID = itenantID.(string)
    45  				}
    46  				var version string
    47  				iversion := stmt.Arg("version", context)
    48  				if iversion != nil {
    49  					version = iversion.(string)
    50  				}
    51  
    52  				result1,
    53  					err :=
    54  					lib.GetOpenstackClient(
    55  						authURL, userName, password, domainName, tenantName, tenantID, version)
    56  
    57  				return result1, err
    58  
    59  			}, nil
    60  		})
    61  	gohanscript.RegisterMiniGoFunc("GetOpenstackClient",
    62  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
    63  
    64  			authURL, _ := args[0].(string)
    65  			userName, _ := args[1].(string)
    66  			password, _ := args[2].(string)
    67  			domainName, _ := args[3].(string)
    68  			tenantName, _ := args[4].(string)
    69  			tenantID, _ := args[5].(string)
    70  			version, _ := args[6].(string)
    71  
    72  			result1,
    73  				err :=
    74  				lib.GetOpenstackClient(
    75  					authURL, userName, password, domainName, tenantName, tenantID, version)
    76  			return []interface{}{
    77  				result1,
    78  				err}
    79  
    80  		})
    81  
    82  	gohanscript.RegisterStmtParser("openstack_token",
    83  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    84  			return func(context *gohanscript.Context) (interface{}, error) {
    85  
    86  				var client *gophercloud.ServiceClient
    87  				iclient := stmt.Arg("client", context)
    88  				if iclient != nil {
    89  					client = iclient.(*gophercloud.ServiceClient)
    90  				}
    91  
    92  				result1 :=
    93  					lib.OpenstackToken(
    94  						client)
    95  
    96  				return result1, nil
    97  
    98  			}, nil
    99  		})
   100  	gohanscript.RegisterMiniGoFunc("OpenstackToken",
   101  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   102  
   103  			client, _ := args[0].(*gophercloud.ServiceClient)
   104  
   105  			result1 :=
   106  				lib.OpenstackToken(
   107  					client)
   108  			return []interface{}{
   109  				result1}
   110  
   111  		})
   112  
   113  	gohanscript.RegisterStmtParser("openstack_get",
   114  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   115  			return func(context *gohanscript.Context) (interface{}, error) {
   116  
   117  				var client *gophercloud.ServiceClient
   118  				iclient := stmt.Arg("client", context)
   119  				if iclient != nil {
   120  					client = iclient.(*gophercloud.ServiceClient)
   121  				}
   122  				var url string
   123  				iurl := stmt.Arg("url", context)
   124  				if iurl != nil {
   125  					url = iurl.(string)
   126  				}
   127  
   128  				result1,
   129  					err :=
   130  					lib.OpenstackGet(
   131  						client, url)
   132  
   133  				return result1, err
   134  
   135  			}, nil
   136  		})
   137  	gohanscript.RegisterMiniGoFunc("OpenstackGet",
   138  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   139  
   140  			client, _ := args[0].(*gophercloud.ServiceClient)
   141  			url, _ := args[0].(string)
   142  
   143  			result1,
   144  				err :=
   145  				lib.OpenstackGet(
   146  					client, url)
   147  			return []interface{}{
   148  				result1,
   149  				err}
   150  
   151  		})
   152  
   153  	gohanscript.RegisterStmtParser("openstack_ensure",
   154  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   155  			return func(context *gohanscript.Context) (interface{}, error) {
   156  
   157  				var client *gophercloud.ServiceClient
   158  				iclient := stmt.Arg("client", context)
   159  				if iclient != nil {
   160  					client = iclient.(*gophercloud.ServiceClient)
   161  				}
   162  				var url string
   163  				iurl := stmt.Arg("url", context)
   164  				if iurl != nil {
   165  					url = iurl.(string)
   166  				}
   167  				var postURL string
   168  				ipostURL := stmt.Arg("post_url", context)
   169  				if ipostURL != nil {
   170  					postURL = ipostURL.(string)
   171  				}
   172  				var data interface{}
   173  				idata := stmt.Arg("data", context)
   174  				if idata != nil {
   175  					data = idata.(interface{})
   176  				}
   177  
   178  				result1,
   179  					err :=
   180  					lib.OpenstackEnsure(
   181  						client, url, postURL, data)
   182  
   183  				return result1, err
   184  
   185  			}, nil
   186  		})
   187  	gohanscript.RegisterMiniGoFunc("OpenstackEnsure",
   188  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   189  
   190  			client, _ := args[0].(*gophercloud.ServiceClient)
   191  			url, _ := args[0].(string)
   192  			postURL, _ := args[0].(string)
   193  			data, _ := args[0].(interface{})
   194  
   195  			result1,
   196  				err :=
   197  				lib.OpenstackEnsure(
   198  					client, url, postURL, data)
   199  			return []interface{}{
   200  				result1,
   201  				err}
   202  
   203  		})
   204  
   205  	gohanscript.RegisterStmtParser("openstack_put",
   206  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   207  			return func(context *gohanscript.Context) (interface{}, error) {
   208  
   209  				var client *gophercloud.ServiceClient
   210  				iclient := stmt.Arg("client", context)
   211  				if iclient != nil {
   212  					client = iclient.(*gophercloud.ServiceClient)
   213  				}
   214  				var url string
   215  				iurl := stmt.Arg("url", context)
   216  				if iurl != nil {
   217  					url = iurl.(string)
   218  				}
   219  				var data interface{}
   220  				idata := stmt.Arg("data", context)
   221  				if idata != nil {
   222  					data = idata.(interface{})
   223  				}
   224  
   225  				result1,
   226  					err :=
   227  					lib.OpenstackPut(
   228  						client, url, data)
   229  
   230  				return result1, err
   231  
   232  			}, nil
   233  		})
   234  	gohanscript.RegisterMiniGoFunc("OpenstackPut",
   235  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   236  
   237  			client, _ := args[0].(*gophercloud.ServiceClient)
   238  			url, _ := args[0].(string)
   239  			data, _ := args[0].(interface{})
   240  
   241  			result1,
   242  				err :=
   243  				lib.OpenstackPut(
   244  					client, url, data)
   245  			return []interface{}{
   246  				result1,
   247  				err}
   248  
   249  		})
   250  
   251  	gohanscript.RegisterStmtParser("openstack_post",
   252  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   253  			return func(context *gohanscript.Context) (interface{}, error) {
   254  
   255  				var client *gophercloud.ServiceClient
   256  				iclient := stmt.Arg("client", context)
   257  				if iclient != nil {
   258  					client = iclient.(*gophercloud.ServiceClient)
   259  				}
   260  				var url string
   261  				iurl := stmt.Arg("url", context)
   262  				if iurl != nil {
   263  					url = iurl.(string)
   264  				}
   265  				var data interface{}
   266  				idata := stmt.Arg("data", context)
   267  				if idata != nil {
   268  					data = idata.(interface{})
   269  				}
   270  
   271  				result1,
   272  					err :=
   273  					lib.OpenstackPost(
   274  						client, url, data)
   275  
   276  				return result1, err
   277  
   278  			}, nil
   279  		})
   280  	gohanscript.RegisterMiniGoFunc("OpenstackPost",
   281  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   282  
   283  			client, _ := args[0].(*gophercloud.ServiceClient)
   284  			url, _ := args[0].(string)
   285  			data, _ := args[0].(interface{})
   286  
   287  			result1,
   288  				err :=
   289  				lib.OpenstackPost(
   290  					client, url, data)
   291  			return []interface{}{
   292  				result1,
   293  				err}
   294  
   295  		})
   296  
   297  	gohanscript.RegisterStmtParser("openstack_delete",
   298  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   299  			return func(context *gohanscript.Context) (interface{}, error) {
   300  
   301  				var client *gophercloud.ServiceClient
   302  				iclient := stmt.Arg("client", context)
   303  				if iclient != nil {
   304  					client = iclient.(*gophercloud.ServiceClient)
   305  				}
   306  				var url string
   307  				iurl := stmt.Arg("url", context)
   308  				if iurl != nil {
   309  					url = iurl.(string)
   310  				}
   311  
   312  				result1,
   313  					err :=
   314  					lib.OpenstackDelete(
   315  						client, url)
   316  
   317  				return result1, err
   318  
   319  			}, nil
   320  		})
   321  	gohanscript.RegisterMiniGoFunc("OpenstackDelete",
   322  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   323  
   324  			client, _ := args[0].(*gophercloud.ServiceClient)
   325  			url, _ := args[0].(string)
   326  
   327  			result1,
   328  				err :=
   329  				lib.OpenstackDelete(
   330  					client, url)
   331  			return []interface{}{
   332  				result1,
   333  				err}
   334  
   335  		})
   336  
   337  	gohanscript.RegisterStmtParser("openstack_endpoint",
   338  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   339  			return func(context *gohanscript.Context) (interface{}, error) {
   340  
   341  				var client *gophercloud.ServiceClient
   342  				iclient := stmt.Arg("client", context)
   343  				if iclient != nil {
   344  					client = iclient.(*gophercloud.ServiceClient)
   345  				}
   346  				var endpointType string
   347  				iendpointType := stmt.Arg("endpoint_type", context)
   348  				if iendpointType != nil {
   349  					endpointType = iendpointType.(string)
   350  				}
   351  				var name string
   352  				iname := stmt.Arg("name", context)
   353  				if iname != nil {
   354  					name = iname.(string)
   355  				}
   356  				var region string
   357  				iregion := stmt.Arg("region", context)
   358  				if iregion != nil {
   359  					region = iregion.(string)
   360  				}
   361  				var availability string
   362  				iavailability := stmt.Arg("availability", context)
   363  				if iavailability != nil {
   364  					availability = iavailability.(string)
   365  				}
   366  
   367  				result1,
   368  					err :=
   369  					lib.OpenstackEndpoint(
   370  						client, endpointType, name, region, availability)
   371  
   372  				return result1, err
   373  
   374  			}, nil
   375  		})
   376  	gohanscript.RegisterMiniGoFunc("OpenstackEndpoint",
   377  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   378  
   379  			client, _ := args[0].(*gophercloud.ServiceClient)
   380  			endpointType, _ := args[0].(string)
   381  			name, _ := args[1].(string)
   382  			region, _ := args[2].(string)
   383  			availability, _ := args[3].(string)
   384  
   385  			result1,
   386  				err :=
   387  				lib.OpenstackEndpoint(
   388  					client, endpointType, name, region, availability)
   389  			return []interface{}{
   390  				result1,
   391  				err}
   392  
   393  		})
   394  
   395  }