repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1 value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_identity_role_v3.go | dataSourceIdentityRoleV3Read | func dataSourceIdentityRoleV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
listOpts := roles.ListOpts{
DomainID: d.Get("domain_id").(string),
Name: d.Get("name").(string),
}
log.Printf("[DEBUG] openstack_identity_role_v3 list options: %#v", listOpts)
var role roles.Role
allPages, err := roles.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_role_v3: %s", err)
}
allRoles, err := roles.ExtractRoles(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_role_v3: %s", err)
}
if len(allRoles) < 1 {
return fmt.Errorf("Your openstack_identity_role_v3 query returned no results.")
}
if len(allRoles) > 1 {
return fmt.Errorf("Your openstack_identity_role_v3 query returned more than one result.")
}
role = allRoles[0]
return dataSourceIdentityRoleV3Attributes(d, config, &role)
} | go | func dataSourceIdentityRoleV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
listOpts := roles.ListOpts{
DomainID: d.Get("domain_id").(string),
Name: d.Get("name").(string),
}
log.Printf("[DEBUG] openstack_identity_role_v3 list options: %#v", listOpts)
var role roles.Role
allPages, err := roles.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_role_v3: %s", err)
}
allRoles, err := roles.ExtractRoles(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_role_v3: %s", err)
}
if len(allRoles) < 1 {
return fmt.Errorf("Your openstack_identity_role_v3 query returned no results.")
}
if len(allRoles) > 1 {
return fmt.Errorf("Your openstack_identity_role_v3 query returned more than one result.")
}
role = allRoles[0]
return dataSourceIdentityRoleV3Attributes(d, config, &role)
} | [
"func",
"dataSourceIdentityRoleV3Read",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
")",
"error",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n",
"identityClient",
",",
"err",
":=",
"config",
".",
"identityV3Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"listOpts",
":=",
"roles",
".",
"ListOpts",
"{",
"DomainID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"Name",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"listOpts",
")",
"\n\n",
"var",
"role",
"roles",
".",
"Role",
"\n",
"allPages",
",",
"err",
":=",
"roles",
".",
"List",
"(",
"identityClient",
",",
"listOpts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allRoles",
",",
"err",
":=",
"roles",
".",
"ExtractRoles",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allRoles",
")",
"<",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allRoles",
")",
">",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"role",
"=",
"allRoles",
"[",
"0",
"]",
"\n\n",
"return",
"dataSourceIdentityRoleV3Attributes",
"(",
"d",
",",
"config",
",",
"&",
"role",
")",
"\n",
"}"
] | // dataSourceIdentityRoleV3Read performs the role lookup. | [
"dataSourceIdentityRoleV3Read",
"performs",
"the",
"role",
"lookup",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_identity_role_v3.go#L38-L74 | train |
terraform-providers/terraform-provider-openstack | openstack/identity_role_assignment_v3.go | identityRoleAssignmentV3ID | func identityRoleAssignmentV3ID(domainID, projectID, groupID, userID, roleID string) string {
return fmt.Sprintf("%s/%s/%s/%s/%s", domainID, projectID, groupID, userID, roleID)
} | go | func identityRoleAssignmentV3ID(domainID, projectID, groupID, userID, roleID string) string {
return fmt.Sprintf("%s/%s/%s/%s/%s", domainID, projectID, groupID, userID, roleID)
} | [
"func",
"identityRoleAssignmentV3ID",
"(",
"domainID",
",",
"projectID",
",",
"groupID",
",",
"userID",
",",
"roleID",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"domainID",
",",
"projectID",
",",
"groupID",
",",
"userID",
",",
"roleID",
")",
"\n",
"}"
] | // Role assignments have no ID in OpenStack.
// Build an ID out of the IDs that make up the role assignment | [
"Role",
"assignments",
"have",
"no",
"ID",
"in",
"OpenStack",
".",
"Build",
"an",
"ID",
"out",
"of",
"the",
"IDs",
"that",
"make",
"up",
"the",
"role",
"assignment"
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/identity_role_assignment_v3.go#L14-L16 | train |
terraform-providers/terraform-provider-openstack | openstack/resource_openstack_networking_subnet_v2.go | resourceSubnetAllocationPoolsCreateV2 | func resourceSubnetAllocationPoolsCreateV2(d *schema.ResourceData) []subnets.AllocationPool {
// First check allocation_pool since that is the new argument.
rawAPs := d.Get("allocation_pool").(*schema.Set).List()
if len(rawAPs) == 0 {
// If no allocation_pool was specified, check allocation_pools
// which is the older legacy argument.
rawAPs = d.Get("allocation_pools").([]interface{})
}
aps := make([]subnets.AllocationPool, len(rawAPs))
for i, raw := range rawAPs {
rawMap := raw.(map[string]interface{})
aps[i] = subnets.AllocationPool{
Start: rawMap["start"].(string),
End: rawMap["end"].(string),
}
}
return aps
} | go | func resourceSubnetAllocationPoolsCreateV2(d *schema.ResourceData) []subnets.AllocationPool {
// First check allocation_pool since that is the new argument.
rawAPs := d.Get("allocation_pool").(*schema.Set).List()
if len(rawAPs) == 0 {
// If no allocation_pool was specified, check allocation_pools
// which is the older legacy argument.
rawAPs = d.Get("allocation_pools").([]interface{})
}
aps := make([]subnets.AllocationPool, len(rawAPs))
for i, raw := range rawAPs {
rawMap := raw.(map[string]interface{})
aps[i] = subnets.AllocationPool{
Start: rawMap["start"].(string),
End: rawMap["end"].(string),
}
}
return aps
} | [
"func",
"resourceSubnetAllocationPoolsCreateV2",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
")",
"[",
"]",
"subnets",
".",
"AllocationPool",
"{",
"// First check allocation_pool since that is the new argument.",
"rawAPs",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"*",
"schema",
".",
"Set",
")",
".",
"List",
"(",
")",
"\n\n",
"if",
"len",
"(",
"rawAPs",
")",
"==",
"0",
"{",
"// If no allocation_pool was specified, check allocation_pools",
"// which is the older legacy argument.",
"rawAPs",
"=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"aps",
":=",
"make",
"(",
"[",
"]",
"subnets",
".",
"AllocationPool",
",",
"len",
"(",
"rawAPs",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"rawAPs",
"{",
"rawMap",
":=",
"raw",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"aps",
"[",
"i",
"]",
"=",
"subnets",
".",
"AllocationPool",
"{",
"Start",
":",
"rawMap",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
",",
"End",
":",
"rawMap",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"aps",
"\n",
"}"
] | // resourceSubnetAllocationPoolsCreateV2 returns a slice of allocation pools
// when creating a subnet. It takes into account both the old allocation_pools
// argument as well as the new allocation_pool argument.
//
// This can be modified to only account for allocation_pool when
// allocation_pools is removed. | [
"resourceSubnetAllocationPoolsCreateV2",
"returns",
"a",
"slice",
"of",
"allocation",
"pools",
"when",
"creating",
"a",
"subnet",
".",
"It",
"takes",
"into",
"account",
"both",
"the",
"old",
"allocation_pools",
"argument",
"as",
"well",
"as",
"the",
"new",
"allocation_pool",
"argument",
".",
"This",
"can",
"be",
"modified",
"to",
"only",
"account",
"for",
"allocation_pool",
"when",
"allocation_pools",
"is",
"removed",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/resource_openstack_networking_subnet_v2.go#L474-L493 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_identity_project_v3.go | dataSourceIdentityProjectV3Read | func dataSourceIdentityProjectV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
enabled := d.Get("enabled").(bool)
isDomain := d.Get("is_domain").(bool)
listOpts := projects.ListOpts{
DomainID: d.Get("domain_id").(string),
Enabled: &enabled,
IsDomain: &isDomain,
Name: d.Get("name").(string),
ParentID: d.Get("parent_id").(string),
}
log.Printf("[DEBUG] openstack_identity_project_v3 list options: %#v", listOpts)
var project projects.Project
allPages, err := projects.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_project_v3: %s", err)
}
allProjects, err := projects.ExtractProjects(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_project_v3: %s", err)
}
if len(allProjects) < 1 {
return fmt.Errorf("Your openstack_identity_project_v3 query returned no results. " +
"Please change your search criteria and try again.")
}
if len(allProjects) > 1 {
return fmt.Errorf("Your openstack_identity_project_v3 query returned more than one result.")
}
project = allProjects[0]
return dataSourceIdentityProjectV3Attributes(d, &project)
} | go | func dataSourceIdentityProjectV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
enabled := d.Get("enabled").(bool)
isDomain := d.Get("is_domain").(bool)
listOpts := projects.ListOpts{
DomainID: d.Get("domain_id").(string),
Enabled: &enabled,
IsDomain: &isDomain,
Name: d.Get("name").(string),
ParentID: d.Get("parent_id").(string),
}
log.Printf("[DEBUG] openstack_identity_project_v3 list options: %#v", listOpts)
var project projects.Project
allPages, err := projects.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_project_v3: %s", err)
}
allProjects, err := projects.ExtractProjects(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_project_v3: %s", err)
}
if len(allProjects) < 1 {
return fmt.Errorf("Your openstack_identity_project_v3 query returned no results. " +
"Please change your search criteria and try again.")
}
if len(allProjects) > 1 {
return fmt.Errorf("Your openstack_identity_project_v3 query returned more than one result.")
}
project = allProjects[0]
return dataSourceIdentityProjectV3Attributes(d, &project)
} | [
"func",
"dataSourceIdentityProjectV3Read",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
")",
"error",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n",
"identityClient",
",",
"err",
":=",
"config",
".",
"identityV3Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"enabled",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"bool",
")",
"\n",
"isDomain",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"bool",
")",
"\n",
"listOpts",
":=",
"projects",
".",
"ListOpts",
"{",
"DomainID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"Enabled",
":",
"&",
"enabled",
",",
"IsDomain",
":",
"&",
"isDomain",
",",
"Name",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"ParentID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"listOpts",
")",
"\n\n",
"var",
"project",
"projects",
".",
"Project",
"\n",
"allPages",
",",
"err",
":=",
"projects",
".",
"List",
"(",
"identityClient",
",",
"listOpts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allProjects",
",",
"err",
":=",
"projects",
".",
"ExtractProjects",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allProjects",
")",
"<",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allProjects",
")",
">",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"project",
"=",
"allProjects",
"[",
"0",
"]",
"\n\n",
"return",
"dataSourceIdentityProjectV3Attributes",
"(",
"d",
",",
"&",
"project",
")",
"\n",
"}"
] | // dataSourceIdentityProjectV3Read performs the project lookup. | [
"dataSourceIdentityProjectV3Read",
"performs",
"the",
"project",
"lookup",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_identity_project_v3.go#L60-L102 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_identity_project_v3.go | dataSourceIdentityProjectV3Attributes | func dataSourceIdentityProjectV3Attributes(d *schema.ResourceData, project *projects.Project) error {
log.Printf("[DEBUG] openstack_identity_project_v3 details: %#v", project)
d.SetId(project.ID)
d.Set("is_domain", project.IsDomain)
d.Set("description", project.Description)
d.Set("domain_id", project.DomainID)
d.Set("enabled", project.Enabled)
d.Set("name", project.Name)
d.Set("parent_id", project.ParentID)
return nil
} | go | func dataSourceIdentityProjectV3Attributes(d *schema.ResourceData, project *projects.Project) error {
log.Printf("[DEBUG] openstack_identity_project_v3 details: %#v", project)
d.SetId(project.ID)
d.Set("is_domain", project.IsDomain)
d.Set("description", project.Description)
d.Set("domain_id", project.DomainID)
d.Set("enabled", project.Enabled)
d.Set("name", project.Name)
d.Set("parent_id", project.ParentID)
return nil
} | [
"func",
"dataSourceIdentityProjectV3Attributes",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"project",
"*",
"projects",
".",
"Project",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"project",
")",
"\n\n",
"d",
".",
"SetId",
"(",
"project",
".",
"ID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"project",
".",
"IsDomain",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"project",
".",
"Description",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"project",
".",
"DomainID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"project",
".",
"Enabled",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"project",
".",
"Name",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"project",
".",
"ParentID",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // dataSourceIdentityProjectV3Attributes populates the fields of an Project resource. | [
"dataSourceIdentityProjectV3Attributes",
"populates",
"the",
"fields",
"of",
"an",
"Project",
"resource",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_identity_project_v3.go#L105-L117 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_compute_flavor_v2.go | dataSourceComputeFlavorV2Attributes | func dataSourceComputeFlavorV2Attributes(
d *schema.ResourceData, computeClient *gophercloud.ServiceClient, flavor *flavors.Flavor) error {
log.Printf("[DEBUG] Retrieved openstack_compute_flavor_v2 %s: %#v", flavor.ID, flavor)
d.SetId(flavor.ID)
d.Set("name", flavor.Name)
d.Set("flavor_id", flavor.ID)
d.Set("disk", flavor.Disk)
d.Set("ram", flavor.RAM)
d.Set("rx_tx_factor", flavor.RxTxFactor)
d.Set("swap", flavor.Swap)
d.Set("vcpus", flavor.VCPUs)
d.Set("is_public", flavor.IsPublic)
es, err := flavors.ListExtraSpecs(computeClient, d.Id()).Extract()
if err != nil {
return err
}
if err := d.Set("extra_specs", es); err != nil {
log.Printf("[WARN] Unable to set extra_specs for openstack_compute_flavor_v2 %s: %s", d.Id(), err)
}
return nil
} | go | func dataSourceComputeFlavorV2Attributes(
d *schema.ResourceData, computeClient *gophercloud.ServiceClient, flavor *flavors.Flavor) error {
log.Printf("[DEBUG] Retrieved openstack_compute_flavor_v2 %s: %#v", flavor.ID, flavor)
d.SetId(flavor.ID)
d.Set("name", flavor.Name)
d.Set("flavor_id", flavor.ID)
d.Set("disk", flavor.Disk)
d.Set("ram", flavor.RAM)
d.Set("rx_tx_factor", flavor.RxTxFactor)
d.Set("swap", flavor.Swap)
d.Set("vcpus", flavor.VCPUs)
d.Set("is_public", flavor.IsPublic)
es, err := flavors.ListExtraSpecs(computeClient, d.Id()).Extract()
if err != nil {
return err
}
if err := d.Set("extra_specs", es); err != nil {
log.Printf("[WARN] Unable to set extra_specs for openstack_compute_flavor_v2 %s: %s", d.Id(), err)
}
return nil
} | [
"func",
"dataSourceComputeFlavorV2Attributes",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"computeClient",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"flavor",
"*",
"flavors",
".",
"Flavor",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"flavor",
".",
"ID",
",",
"flavor",
")",
"\n\n",
"d",
".",
"SetId",
"(",
"flavor",
".",
"ID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"flavor",
".",
"Name",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"flavor",
".",
"ID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"flavor",
".",
"Disk",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"flavor",
".",
"RAM",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"flavor",
".",
"RxTxFactor",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"flavor",
".",
"Swap",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"flavor",
".",
"VCPUs",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"flavor",
".",
"IsPublic",
")",
"\n\n",
"es",
",",
"err",
":=",
"flavors",
".",
"ListExtraSpecs",
"(",
"computeClient",
",",
"d",
".",
"Id",
"(",
")",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"es",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"d",
".",
"Id",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // dataSourceComputeFlavorV2Attributes populates the fields of a Flavor resource. | [
"dataSourceComputeFlavorV2Attributes",
"populates",
"the",
"fields",
"of",
"a",
"Flavor",
"resource",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_compute_flavor_v2.go#L198-L223 | train |
terraform-providers/terraform-provider-openstack | openstack/resource_openstack_objectstorage_tempurl_v1.go | resourceObjectstorageTempurlV1Create | func resourceObjectstorageTempurlV1Create(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
objectStorageClient, err := config.objectStorageV1Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack compute client: %s", err)
}
method := objects.GET
switch d.Get("method") {
case "post":
method = objects.POST
// gophercloud doesn't have support for PUT yet,
// although it's a valid method for swift
//case "put":
// method = objects.PUT
}
turlOptions := objects.CreateTempURLOpts{
Method: method,
TTL: d.Get("ttl").(int),
Split: d.Get("split").(string),
}
containerName := d.Get("container").(string)
objectName := d.Get("object").(string)
log.Printf("[DEBUG] Create temporary url Options: %#v", turlOptions)
url, err := objects.CreateTempURL(objectStorageClient, containerName, objectName, turlOptions)
if err != nil {
return fmt.Errorf("Unable to generate a temporary url for the object %s in container %s: %s",
objectName, containerName, err)
}
log.Printf("[DEBUG] URL Generated: %s", url)
// Set the URL and Id fields.
hasher := md5.New()
hasher.Write([]byte(url))
d.SetId(hex.EncodeToString(hasher.Sum(nil)))
d.Set("url", url)
return nil
} | go | func resourceObjectstorageTempurlV1Create(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
objectStorageClient, err := config.objectStorageV1Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack compute client: %s", err)
}
method := objects.GET
switch d.Get("method") {
case "post":
method = objects.POST
// gophercloud doesn't have support for PUT yet,
// although it's a valid method for swift
//case "put":
// method = objects.PUT
}
turlOptions := objects.CreateTempURLOpts{
Method: method,
TTL: d.Get("ttl").(int),
Split: d.Get("split").(string),
}
containerName := d.Get("container").(string)
objectName := d.Get("object").(string)
log.Printf("[DEBUG] Create temporary url Options: %#v", turlOptions)
url, err := objects.CreateTempURL(objectStorageClient, containerName, objectName, turlOptions)
if err != nil {
return fmt.Errorf("Unable to generate a temporary url for the object %s in container %s: %s",
objectName, containerName, err)
}
log.Printf("[DEBUG] URL Generated: %s", url)
// Set the URL and Id fields.
hasher := md5.New()
hasher.Write([]byte(url))
d.SetId(hex.EncodeToString(hasher.Sum(nil)))
d.Set("url", url)
return nil
} | [
"func",
"resourceObjectstorageTempurlV1Create",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
")",
"error",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n",
"objectStorageClient",
",",
"err",
":=",
"config",
".",
"objectStorageV1Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"method",
":=",
"objects",
".",
"GET",
"\n",
"switch",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
"{",
"case",
"\"",
"\"",
":",
"method",
"=",
"objects",
".",
"POST",
"\n",
"// gophercloud doesn't have support for PUT yet,",
"// although it's a valid method for swift",
"//case \"put\":",
"//\tmethod = objects.PUT",
"}",
"\n\n",
"turlOptions",
":=",
"objects",
".",
"CreateTempURLOpts",
"{",
"Method",
":",
"method",
",",
"TTL",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"int",
")",
",",
"Split",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"}",
"\n\n",
"containerName",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
"\n",
"objectName",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"turlOptions",
")",
"\n\n",
"url",
",",
"err",
":=",
"objects",
".",
"CreateTempURL",
"(",
"objectStorageClient",
",",
"containerName",
",",
"objectName",
",",
"turlOptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"objectName",
",",
"containerName",
",",
"err",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"url",
")",
"\n\n",
"// Set the URL and Id fields.",
"hasher",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"hasher",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"url",
")",
")",
"\n",
"d",
".",
"SetId",
"(",
"hex",
".",
"EncodeToString",
"(",
"hasher",
".",
"Sum",
"(",
"nil",
")",
")",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"url",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // resourceObjectstorageTempurlV1Create performs the image lookup. | [
"resourceObjectstorageTempurlV1Create",
"performs",
"the",
"image",
"lookup",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/resource_openstack_objectstorage_tempurl_v1.go#L85-L127 | train |
terraform-providers/terraform-provider-openstack | openstack/resource_openstack_objectstorage_tempurl_v1.go | resourceObjectstorageTempurlV1Read | func resourceObjectstorageTempurlV1Read(d *schema.ResourceData, meta interface{}) error {
turl := d.Get("url").(string)
u, err := url.Parse(turl)
if err != nil {
return fmt.Errorf("Failed to read the temporary url %s: %s", turl, err)
}
qp, err := url.ParseQuery(u.RawQuery)
if err != nil {
return fmt.Errorf("Failed to parse the temporary url %s query string: %s", turl, err)
}
tempURLExpires := qp.Get("temp_url_expires")
expiry, err := strconv.ParseInt(tempURLExpires, 10, 64)
if err != nil {
return fmt.Errorf(
"Failed to parse the temporary url %s expiration time %s: %s",
turl, tempURLExpires, err)
}
// Regenerate the URL if it has expired and if the user requested it to be.
regen := d.Get("regenerate").(bool)
now := time.Now().Unix()
if expiry < now && regen {
log.Printf("[DEBUG] temporary url %s expired, generating a new one", turl)
d.SetId("")
}
return nil
} | go | func resourceObjectstorageTempurlV1Read(d *schema.ResourceData, meta interface{}) error {
turl := d.Get("url").(string)
u, err := url.Parse(turl)
if err != nil {
return fmt.Errorf("Failed to read the temporary url %s: %s", turl, err)
}
qp, err := url.ParseQuery(u.RawQuery)
if err != nil {
return fmt.Errorf("Failed to parse the temporary url %s query string: %s", turl, err)
}
tempURLExpires := qp.Get("temp_url_expires")
expiry, err := strconv.ParseInt(tempURLExpires, 10, 64)
if err != nil {
return fmt.Errorf(
"Failed to parse the temporary url %s expiration time %s: %s",
turl, tempURLExpires, err)
}
// Regenerate the URL if it has expired and if the user requested it to be.
regen := d.Get("regenerate").(bool)
now := time.Now().Unix()
if expiry < now && regen {
log.Printf("[DEBUG] temporary url %s expired, generating a new one", turl)
d.SetId("")
}
return nil
} | [
"func",
"resourceObjectstorageTempurlV1Read",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
")",
"error",
"{",
"turl",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"turl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"turl",
",",
"err",
")",
"\n",
"}",
"\n\n",
"qp",
",",
"err",
":=",
"url",
".",
"ParseQuery",
"(",
"u",
".",
"RawQuery",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"turl",
",",
"err",
")",
"\n",
"}",
"\n\n",
"tempURLExpires",
":=",
"qp",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"expiry",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"tempURLExpires",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"turl",
",",
"tempURLExpires",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Regenerate the URL if it has expired and if the user requested it to be.",
"regen",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"bool",
")",
"\n",
"now",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"\n",
"if",
"expiry",
"<",
"now",
"&&",
"regen",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"turl",
")",
"\n",
"d",
".",
"SetId",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // resourceObjectstorageTempurlV1Read performs the image lookup. | [
"resourceObjectstorageTempurlV1Read",
"performs",
"the",
"image",
"lookup",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/resource_openstack_objectstorage_tempurl_v1.go#L130-L159 | train |
terraform-providers/terraform-provider-openstack | openstack/util.go | BuildRequest | func BuildRequest(opts interface{}, parent string) (map[string]interface{}, error) {
b, err := gophercloud.BuildRequestBody(opts, "")
if err != nil {
return nil, err
}
b = AddValueSpecs(b)
return map[string]interface{}{parent: b}, nil
} | go | func BuildRequest(opts interface{}, parent string) (map[string]interface{}, error) {
b, err := gophercloud.BuildRequestBody(opts, "")
if err != nil {
return nil, err
}
b = AddValueSpecs(b)
return map[string]interface{}{parent: b}, nil
} | [
"func",
"BuildRequest",
"(",
"opts",
"interface",
"{",
"}",
",",
"parent",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"gophercloud",
".",
"BuildRequestBody",
"(",
"opts",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"b",
"=",
"AddValueSpecs",
"(",
"b",
")",
"\n\n",
"return",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"parent",
":",
"b",
"}",
",",
"nil",
"\n",
"}"
] | // BuildRequest takes an opts struct and builds a request body for
// Gophercloud to execute | [
"BuildRequest",
"takes",
"an",
"opts",
"struct",
"and",
"builds",
"a",
"request",
"body",
"for",
"Gophercloud",
"to",
"execute"
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/util.go#L22-L31 | train |
terraform-providers/terraform-provider-openstack | openstack/util.go | GetRegion | func GetRegion(d *schema.ResourceData, config *Config) string {
if v, ok := d.GetOk("region"); ok {
return v.(string)
}
return config.Region
} | go | func GetRegion(d *schema.ResourceData, config *Config) string {
if v, ok := d.GetOk("region"); ok {
return v.(string)
}
return config.Region
} | [
"func",
"GetRegion",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"config",
"*",
"Config",
")",
"string",
"{",
"if",
"v",
",",
"ok",
":=",
"d",
".",
"GetOk",
"(",
"\"",
"\"",
")",
";",
"ok",
"{",
"return",
"v",
".",
"(",
"string",
")",
"\n",
"}",
"\n\n",
"return",
"config",
".",
"Region",
"\n",
"}"
] | // GetRegion returns the region that was specified in the resource. If a
// region was not set, the provider-level region is checked. The provider-level
// region can either be set by the region argument or by OS_REGION_NAME. | [
"GetRegion",
"returns",
"the",
"region",
"that",
"was",
"specified",
"in",
"the",
"resource",
".",
"If",
"a",
"region",
"was",
"not",
"set",
"the",
"provider",
"-",
"level",
"region",
"is",
"checked",
".",
"The",
"provider",
"-",
"level",
"region",
"can",
"either",
"be",
"set",
"by",
"the",
"region",
"argument",
"or",
"by",
"OS_REGION_NAME",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/util.go#L47-L53 | train |
terraform-providers/terraform-provider-openstack | openstack/util.go | AddValueSpecs | func AddValueSpecs(body map[string]interface{}) map[string]interface{} {
if body["value_specs"] != nil {
for k, v := range body["value_specs"].(map[string]interface{}) {
body[k] = v
}
delete(body, "value_specs")
}
return body
} | go | func AddValueSpecs(body map[string]interface{}) map[string]interface{} {
if body["value_specs"] != nil {
for k, v := range body["value_specs"].(map[string]interface{}) {
body[k] = v
}
delete(body, "value_specs")
}
return body
} | [
"func",
"AddValueSpecs",
"(",
"body",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"if",
"body",
"[",
"\"",
"\"",
"]",
"!=",
"nil",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"body",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"body",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"delete",
"(",
"body",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"body",
"\n",
"}"
] | // AddValueSpecs expands the 'value_specs' object and removes 'value_specs'
// from the reqeust body. | [
"AddValueSpecs",
"expands",
"the",
"value_specs",
"object",
"and",
"removes",
"value_specs",
"from",
"the",
"reqeust",
"body",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/util.go#L57-L66 | train |
terraform-providers/terraform-provider-openstack | openstack/util.go | MapValueSpecs | func MapValueSpecs(d *schema.ResourceData) map[string]string {
m := make(map[string]string)
for key, val := range d.Get("value_specs").(map[string]interface{}) {
m[key] = val.(string)
}
return m
} | go | func MapValueSpecs(d *schema.ResourceData) map[string]string {
m := make(map[string]string)
for key, val := range d.Get("value_specs").(map[string]interface{}) {
m[key] = val.(string)
}
return m
} | [
"func",
"MapValueSpecs",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"key",
",",
"val",
":=",
"range",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"m",
"[",
"key",
"]",
"=",
"val",
".",
"(",
"string",
")",
"\n",
"}",
"\n",
"return",
"m",
"\n",
"}"
] | // MapValueSpecs converts ResourceData into a map | [
"MapValueSpecs",
"converts",
"ResourceData",
"into",
"a",
"map"
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/util.go#L69-L75 | train |
terraform-providers/terraform-provider-openstack | openstack/util.go | RedactHeaders | func RedactHeaders(headers http.Header) (processedHeaders []string) {
for name, header := range headers {
for _, v := range header {
if com.IsSliceContainsStr(REDACT_HEADERS, name) {
processedHeaders = append(processedHeaders, fmt.Sprintf("%v: %v", name, "***"))
} else {
processedHeaders = append(processedHeaders, fmt.Sprintf("%v: %v", name, v))
}
}
}
return
} | go | func RedactHeaders(headers http.Header) (processedHeaders []string) {
for name, header := range headers {
for _, v := range header {
if com.IsSliceContainsStr(REDACT_HEADERS, name) {
processedHeaders = append(processedHeaders, fmt.Sprintf("%v: %v", name, "***"))
} else {
processedHeaders = append(processedHeaders, fmt.Sprintf("%v: %v", name, v))
}
}
}
return
} | [
"func",
"RedactHeaders",
"(",
"headers",
"http",
".",
"Header",
")",
"(",
"processedHeaders",
"[",
"]",
"string",
")",
"{",
"for",
"name",
",",
"header",
":=",
"range",
"headers",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"header",
"{",
"if",
"com",
".",
"IsSliceContainsStr",
"(",
"REDACT_HEADERS",
",",
"name",
")",
"{",
"processedHeaders",
"=",
"append",
"(",
"processedHeaders",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"name",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"else",
"{",
"processedHeaders",
"=",
"append",
"(",
"processedHeaders",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"name",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // RedactHeaders processes a headers object, returning a redacted list | [
"RedactHeaders",
"processes",
"a",
"headers",
"object",
"returning",
"a",
"redacted",
"list"
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/util.go#L84-L95 | train |
terraform-providers/terraform-provider-openstack | openstack/util.go | FormatHeaders | func FormatHeaders(headers http.Header, seperator string) string {
redactedHeaders := RedactHeaders(headers)
sort.Strings(redactedHeaders)
return strings.Join(redactedHeaders, seperator)
} | go | func FormatHeaders(headers http.Header, seperator string) string {
redactedHeaders := RedactHeaders(headers)
sort.Strings(redactedHeaders)
return strings.Join(redactedHeaders, seperator)
} | [
"func",
"FormatHeaders",
"(",
"headers",
"http",
".",
"Header",
",",
"seperator",
"string",
")",
"string",
"{",
"redactedHeaders",
":=",
"RedactHeaders",
"(",
"headers",
")",
"\n",
"sort",
".",
"Strings",
"(",
"redactedHeaders",
")",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"redactedHeaders",
",",
"seperator",
")",
"\n",
"}"
] | // FormatHeaders processes a headers object plus a deliminator, returning a string | [
"FormatHeaders",
"processes",
"a",
"headers",
"object",
"plus",
"a",
"deliminator",
"returning",
"a",
"string"
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/util.go#L98-L103 | train |
terraform-providers/terraform-provider-openstack | openstack/util.go | compatibleMicroversion | func compatibleMicroversion(direction, required, given string) (bool, error) {
if direction != "min" && direction != "max" {
return false, fmt.Errorf("Invalid microversion direction %s. Must be min or max", direction)
}
if required == "" || given == "" {
return false, nil
}
requiredParts := strings.Split(required, ".")
if len(requiredParts) != 2 {
return false, fmt.Errorf("Not a valid microversion: %s", required)
}
givenParts := strings.Split(given, ".")
if len(givenParts) != 2 {
return false, fmt.Errorf("Not a valid microversion: %s", given)
}
requiredMajor, requiredMinor := requiredParts[0], requiredParts[1]
givenMajor, givenMinor := givenParts[0], givenParts[1]
requiredMajorInt, err := strconv.Atoi(requiredMajor)
if err != nil {
return false, fmt.Errorf("Unable to parse microversion: %s", required)
}
requiredMinorInt, err := strconv.Atoi(requiredMinor)
if err != nil {
return false, fmt.Errorf("Unable to parse microversion: %s", required)
}
givenMajorInt, err := strconv.Atoi(givenMajor)
if err != nil {
return false, fmt.Errorf("Unable to parse microversion: %s", given)
}
givenMinorInt, err := strconv.Atoi(givenMinor)
if err != nil {
return false, fmt.Errorf("Unable to parse microversion: %s", given)
}
switch direction {
case "min":
if requiredMajorInt == givenMajorInt {
if requiredMinorInt <= givenMinorInt {
return true, nil
}
}
case "max":
if requiredMajorInt == givenMajorInt {
if requiredMinorInt >= givenMinorInt {
return true, nil
}
}
}
return false, nil
} | go | func compatibleMicroversion(direction, required, given string) (bool, error) {
if direction != "min" && direction != "max" {
return false, fmt.Errorf("Invalid microversion direction %s. Must be min or max", direction)
}
if required == "" || given == "" {
return false, nil
}
requiredParts := strings.Split(required, ".")
if len(requiredParts) != 2 {
return false, fmt.Errorf("Not a valid microversion: %s", required)
}
givenParts := strings.Split(given, ".")
if len(givenParts) != 2 {
return false, fmt.Errorf("Not a valid microversion: %s", given)
}
requiredMajor, requiredMinor := requiredParts[0], requiredParts[1]
givenMajor, givenMinor := givenParts[0], givenParts[1]
requiredMajorInt, err := strconv.Atoi(requiredMajor)
if err != nil {
return false, fmt.Errorf("Unable to parse microversion: %s", required)
}
requiredMinorInt, err := strconv.Atoi(requiredMinor)
if err != nil {
return false, fmt.Errorf("Unable to parse microversion: %s", required)
}
givenMajorInt, err := strconv.Atoi(givenMajor)
if err != nil {
return false, fmt.Errorf("Unable to parse microversion: %s", given)
}
givenMinorInt, err := strconv.Atoi(givenMinor)
if err != nil {
return false, fmt.Errorf("Unable to parse microversion: %s", given)
}
switch direction {
case "min":
if requiredMajorInt == givenMajorInt {
if requiredMinorInt <= givenMinorInt {
return true, nil
}
}
case "max":
if requiredMajorInt == givenMajorInt {
if requiredMinorInt >= givenMinorInt {
return true, nil
}
}
}
return false, nil
} | [
"func",
"compatibleMicroversion",
"(",
"direction",
",",
"required",
",",
"given",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"direction",
"!=",
"\"",
"\"",
"&&",
"direction",
"!=",
"\"",
"\"",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"direction",
")",
"\n",
"}",
"\n\n",
"if",
"required",
"==",
"\"",
"\"",
"||",
"given",
"==",
"\"",
"\"",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"requiredParts",
":=",
"strings",
".",
"Split",
"(",
"required",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"requiredParts",
")",
"!=",
"2",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"required",
")",
"\n",
"}",
"\n\n",
"givenParts",
":=",
"strings",
".",
"Split",
"(",
"given",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"givenParts",
")",
"!=",
"2",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"given",
")",
"\n",
"}",
"\n\n",
"requiredMajor",
",",
"requiredMinor",
":=",
"requiredParts",
"[",
"0",
"]",
",",
"requiredParts",
"[",
"1",
"]",
"\n",
"givenMajor",
",",
"givenMinor",
":=",
"givenParts",
"[",
"0",
"]",
",",
"givenParts",
"[",
"1",
"]",
"\n\n",
"requiredMajorInt",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"requiredMajor",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"required",
")",
"\n",
"}",
"\n\n",
"requiredMinorInt",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"requiredMinor",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"required",
")",
"\n",
"}",
"\n\n",
"givenMajorInt",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"givenMajor",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"given",
")",
"\n",
"}",
"\n\n",
"givenMinorInt",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"givenMinor",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"given",
")",
"\n",
"}",
"\n\n",
"switch",
"direction",
"{",
"case",
"\"",
"\"",
":",
"if",
"requiredMajorInt",
"==",
"givenMajorInt",
"{",
"if",
"requiredMinorInt",
"<=",
"givenMinorInt",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"if",
"requiredMajorInt",
"==",
"givenMajorInt",
"{",
"if",
"requiredMinorInt",
">=",
"givenMinorInt",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // compatibleMicroversion will determine if an obtained microversion is
// compatible with a given microversion. | [
"compatibleMicroversion",
"will",
"determine",
"if",
"an",
"obtained",
"microversion",
"is",
"compatible",
"with",
"a",
"given",
"microversion",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/util.go#L278-L336 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_images_image_v2.go | dataSourceImagesImageV2Attributes | func dataSourceImagesImageV2Attributes(d *schema.ResourceData, image *images.Image) error {
log.Printf("[DEBUG] openstack_images_image details: %#v", image)
d.SetId(image.ID)
d.Set("name", image.Name)
d.Set("tags", image.Tags)
d.Set("container_format", image.ContainerFormat)
d.Set("disk_format", image.DiskFormat)
d.Set("min_disk_gb", image.MinDiskGigabytes)
d.Set("min_ram_mb", image.MinRAMMegabytes)
d.Set("owner", image.Owner)
d.Set("protected", image.Protected)
d.Set("visibility", image.Visibility)
d.Set("checksum", image.Checksum)
d.Set("size_bytes", image.SizeBytes)
d.Set("metadata", image.Metadata)
d.Set("created_at", image.CreatedAt.Format(time.RFC3339))
d.Set("updated_at", image.UpdatedAt.Format(time.RFC3339))
d.Set("file", image.File)
d.Set("schema", image.Schema)
return nil
} | go | func dataSourceImagesImageV2Attributes(d *schema.ResourceData, image *images.Image) error {
log.Printf("[DEBUG] openstack_images_image details: %#v", image)
d.SetId(image.ID)
d.Set("name", image.Name)
d.Set("tags", image.Tags)
d.Set("container_format", image.ContainerFormat)
d.Set("disk_format", image.DiskFormat)
d.Set("min_disk_gb", image.MinDiskGigabytes)
d.Set("min_ram_mb", image.MinRAMMegabytes)
d.Set("owner", image.Owner)
d.Set("protected", image.Protected)
d.Set("visibility", image.Visibility)
d.Set("checksum", image.Checksum)
d.Set("size_bytes", image.SizeBytes)
d.Set("metadata", image.Metadata)
d.Set("created_at", image.CreatedAt.Format(time.RFC3339))
d.Set("updated_at", image.UpdatedAt.Format(time.RFC3339))
d.Set("file", image.File)
d.Set("schema", image.Schema)
return nil
} | [
"func",
"dataSourceImagesImageV2Attributes",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"image",
"*",
"images",
".",
"Image",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"image",
")",
"\n\n",
"d",
".",
"SetId",
"(",
"image",
".",
"ID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"Name",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"Tags",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"ContainerFormat",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"DiskFormat",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"MinDiskGigabytes",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"MinRAMMegabytes",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"Owner",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"Protected",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"Visibility",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"Checksum",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"SizeBytes",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"Metadata",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"CreatedAt",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"UpdatedAt",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"File",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"image",
".",
"Schema",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // dataSourceImagesImageV2Attributes populates the fields of an Image resource. | [
"dataSourceImagesImageV2Attributes",
"populates",
"the",
"fields",
"of",
"an",
"Image",
"resource",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_images_image_v2.go#L262-L284 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_images_image_v2.go | mostRecentImage | func mostRecentImage(images []images.Image) images.Image {
sortedImages := images
sort.Sort(imageSort(sortedImages))
return sortedImages[len(sortedImages)-1]
} | go | func mostRecentImage(images []images.Image) images.Image {
sortedImages := images
sort.Sort(imageSort(sortedImages))
return sortedImages[len(sortedImages)-1]
} | [
"func",
"mostRecentImage",
"(",
"images",
"[",
"]",
"images",
".",
"Image",
")",
"images",
".",
"Image",
"{",
"sortedImages",
":=",
"images",
"\n",
"sort",
".",
"Sort",
"(",
"imageSort",
"(",
"sortedImages",
")",
")",
"\n",
"return",
"sortedImages",
"[",
"len",
"(",
"sortedImages",
")",
"-",
"1",
"]",
"\n",
"}"
] | // Returns the most recent Image out of a slice of images. | [
"Returns",
"the",
"most",
"recent",
"Image",
"out",
"of",
"a",
"slice",
"of",
"images",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_images_image_v2.go#L297-L301 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_identity_group_v3.go | dataSourceIdentityGroupV3Read | func dataSourceIdentityGroupV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
listOpts := groups.ListOpts{
DomainID: d.Get("domain_id").(string),
Name: d.Get("name").(string),
}
log.Printf("[DEBUG] openstack_identity_group_v3 list options: %#v", listOpts)
var group groups.Group
allPages, err := groups.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_group_v3: %s", err)
}
allGroups, err := groups.ExtractGroups(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_group_v3: %s", err)
}
if len(allGroups) < 1 {
return fmt.Errorf("Your openstack_identity_group_v3 query returned no results. " +
"Please change your search criteria and try again.")
}
if len(allGroups) > 1 {
return fmt.Errorf("Your openstack_identity_group_v3 query returned more than one result.")
}
group = allGroups[0]
return dataSourceIdentityGroupV3Attributes(d, config, &group)
} | go | func dataSourceIdentityGroupV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
listOpts := groups.ListOpts{
DomainID: d.Get("domain_id").(string),
Name: d.Get("name").(string),
}
log.Printf("[DEBUG] openstack_identity_group_v3 list options: %#v", listOpts)
var group groups.Group
allPages, err := groups.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_group_v3: %s", err)
}
allGroups, err := groups.ExtractGroups(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_group_v3: %s", err)
}
if len(allGroups) < 1 {
return fmt.Errorf("Your openstack_identity_group_v3 query returned no results. " +
"Please change your search criteria and try again.")
}
if len(allGroups) > 1 {
return fmt.Errorf("Your openstack_identity_group_v3 query returned more than one result.")
}
group = allGroups[0]
return dataSourceIdentityGroupV3Attributes(d, config, &group)
} | [
"func",
"dataSourceIdentityGroupV3Read",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
")",
"error",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n",
"identityClient",
",",
"err",
":=",
"config",
".",
"identityV3Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"listOpts",
":=",
"groups",
".",
"ListOpts",
"{",
"DomainID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"Name",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"listOpts",
")",
"\n\n",
"var",
"group",
"groups",
".",
"Group",
"\n",
"allPages",
",",
"err",
":=",
"groups",
".",
"List",
"(",
"identityClient",
",",
"listOpts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allGroups",
",",
"err",
":=",
"groups",
".",
"ExtractGroups",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allGroups",
")",
"<",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allGroups",
")",
">",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"group",
"=",
"allGroups",
"[",
"0",
"]",
"\n\n",
"return",
"dataSourceIdentityGroupV3Attributes",
"(",
"d",
",",
"config",
",",
"&",
"group",
")",
"\n",
"}"
] | // dataSourceIdentityGroupV3Read performs the group lookup. | [
"dataSourceIdentityGroupV3Read",
"performs",
"the",
"group",
"lookup",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_identity_group_v3.go#L38-L75 | train |
terraform-providers/terraform-provider-openstack | openstack/dns_recordset_v2.go | ToRecordSetCreateMap | func (opts RecordSetCreateOpts) ToRecordSetCreateMap() (map[string]interface{}, error) {
b, err := BuildRequest(opts, "")
if err != nil {
return nil, err
}
if m, ok := b[""].(map[string]interface{}); ok {
return m, nil
}
return nil, fmt.Errorf("Expected map but got %T", b[""])
} | go | func (opts RecordSetCreateOpts) ToRecordSetCreateMap() (map[string]interface{}, error) {
b, err := BuildRequest(opts, "")
if err != nil {
return nil, err
}
if m, ok := b[""].(map[string]interface{}); ok {
return m, nil
}
return nil, fmt.Errorf("Expected map but got %T", b[""])
} | [
"func",
"(",
"opts",
"RecordSetCreateOpts",
")",
"ToRecordSetCreateMap",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"BuildRequest",
"(",
"opts",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"m",
",",
"ok",
":=",
"b",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"return",
"m",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"b",
"[",
"\"",
"\"",
"]",
")",
"\n",
"}"
] | // ToRecordSetCreateMap casts a CreateOpts struct to a map.
// It overrides recordsets.ToRecordSetCreateMap to add the ValueSpecs field. | [
"ToRecordSetCreateMap",
"casts",
"a",
"CreateOpts",
"struct",
"to",
"a",
"map",
".",
"It",
"overrides",
"recordsets",
".",
"ToRecordSetCreateMap",
"to",
"add",
"the",
"ValueSpecs",
"field",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/dns_recordset_v2.go#L23-L34 | train |
terraform-providers/terraform-provider-openstack | openstack/dns_recordset_v2.go | dnsRecordSetV2RecordsStateFunc | func dnsRecordSetV2RecordsStateFunc(v interface{}) string {
if addr, ok := v.(string); ok {
re := regexp.MustCompile("[][]")
addr = re.ReplaceAllString(addr, "")
return addr
}
return ""
} | go | func dnsRecordSetV2RecordsStateFunc(v interface{}) string {
if addr, ok := v.(string); ok {
re := regexp.MustCompile("[][]")
addr = re.ReplaceAllString(addr, "")
return addr
}
return ""
} | [
"func",
"dnsRecordSetV2RecordsStateFunc",
"(",
"v",
"interface",
"{",
"}",
")",
"string",
"{",
"if",
"addr",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
";",
"ok",
"{",
"re",
":=",
"regexp",
".",
"MustCompile",
"(",
"\"",
"\"",
")",
"\n",
"addr",
"=",
"re",
".",
"ReplaceAllString",
"(",
"addr",
",",
"\"",
"\"",
")",
"\n\n",
"return",
"addr",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // dnsRecordSetV2RecordsStateFunc will strip brackets from IPv6 addresses. | [
"dnsRecordSetV2RecordsStateFunc",
"will",
"strip",
"brackets",
"from",
"IPv6",
"addresses",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/dns_recordset_v2.go#L82-L91 | train |
terraform-providers/terraform-provider-openstack | openstack/db_database_v1.go | databaseDatabaseV1StateRefreshFunc | func databaseDatabaseV1StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string, dbName string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
pages, err := databases.List(client, instanceID).AllPages()
if err != nil {
return nil, "", fmt.Errorf("Unable to retrieve OpenStack databases: %s", err)
}
allDatabases, err := databases.ExtractDBs(pages)
if err != nil {
return nil, "", fmt.Errorf("Unable to extract OpenStack databases: %s", err)
}
for _, v := range allDatabases {
if v.Name == dbName {
return v, "ACTIVE", nil
}
}
return nil, "BUILD", nil
}
} | go | func databaseDatabaseV1StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string, dbName string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
pages, err := databases.List(client, instanceID).AllPages()
if err != nil {
return nil, "", fmt.Errorf("Unable to retrieve OpenStack databases: %s", err)
}
allDatabases, err := databases.ExtractDBs(pages)
if err != nil {
return nil, "", fmt.Errorf("Unable to extract OpenStack databases: %s", err)
}
for _, v := range allDatabases {
if v.Name == dbName {
return v, "ACTIVE", nil
}
}
return nil, "BUILD", nil
}
} | [
"func",
"databaseDatabaseV1StateRefreshFunc",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"instanceID",
"string",
",",
"dbName",
"string",
")",
"resource",
".",
"StateRefreshFunc",
"{",
"return",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"string",
",",
"error",
")",
"{",
"pages",
",",
"err",
":=",
"databases",
".",
"List",
"(",
"client",
",",
"instanceID",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allDatabases",
",",
"err",
":=",
"databases",
".",
"ExtractDBs",
"(",
"pages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"allDatabases",
"{",
"if",
"v",
".",
"Name",
"==",
"dbName",
"{",
"return",
"v",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // databaseDatabaseV1StateRefreshFunc returns a resource.StateRefreshFunc
// that is used to watch a database. | [
"databaseDatabaseV1StateRefreshFunc",
"returns",
"a",
"resource",
".",
"StateRefreshFunc",
"that",
"is",
"used",
"to",
"watch",
"a",
"database",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/db_database_v1.go#L14-L34 | train |
terraform-providers/terraform-provider-openstack | openstack/db_user_v1.go | databaseUserV1StateRefreshFunc | func databaseUserV1StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string, userName string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
pages, err := users.List(client, instanceID).AllPages()
if err != nil {
return nil, "", fmt.Errorf("Unable to retrieve OpenStack database users: %s", err)
}
allUsers, err := users.ExtractUsers(pages)
if err != nil {
return nil, "", fmt.Errorf("Unable to extract OpenStack database users: %s", err)
}
for _, v := range allUsers {
if v.Name == userName {
return v, "ACTIVE", nil
}
}
return nil, "BUILD", nil
}
} | go | func databaseUserV1StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string, userName string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
pages, err := users.List(client, instanceID).AllPages()
if err != nil {
return nil, "", fmt.Errorf("Unable to retrieve OpenStack database users: %s", err)
}
allUsers, err := users.ExtractUsers(pages)
if err != nil {
return nil, "", fmt.Errorf("Unable to extract OpenStack database users: %s", err)
}
for _, v := range allUsers {
if v.Name == userName {
return v, "ACTIVE", nil
}
}
return nil, "BUILD", nil
}
} | [
"func",
"databaseUserV1StateRefreshFunc",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"instanceID",
"string",
",",
"userName",
"string",
")",
"resource",
".",
"StateRefreshFunc",
"{",
"return",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"string",
",",
"error",
")",
"{",
"pages",
",",
"err",
":=",
"users",
".",
"List",
"(",
"client",
",",
"instanceID",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allUsers",
",",
"err",
":=",
"users",
".",
"ExtractUsers",
"(",
"pages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"allUsers",
"{",
"if",
"v",
".",
"Name",
"==",
"userName",
"{",
"return",
"v",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // databaseUserV1StateRefreshFunc returns a resource.StateRefreshFunc that is used to watch db user. | [
"databaseUserV1StateRefreshFunc",
"returns",
"a",
"resource",
".",
"StateRefreshFunc",
"that",
"is",
"used",
"to",
"watch",
"db",
"user",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/db_user_v1.go#L35-L55 | train |
terraform-providers/terraform-provider-openstack | openstack/db_user_v1.go | databaseUserV1Exists | func databaseUserV1Exists(client *gophercloud.ServiceClient, instanceID string, userName string) (bool, users.User, error) {
var exists bool
var err error
var userObj users.User
pages, err := users.List(client, instanceID).AllPages()
if err != nil {
return exists, userObj, err
}
allUsers, err := users.ExtractUsers(pages)
if err != nil {
return exists, userObj, err
}
for _, v := range allUsers {
if v.Name == userName {
exists = true
return exists, v, nil
}
}
return false, userObj, err
} | go | func databaseUserV1Exists(client *gophercloud.ServiceClient, instanceID string, userName string) (bool, users.User, error) {
var exists bool
var err error
var userObj users.User
pages, err := users.List(client, instanceID).AllPages()
if err != nil {
return exists, userObj, err
}
allUsers, err := users.ExtractUsers(pages)
if err != nil {
return exists, userObj, err
}
for _, v := range allUsers {
if v.Name == userName {
exists = true
return exists, v, nil
}
}
return false, userObj, err
} | [
"func",
"databaseUserV1Exists",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"instanceID",
"string",
",",
"userName",
"string",
")",
"(",
"bool",
",",
"users",
".",
"User",
",",
"error",
")",
"{",
"var",
"exists",
"bool",
"\n",
"var",
"err",
"error",
"\n",
"var",
"userObj",
"users",
".",
"User",
"\n\n",
"pages",
",",
"err",
":=",
"users",
".",
"List",
"(",
"client",
",",
"instanceID",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"exists",
",",
"userObj",
",",
"err",
"\n",
"}",
"\n\n",
"allUsers",
",",
"err",
":=",
"users",
".",
"ExtractUsers",
"(",
"pages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"exists",
",",
"userObj",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"allUsers",
"{",
"if",
"v",
".",
"Name",
"==",
"userName",
"{",
"exists",
"=",
"true",
"\n",
"return",
"exists",
",",
"v",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"userObj",
",",
"err",
"\n",
"}"
] | // databaseUserV1Exists is used to check whether user exists on particular database instance | [
"databaseUserV1Exists",
"is",
"used",
"to",
"check",
"whether",
"user",
"exists",
"on",
"particular",
"database",
"instance"
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/db_user_v1.go#L58-L81 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_identity_user_v3.go | dataSourceIdentityUserV3Read | func dataSourceIdentityUserV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
enabled := d.Get("enabled").(bool)
listOpts := users.ListOpts{
DomainID: d.Get("domain_id").(string),
Enabled: &enabled,
IdPID: d.Get("idp_id").(string),
Name: d.Get("name").(string),
PasswordExpiresAt: d.Get("password_expires_at").(string),
ProtocolID: d.Get("protocol_id").(string),
UniqueID: d.Get("unique_id").(string),
}
log.Printf("[DEBUG] openstack_identity_user_v3 list options: %#v", listOpts)
var user users.User
allPages, err := users.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_user_v3: %s", err)
}
allUsers, err := users.ExtractUsers(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_user_v3: %s", err)
}
if len(allUsers) < 1 {
return fmt.Errorf("Your openstack_identity_user_v3 query returned no results. " +
"Please change your search criteria and try again.")
}
if len(allUsers) > 1 {
return fmt.Errorf("Your openstack_identity_user_v3 query returned more than one result.")
}
user = allUsers[0]
return dataSourceIdentityUserV3Attributes(d, &user)
} | go | func dataSourceIdentityUserV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
enabled := d.Get("enabled").(bool)
listOpts := users.ListOpts{
DomainID: d.Get("domain_id").(string),
Enabled: &enabled,
IdPID: d.Get("idp_id").(string),
Name: d.Get("name").(string),
PasswordExpiresAt: d.Get("password_expires_at").(string),
ProtocolID: d.Get("protocol_id").(string),
UniqueID: d.Get("unique_id").(string),
}
log.Printf("[DEBUG] openstack_identity_user_v3 list options: %#v", listOpts)
var user users.User
allPages, err := users.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_user_v3: %s", err)
}
allUsers, err := users.ExtractUsers(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_user_v3: %s", err)
}
if len(allUsers) < 1 {
return fmt.Errorf("Your openstack_identity_user_v3 query returned no results. " +
"Please change your search criteria and try again.")
}
if len(allUsers) > 1 {
return fmt.Errorf("Your openstack_identity_user_v3 query returned more than one result.")
}
user = allUsers[0]
return dataSourceIdentityUserV3Attributes(d, &user)
} | [
"func",
"dataSourceIdentityUserV3Read",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
")",
"error",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n",
"identityClient",
",",
"err",
":=",
"config",
".",
"identityV3Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"enabled",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"bool",
")",
"\n",
"listOpts",
":=",
"users",
".",
"ListOpts",
"{",
"DomainID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"Enabled",
":",
"&",
"enabled",
",",
"IdPID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"Name",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"PasswordExpiresAt",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"ProtocolID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"UniqueID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"listOpts",
")",
"\n\n",
"var",
"user",
"users",
".",
"User",
"\n",
"allPages",
",",
"err",
":=",
"users",
".",
"List",
"(",
"identityClient",
",",
"listOpts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allUsers",
",",
"err",
":=",
"users",
".",
"ExtractUsers",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allUsers",
")",
"<",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allUsers",
")",
">",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"user",
"=",
"allUsers",
"[",
"0",
"]",
"\n\n",
"return",
"dataSourceIdentityUserV3Attributes",
"(",
"d",
",",
"&",
"user",
")",
"\n",
"}"
] | // dataSourceIdentityUserV3Read performs the user lookup. | [
"dataSourceIdentityUserV3Read",
"performs",
"the",
"user",
"lookup",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_identity_user_v3.go#L71-L114 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_identity_user_v3.go | dataSourceIdentityUserV3Attributes | func dataSourceIdentityUserV3Attributes(d *schema.ResourceData, user *users.User) error {
log.Printf("[DEBUG] openstack_identity_user_v3 details: %#v", user)
d.SetId(user.ID)
d.Set("default_project_id", user.DefaultProjectID)
d.Set("description", user.Description)
d.Set("domain_id", user.DomainID)
d.Set("enabled", user.Enabled)
d.Set("name", user.Name)
d.Set("password_expires_at", user.PasswordExpiresAt.Format(time.RFC3339))
return nil
} | go | func dataSourceIdentityUserV3Attributes(d *schema.ResourceData, user *users.User) error {
log.Printf("[DEBUG] openstack_identity_user_v3 details: %#v", user)
d.SetId(user.ID)
d.Set("default_project_id", user.DefaultProjectID)
d.Set("description", user.Description)
d.Set("domain_id", user.DomainID)
d.Set("enabled", user.Enabled)
d.Set("name", user.Name)
d.Set("password_expires_at", user.PasswordExpiresAt.Format(time.RFC3339))
return nil
} | [
"func",
"dataSourceIdentityUserV3Attributes",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"user",
"*",
"users",
".",
"User",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"user",
")",
"\n\n",
"d",
".",
"SetId",
"(",
"user",
".",
"ID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"user",
".",
"DefaultProjectID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"user",
".",
"Description",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"user",
".",
"DomainID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"user",
".",
"Enabled",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"user",
".",
"Name",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"user",
".",
"PasswordExpiresAt",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // dataSourceIdentityUserV3Attributes populates the fields of an User resource. | [
"dataSourceIdentityUserV3Attributes",
"populates",
"the",
"fields",
"of",
"an",
"User",
"resource",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_identity_user_v3.go#L117-L129 | train |
terraform-providers/terraform-provider-openstack | openstack/db_configuration_v1.go | databaseConfigurationV1StateRefreshFunc | func databaseConfigurationV1StateRefreshFunc(client *gophercloud.ServiceClient, cgroupID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
i, err := configurations.Get(client, cgroupID).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
return i, "DELETED", nil
}
return nil, "", err
}
return i, "ACTIVE", nil
}
} | go | func databaseConfigurationV1StateRefreshFunc(client *gophercloud.ServiceClient, cgroupID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
i, err := configurations.Get(client, cgroupID).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
return i, "DELETED", nil
}
return nil, "", err
}
return i, "ACTIVE", nil
}
} | [
"func",
"databaseConfigurationV1StateRefreshFunc",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"cgroupID",
"string",
")",
"resource",
".",
"StateRefreshFunc",
"{",
"return",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"string",
",",
"error",
")",
"{",
"i",
",",
"err",
":=",
"configurations",
".",
"Get",
"(",
"client",
",",
"cgroupID",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"gophercloud",
".",
"ErrDefault404",
")",
";",
"ok",
"{",
"return",
"i",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"i",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // databaseConfigurationV1StateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
// an cloud database instance. | [
"databaseConfigurationV1StateRefreshFunc",
"returns",
"a",
"resource",
".",
"StateRefreshFunc",
"that",
"is",
"used",
"to",
"watch",
"an",
"cloud",
"database",
"instance",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/db_configuration_v1.go#L43-L55 | train |
terraform-providers/terraform-provider-openstack | openstack/resource_openstack_compute_instance_v2.go | ServerV2StateRefreshFunc | func ServerV2StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
s, err := servers.Get(client, instanceID).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
return s, "DELETED", nil
}
return nil, "", err
}
return s, s.Status, nil
}
} | go | func ServerV2StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
s, err := servers.Get(client, instanceID).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
return s, "DELETED", nil
}
return nil, "", err
}
return s, s.Status, nil
}
} | [
"func",
"ServerV2StateRefreshFunc",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"instanceID",
"string",
")",
"resource",
".",
"StateRefreshFunc",
"{",
"return",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"string",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"servers",
".",
"Get",
"(",
"client",
",",
"instanceID",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"gophercloud",
".",
"ErrDefault404",
")",
";",
"ok",
"{",
"return",
"s",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"s",
",",
"s",
".",
"Status",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // ServerV2StateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
// an OpenStack instance. | [
"ServerV2StateRefreshFunc",
"returns",
"a",
"resource",
".",
"StateRefreshFunc",
"that",
"is",
"used",
"to",
"watch",
"an",
"OpenStack",
"instance",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/resource_openstack_compute_instance_v2.go#L950-L962 | train |
terraform-providers/terraform-provider-openstack | openstack/config.go | determineEndpoint | func (c *Config) determineEndpoint(client *gophercloud.ServiceClient, service string) *gophercloud.ServiceClient {
finalEndpoint := client.ResourceBaseURL()
if v, ok := c.EndpointOverrides[service]; ok {
if endpoint, ok := v.(string); ok && endpoint != "" {
finalEndpoint = endpoint
client.Endpoint = endpoint
client.ResourceBase = ""
}
}
log.Printf("[DEBUG] OpenStack Endpoint for %s: %s", service, finalEndpoint)
return client
} | go | func (c *Config) determineEndpoint(client *gophercloud.ServiceClient, service string) *gophercloud.ServiceClient {
finalEndpoint := client.ResourceBaseURL()
if v, ok := c.EndpointOverrides[service]; ok {
if endpoint, ok := v.(string); ok && endpoint != "" {
finalEndpoint = endpoint
client.Endpoint = endpoint
client.ResourceBase = ""
}
}
log.Printf("[DEBUG] OpenStack Endpoint for %s: %s", service, finalEndpoint)
return client
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"determineEndpoint",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"service",
"string",
")",
"*",
"gophercloud",
".",
"ServiceClient",
"{",
"finalEndpoint",
":=",
"client",
".",
"ResourceBaseURL",
"(",
")",
"\n\n",
"if",
"v",
",",
"ok",
":=",
"c",
".",
"EndpointOverrides",
"[",
"service",
"]",
";",
"ok",
"{",
"if",
"endpoint",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
";",
"ok",
"&&",
"endpoint",
"!=",
"\"",
"\"",
"{",
"finalEndpoint",
"=",
"endpoint",
"\n",
"client",
".",
"Endpoint",
"=",
"endpoint",
"\n",
"client",
".",
"ResourceBase",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"service",
",",
"finalEndpoint",
")",
"\n\n",
"return",
"client",
"\n",
"}"
] | // determineEndpoint is a helper method to determine if the user wants to
// override an endpoint returned from the catalog. | [
"determineEndpoint",
"is",
"a",
"helper",
"method",
"to",
"determine",
"if",
"the",
"user",
"wants",
"to",
"override",
"an",
"endpoint",
"returned",
"from",
"the",
"catalog",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/config.go#L219-L233 | train |
terraform-providers/terraform-provider-openstack | openstack/config.go | determineRegion | func (c *Config) determineRegion(region string) string {
// If a resource-level region was not specified, and a provider-level region was set,
// use the provider-level region.
if region == "" && c.Region != "" {
region = c.Region
}
log.Printf("[DEBUG] OpenStack Region is: %s", region)
return region
} | go | func (c *Config) determineRegion(region string) string {
// If a resource-level region was not specified, and a provider-level region was set,
// use the provider-level region.
if region == "" && c.Region != "" {
region = c.Region
}
log.Printf("[DEBUG] OpenStack Region is: %s", region)
return region
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"determineRegion",
"(",
"region",
"string",
")",
"string",
"{",
"// If a resource-level region was not specified, and a provider-level region was set,",
"// use the provider-level region.",
"if",
"region",
"==",
"\"",
"\"",
"&&",
"c",
".",
"Region",
"!=",
"\"",
"\"",
"{",
"region",
"=",
"c",
".",
"Region",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"region",
")",
"\n",
"return",
"region",
"\n",
"}"
] | // determineRegion is a helper method to determine the region based on
// the user's settings. | [
"determineRegion",
"is",
"a",
"helper",
"method",
"to",
"determine",
"the",
"region",
"based",
"on",
"the",
"user",
"s",
"settings",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/config.go#L237-L246 | train |
terraform-providers/terraform-provider-openstack | openstack/config.go | blockStorageV1Client | func (c *Config) blockStorageV1Client(region string) (*gophercloud.ServiceClient, error) {
client, err := openstack.NewBlockStorageV1(c.OsClient, gophercloud.EndpointOpts{
Region: c.determineRegion(region),
Availability: c.getEndpointType(),
})
if err != nil {
return client, err
}
// Check if an endpoint override was specified for the volume service.
client = c.determineEndpoint(client, "volume")
return client, nil
} | go | func (c *Config) blockStorageV1Client(region string) (*gophercloud.ServiceClient, error) {
client, err := openstack.NewBlockStorageV1(c.OsClient, gophercloud.EndpointOpts{
Region: c.determineRegion(region),
Availability: c.getEndpointType(),
})
if err != nil {
return client, err
}
// Check if an endpoint override was specified for the volume service.
client = c.determineEndpoint(client, "volume")
return client, nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"blockStorageV1Client",
"(",
"region",
"string",
")",
"(",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"openstack",
".",
"NewBlockStorageV1",
"(",
"c",
".",
"OsClient",
",",
"gophercloud",
".",
"EndpointOpts",
"{",
"Region",
":",
"c",
".",
"determineRegion",
"(",
"region",
")",
",",
"Availability",
":",
"c",
".",
"getEndpointType",
"(",
")",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"client",
",",
"err",
"\n",
"}",
"\n\n",
"// Check if an endpoint override was specified for the volume service.",
"client",
"=",
"c",
".",
"determineEndpoint",
"(",
"client",
",",
"\"",
"\"",
")",
"\n\n",
"return",
"client",
",",
"nil",
"\n",
"}"
] | // The following methods assist with the creation of individual Service Clients
// which interact with the various OpenStack services. | [
"The",
"following",
"methods",
"assist",
"with",
"the",
"creation",
"of",
"individual",
"Service",
"Clients",
"which",
"interact",
"with",
"the",
"various",
"OpenStack",
"services",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/config.go#L263-L277 | train |
terraform-providers/terraform-provider-openstack | openstack/networking_network_v2.go | networkingNetworkV2Name | func networkingNetworkV2Name(d *schema.ResourceData, meta interface{}, networkID string) (string, error) {
config := meta.(*Config)
networkingClient, err := config.networkingV2Client(GetRegion(d, config))
if err != nil {
return "", fmt.Errorf("Error creating OpenStack network client: %s", err)
}
opts := networks.ListOpts{ID: networkID}
pager := networks.List(networkingClient, opts)
networkName := ""
err = pager.EachPage(func(page pagination.Page) (bool, error) {
networkList, err := networks.ExtractNetworks(page)
if err != nil {
return false, err
}
for _, n := range networkList {
if n.ID == networkID {
networkName = n.Name
return false, nil
}
}
return true, nil
})
return networkName, err
} | go | func networkingNetworkV2Name(d *schema.ResourceData, meta interface{}, networkID string) (string, error) {
config := meta.(*Config)
networkingClient, err := config.networkingV2Client(GetRegion(d, config))
if err != nil {
return "", fmt.Errorf("Error creating OpenStack network client: %s", err)
}
opts := networks.ListOpts{ID: networkID}
pager := networks.List(networkingClient, opts)
networkName := ""
err = pager.EachPage(func(page pagination.Page) (bool, error) {
networkList, err := networks.ExtractNetworks(page)
if err != nil {
return false, err
}
for _, n := range networkList {
if n.ID == networkID {
networkName = n.Name
return false, nil
}
}
return true, nil
})
return networkName, err
} | [
"func",
"networkingNetworkV2Name",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
",",
"networkID",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n",
"networkingClient",
",",
"err",
":=",
"config",
".",
"networkingV2Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"opts",
":=",
"networks",
".",
"ListOpts",
"{",
"ID",
":",
"networkID",
"}",
"\n",
"pager",
":=",
"networks",
".",
"List",
"(",
"networkingClient",
",",
"opts",
")",
"\n",
"networkName",
":=",
"\"",
"\"",
"\n\n",
"err",
"=",
"pager",
".",
"EachPage",
"(",
"func",
"(",
"page",
"pagination",
".",
"Page",
")",
"(",
"bool",
",",
"error",
")",
"{",
"networkList",
",",
"err",
":=",
"networks",
".",
"ExtractNetworks",
"(",
"page",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"n",
":=",
"range",
"networkList",
"{",
"if",
"n",
".",
"ID",
"==",
"networkID",
"{",
"networkName",
"=",
"n",
".",
"Name",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
",",
"nil",
"\n",
"}",
")",
"\n\n",
"return",
"networkName",
",",
"err",
"\n",
"}"
] | // networkingNetworkV2Name retrieves network name by the provided ID. | [
"networkingNetworkV2Name",
"retrieves",
"network",
"name",
"by",
"the",
"provided",
"ID",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/networking_network_v2.go#L62-L90 | train |
terraform-providers/terraform-provider-openstack | openstack/networking_floatingip_v2.go | networkingFloatingIPV2ID | func networkingFloatingIPV2ID(client *gophercloud.ServiceClient, floatingIP string) (string, error) {
listOpts := floatingips.ListOpts{
FloatingIP: floatingIP,
}
allPages, err := floatingips.List(client, listOpts).AllPages()
if err != nil {
return "", err
}
allFloatingIPs, err := floatingips.ExtractFloatingIPs(allPages)
if err != nil {
return "", err
}
if len(allFloatingIPs) == 0 {
return "", fmt.Errorf("there are no openstack_networking_floatingip_v2 with %s IP", floatingIP)
}
if len(allFloatingIPs) > 1 {
return "", fmt.Errorf("there are more than one openstack_networking_floatingip_v2 with %s IP", floatingIP)
}
return allFloatingIPs[0].ID, nil
} | go | func networkingFloatingIPV2ID(client *gophercloud.ServiceClient, floatingIP string) (string, error) {
listOpts := floatingips.ListOpts{
FloatingIP: floatingIP,
}
allPages, err := floatingips.List(client, listOpts).AllPages()
if err != nil {
return "", err
}
allFloatingIPs, err := floatingips.ExtractFloatingIPs(allPages)
if err != nil {
return "", err
}
if len(allFloatingIPs) == 0 {
return "", fmt.Errorf("there are no openstack_networking_floatingip_v2 with %s IP", floatingIP)
}
if len(allFloatingIPs) > 1 {
return "", fmt.Errorf("there are more than one openstack_networking_floatingip_v2 with %s IP", floatingIP)
}
return allFloatingIPs[0].ID, nil
} | [
"func",
"networkingFloatingIPV2ID",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"floatingIP",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"listOpts",
":=",
"floatingips",
".",
"ListOpts",
"{",
"FloatingIP",
":",
"floatingIP",
",",
"}",
"\n\n",
"allPages",
",",
"err",
":=",
"floatingips",
".",
"List",
"(",
"client",
",",
"listOpts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"allFloatingIPs",
",",
"err",
":=",
"floatingips",
".",
"ExtractFloatingIPs",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allFloatingIPs",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"floatingIP",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"allFloatingIPs",
")",
">",
"1",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"floatingIP",
")",
"\n",
"}",
"\n\n",
"return",
"allFloatingIPs",
"[",
"0",
"]",
".",
"ID",
",",
"nil",
"\n",
"}"
] | // networkingFloatingIPV2ID retrieves floating IP ID by the provided IP address. | [
"networkingFloatingIPV2ID",
"retrieves",
"floating",
"IP",
"ID",
"by",
"the",
"provided",
"IP",
"address",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/networking_floatingip_v2.go#L18-L41 | train |
terraform-providers/terraform-provider-openstack | openstack/containerinfra_shared_v1.go | containerInfraClusterV1StateRefreshFunc | func containerInfraClusterV1StateRefreshFunc(client *gophercloud.ServiceClient, clusterID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
c, err := clusters.Get(client, clusterID).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
return c, "DELETE_COMPLETE", nil
}
return nil, "", err
}
errorStatuses := []string{
"CREATE_FAILED",
"UPDATE_FAILED",
"DELETE_FAILED",
"RESUME_FAILED",
"ROLLBACK_FAILED",
}
for _, errorStatus := range errorStatuses {
if c.Status == errorStatus {
err = fmt.Errorf("openstack_containerinfra_cluster_v1 is in an error state: %s", c.StatusReason)
return c, c.Status, err
}
}
return c, c.Status, nil
}
} | go | func containerInfraClusterV1StateRefreshFunc(client *gophercloud.ServiceClient, clusterID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
c, err := clusters.Get(client, clusterID).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
return c, "DELETE_COMPLETE", nil
}
return nil, "", err
}
errorStatuses := []string{
"CREATE_FAILED",
"UPDATE_FAILED",
"DELETE_FAILED",
"RESUME_FAILED",
"ROLLBACK_FAILED",
}
for _, errorStatus := range errorStatuses {
if c.Status == errorStatus {
err = fmt.Errorf("openstack_containerinfra_cluster_v1 is in an error state: %s", c.StatusReason)
return c, c.Status, err
}
}
return c, c.Status, nil
}
} | [
"func",
"containerInfraClusterV1StateRefreshFunc",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"clusterID",
"string",
")",
"resource",
".",
"StateRefreshFunc",
"{",
"return",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"string",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"clusters",
".",
"Get",
"(",
"client",
",",
"clusterID",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"gophercloud",
".",
"ErrDefault404",
")",
";",
"ok",
"{",
"return",
"c",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"errorStatuses",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"}",
"\n",
"for",
"_",
",",
"errorStatus",
":=",
"range",
"errorStatuses",
"{",
"if",
"c",
".",
"Status",
"==",
"errorStatus",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
".",
"StatusReason",
")",
"\n",
"return",
"c",
",",
"c",
".",
"Status",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"c",
",",
"c",
".",
"Status",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // ContainerInfraClusterV1StateRefreshFunc returns a resource.StateRefreshFunc
// that is used to watch a container infra Cluster. | [
"ContainerInfraClusterV1StateRefreshFunc",
"returns",
"a",
"resource",
".",
"StateRefreshFunc",
"that",
"is",
"used",
"to",
"watch",
"a",
"container",
"infra",
"Cluster",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/containerinfra_shared_v1.go#L63-L89 | train |
terraform-providers/terraform-provider-openstack | openstack/containerinfra_shared_v1.go | containerInfraClusterV1Flavor | func containerInfraClusterV1Flavor(d *schema.ResourceData) (string, error) {
if flavor := d.Get("flavor").(string); flavor != "" {
return flavor, nil
}
// Try the OS_MAGNUM_FLAVOR environment variable
if v := os.Getenv("OS_MAGNUM_FLAVOR"); v != "" {
return v, nil
}
return "", nil
} | go | func containerInfraClusterV1Flavor(d *schema.ResourceData) (string, error) {
if flavor := d.Get("flavor").(string); flavor != "" {
return flavor, nil
}
// Try the OS_MAGNUM_FLAVOR environment variable
if v := os.Getenv("OS_MAGNUM_FLAVOR"); v != "" {
return v, nil
}
return "", nil
} | [
"func",
"containerInfraClusterV1Flavor",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"flavor",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
";",
"flavor",
"!=",
"\"",
"\"",
"{",
"return",
"flavor",
",",
"nil",
"\n",
"}",
"\n",
"// Try the OS_MAGNUM_FLAVOR environment variable",
"if",
"v",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
";",
"v",
"!=",
"\"",
"\"",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}"
] | // containerInfraClusterV1Flavor will determine the flavor for a container infra
// cluster based on either what was set in the configuration or environment
// variable. | [
"containerInfraClusterV1Flavor",
"will",
"determine",
"the",
"flavor",
"for",
"a",
"container",
"infra",
"cluster",
"based",
"on",
"either",
"what",
"was",
"set",
"in",
"the",
"configuration",
"or",
"environment",
"variable",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/containerinfra_shared_v1.go#L94-L104 | train |
terraform-providers/terraform-provider-openstack | openstack/fw_rule_v1.go | ToRuleCreateMap | func (opts RuleCreateOpts) ToRuleCreateMap() (map[string]interface{}, error) {
b, err := BuildRequest(opts, "firewall_rule")
if err != nil {
return nil, err
}
if m := b["firewall_rule"].(map[string]interface{}); m["protocol"] == "any" {
m["protocol"] = nil
}
return b, nil
} | go | func (opts RuleCreateOpts) ToRuleCreateMap() (map[string]interface{}, error) {
b, err := BuildRequest(opts, "firewall_rule")
if err != nil {
return nil, err
}
if m := b["firewall_rule"].(map[string]interface{}); m["protocol"] == "any" {
m["protocol"] = nil
}
return b, nil
} | [
"func",
"(",
"opts",
"RuleCreateOpts",
")",
"ToRuleCreateMap",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"BuildRequest",
"(",
"opts",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"m",
":=",
"b",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"m",
"[",
"\"",
"\"",
"]",
"==",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"nil",
"\n",
"}",
"\n\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] | // ToRuleCreateMap casts a CreateOpts struct to a map.
// It overrides rules.ToRuleCreateMap to add the ValueSpecs field. | [
"ToRuleCreateMap",
"casts",
"a",
"CreateOpts",
"struct",
"to",
"a",
"map",
".",
"It",
"overrides",
"rules",
".",
"ToRuleCreateMap",
"to",
"add",
"the",
"ValueSpecs",
"field",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/fw_rule_v1.go#L16-L27 | train |
terraform-providers/terraform-provider-openstack | openstack/compute_instance_v2_networking.go | getInstanceNetworkInfo | func getInstanceNetworkInfo(
d *schema.ResourceData, meta interface{}, queryType, queryTerm string) (map[string]interface{}, error) {
config := meta.(*Config)
if _, ok := os.LookupEnv("OS_NOVA_NETWORK"); !ok {
networkClient, err := config.networkingV2Client(GetRegion(d, config))
if err == nil {
networkInfo, err := getInstanceNetworkInfoNeutron(networkClient, queryType, queryTerm)
if err != nil {
return nil, fmt.Errorf("Error trying to get network information from the Network API: %s", err)
}
return networkInfo, nil
}
}
log.Printf("[DEBUG] Unable to obtain a network client")
computeClient, err := config.computeV2Client(GetRegion(d, config))
if err != nil {
return nil, fmt.Errorf("Error creating OpenStack compute client: %s", err)
}
networkInfo, err := getInstanceNetworkInfoNovaNet(computeClient, queryType, queryTerm)
if err != nil {
return nil, fmt.Errorf("Error trying to get network information from the Nova API: %s", err)
}
return networkInfo, nil
} | go | func getInstanceNetworkInfo(
d *schema.ResourceData, meta interface{}, queryType, queryTerm string) (map[string]interface{}, error) {
config := meta.(*Config)
if _, ok := os.LookupEnv("OS_NOVA_NETWORK"); !ok {
networkClient, err := config.networkingV2Client(GetRegion(d, config))
if err == nil {
networkInfo, err := getInstanceNetworkInfoNeutron(networkClient, queryType, queryTerm)
if err != nil {
return nil, fmt.Errorf("Error trying to get network information from the Network API: %s", err)
}
return networkInfo, nil
}
}
log.Printf("[DEBUG] Unable to obtain a network client")
computeClient, err := config.computeV2Client(GetRegion(d, config))
if err != nil {
return nil, fmt.Errorf("Error creating OpenStack compute client: %s", err)
}
networkInfo, err := getInstanceNetworkInfoNovaNet(computeClient, queryType, queryTerm)
if err != nil {
return nil, fmt.Errorf("Error trying to get network information from the Nova API: %s", err)
}
return networkInfo, nil
} | [
"func",
"getInstanceNetworkInfo",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
",",
"queryType",
",",
"queryTerm",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"os",
".",
"LookupEnv",
"(",
"\"",
"\"",
")",
";",
"!",
"ok",
"{",
"networkClient",
",",
"err",
":=",
"config",
".",
"networkingV2Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"networkInfo",
",",
"err",
":=",
"getInstanceNetworkInfoNeutron",
"(",
"networkClient",
",",
"queryType",
",",
"queryTerm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"networkInfo",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n\n",
"computeClient",
",",
"err",
":=",
"config",
".",
"computeV2Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"networkInfo",
",",
"err",
":=",
"getInstanceNetworkInfoNovaNet",
"(",
"computeClient",
",",
"queryType",
",",
"queryTerm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"networkInfo",
",",
"nil",
"\n",
"}"
] | // getInstanceNetworkInfo will query for network information in order to make
// an accurate determination of a network's name and a network's ID.
//
// We will try to first query the Neutron network service and fall back to the
// legacy nova-network service if that fails.
//
// If OS_NOVA_NETWORK is set, query nova-network even if Neutron is available.
// This is to be able to explicitly test the nova-network API. | [
"getInstanceNetworkInfo",
"will",
"query",
"for",
"network",
"information",
"in",
"order",
"to",
"make",
"an",
"accurate",
"determination",
"of",
"a",
"network",
"s",
"name",
"and",
"a",
"network",
"s",
"ID",
".",
"We",
"will",
"try",
"to",
"first",
"query",
"the",
"Neutron",
"network",
"service",
"and",
"fall",
"back",
"to",
"the",
"legacy",
"nova",
"-",
"network",
"service",
"if",
"that",
"fails",
".",
"If",
"OS_NOVA_NETWORK",
"is",
"set",
"query",
"nova",
"-",
"network",
"even",
"if",
"Neutron",
"is",
"available",
".",
"This",
"is",
"to",
"be",
"able",
"to",
"explicitly",
"test",
"the",
"nova",
"-",
"network",
"API",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/compute_instance_v2_networking.go#L152-L182 | train |
terraform-providers/terraform-provider-openstack | openstack/compute_instance_v2_networking.go | getInstanceNetworkInfoNovaNet | func getInstanceNetworkInfoNovaNet(
client *gophercloud.ServiceClient, queryType, queryTerm string) (map[string]interface{}, error) {
// If somehow a port ended up here, we should just error out.
if queryType == "port" {
return nil, fmt.Errorf(
"Unable to query a port (%s) using the Nova API", queryTerm)
}
// test to see if the tenantnetworks api is available
log.Printf("[DEBUG] testing for os-tenant-networks")
tenantNetworksAvailable := true
allPages, err := tenantnetworks.List(client).AllPages()
if err != nil {
switch err.(type) {
case gophercloud.ErrDefault404:
tenantNetworksAvailable = false
case gophercloud.ErrDefault403:
tenantNetworksAvailable = false
case gophercloud.ErrUnexpectedResponseCode:
tenantNetworksAvailable = false
default:
return nil, fmt.Errorf(
"An error occurred while querying the Nova API for network information: %s", err)
}
}
if !tenantNetworksAvailable {
// we can't query the APIs for more information, but in some cases
// the information provided is enough
log.Printf("[DEBUG] os-tenant-networks disabled.")
return map[string]interface{}{queryType: queryTerm}, nil
}
networkList, err := tenantnetworks.ExtractNetworks(allPages)
if err != nil {
return nil, fmt.Errorf(
"An error occurred while querying the Nova API for network information: %s", err)
}
var networkFound bool
var network tenantnetworks.Network
for _, v := range networkList {
if queryType == "id" && v.ID == queryTerm {
networkFound = true
network = v
break
}
if queryType == "name" && v.Name == queryTerm {
networkFound = true
network = v
break
}
}
if networkFound {
v := map[string]interface{}{
"uuid": network.ID,
"name": network.Name,
}
log.Printf("[DEBUG] getInstanceNetworkInfoNovaNet: %#v", v)
return v, nil
}
return nil, fmt.Errorf("Could not find any matching network for %s %s", queryType, queryTerm)
} | go | func getInstanceNetworkInfoNovaNet(
client *gophercloud.ServiceClient, queryType, queryTerm string) (map[string]interface{}, error) {
// If somehow a port ended up here, we should just error out.
if queryType == "port" {
return nil, fmt.Errorf(
"Unable to query a port (%s) using the Nova API", queryTerm)
}
// test to see if the tenantnetworks api is available
log.Printf("[DEBUG] testing for os-tenant-networks")
tenantNetworksAvailable := true
allPages, err := tenantnetworks.List(client).AllPages()
if err != nil {
switch err.(type) {
case gophercloud.ErrDefault404:
tenantNetworksAvailable = false
case gophercloud.ErrDefault403:
tenantNetworksAvailable = false
case gophercloud.ErrUnexpectedResponseCode:
tenantNetworksAvailable = false
default:
return nil, fmt.Errorf(
"An error occurred while querying the Nova API for network information: %s", err)
}
}
if !tenantNetworksAvailable {
// we can't query the APIs for more information, but in some cases
// the information provided is enough
log.Printf("[DEBUG] os-tenant-networks disabled.")
return map[string]interface{}{queryType: queryTerm}, nil
}
networkList, err := tenantnetworks.ExtractNetworks(allPages)
if err != nil {
return nil, fmt.Errorf(
"An error occurred while querying the Nova API for network information: %s", err)
}
var networkFound bool
var network tenantnetworks.Network
for _, v := range networkList {
if queryType == "id" && v.ID == queryTerm {
networkFound = true
network = v
break
}
if queryType == "name" && v.Name == queryTerm {
networkFound = true
network = v
break
}
}
if networkFound {
v := map[string]interface{}{
"uuid": network.ID,
"name": network.Name,
}
log.Printf("[DEBUG] getInstanceNetworkInfoNovaNet: %#v", v)
return v, nil
}
return nil, fmt.Errorf("Could not find any matching network for %s %s", queryType, queryTerm)
} | [
"func",
"getInstanceNetworkInfoNovaNet",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"queryType",
",",
"queryTerm",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"// If somehow a port ended up here, we should just error out.",
"if",
"queryType",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"queryTerm",
")",
"\n",
"}",
"\n\n",
"// test to see if the tenantnetworks api is available",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"tenantNetworksAvailable",
":=",
"true",
"\n\n",
"allPages",
",",
"err",
":=",
"tenantnetworks",
".",
"List",
"(",
"client",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"switch",
"err",
".",
"(",
"type",
")",
"{",
"case",
"gophercloud",
".",
"ErrDefault404",
":",
"tenantNetworksAvailable",
"=",
"false",
"\n",
"case",
"gophercloud",
".",
"ErrDefault403",
":",
"tenantNetworksAvailable",
"=",
"false",
"\n",
"case",
"gophercloud",
".",
"ErrUnexpectedResponseCode",
":",
"tenantNetworksAvailable",
"=",
"false",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"tenantNetworksAvailable",
"{",
"// we can't query the APIs for more information, but in some cases",
"// the information provided is enough",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"queryType",
":",
"queryTerm",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"networkList",
",",
"err",
":=",
"tenantnetworks",
".",
"ExtractNetworks",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"networkFound",
"bool",
"\n",
"var",
"network",
"tenantnetworks",
".",
"Network",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"networkList",
"{",
"if",
"queryType",
"==",
"\"",
"\"",
"&&",
"v",
".",
"ID",
"==",
"queryTerm",
"{",
"networkFound",
"=",
"true",
"\n",
"network",
"=",
"v",
"\n",
"break",
"\n",
"}",
"\n\n",
"if",
"queryType",
"==",
"\"",
"\"",
"&&",
"v",
".",
"Name",
"==",
"queryTerm",
"{",
"networkFound",
"=",
"true",
"\n",
"network",
"=",
"v",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"networkFound",
"{",
"v",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"network",
".",
"ID",
",",
"\"",
"\"",
":",
"network",
".",
"Name",
",",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"queryType",
",",
"queryTerm",
")",
"\n",
"}"
] | // getInstanceNetworkInfoNovaNet will query the os-tenant-networks API for
// the network information. | [
"getInstanceNetworkInfoNovaNet",
"will",
"query",
"the",
"os",
"-",
"tenant",
"-",
"networks",
"API",
"for",
"the",
"network",
"information",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/compute_instance_v2_networking.go#L186-L255 | train |
terraform-providers/terraform-provider-openstack | openstack/compute_instance_v2_networking.go | getInstanceNetworkInfoNeutron | func getInstanceNetworkInfoNeutron(
client *gophercloud.ServiceClient, queryType, queryTerm string) (map[string]interface{}, error) {
// If a port was specified, use it to look up the network ID
// and then query the network as if a network ID was originally used.
if queryType == "port" {
listOpts := ports.ListOpts{
ID: queryTerm,
}
allPages, err := ports.List(client, listOpts).AllPages()
if err != nil {
return nil, fmt.Errorf("Unable to retrieve networks from the Network API: %s", err)
}
allPorts, err := ports.ExtractPorts(allPages)
if err != nil {
return nil, fmt.Errorf("Unable to retrieve networks from the Network API: %s", err)
}
var port ports.Port
switch len(allPorts) {
case 0:
return nil, fmt.Errorf("Could not find any matching port for %s %s", queryType, queryTerm)
case 1:
port = allPorts[0]
default:
return nil, fmt.Errorf("More than one port found for %s %s", queryType, queryTerm)
}
queryType = "id"
queryTerm = port.NetworkID
}
listOpts := networks.ListOpts{
Status: "ACTIVE",
}
switch queryType {
case "name":
listOpts.Name = queryTerm
default:
listOpts.ID = queryTerm
}
allPages, err := networks.List(client, listOpts).AllPages()
if err != nil {
return nil, fmt.Errorf("Unable to retrieve networks from the Network API: %s", err)
}
allNetworks, err := networks.ExtractNetworks(allPages)
if err != nil {
return nil, fmt.Errorf("Unable to retrieve networks from the Network API: %s", err)
}
var network networks.Network
switch len(allNetworks) {
case 0:
return nil, fmt.Errorf("Could not find any matching network for %s %s", queryType, queryTerm)
case 1:
network = allNetworks[0]
default:
return nil, fmt.Errorf("More than one network found for %s %s", queryType, queryTerm)
}
v := map[string]interface{}{
"uuid": network.ID,
"name": network.Name,
}
log.Printf("[DEBUG] getInstanceNetworkInfoNeutron: %#v", v)
return v, nil
} | go | func getInstanceNetworkInfoNeutron(
client *gophercloud.ServiceClient, queryType, queryTerm string) (map[string]interface{}, error) {
// If a port was specified, use it to look up the network ID
// and then query the network as if a network ID was originally used.
if queryType == "port" {
listOpts := ports.ListOpts{
ID: queryTerm,
}
allPages, err := ports.List(client, listOpts).AllPages()
if err != nil {
return nil, fmt.Errorf("Unable to retrieve networks from the Network API: %s", err)
}
allPorts, err := ports.ExtractPorts(allPages)
if err != nil {
return nil, fmt.Errorf("Unable to retrieve networks from the Network API: %s", err)
}
var port ports.Port
switch len(allPorts) {
case 0:
return nil, fmt.Errorf("Could not find any matching port for %s %s", queryType, queryTerm)
case 1:
port = allPorts[0]
default:
return nil, fmt.Errorf("More than one port found for %s %s", queryType, queryTerm)
}
queryType = "id"
queryTerm = port.NetworkID
}
listOpts := networks.ListOpts{
Status: "ACTIVE",
}
switch queryType {
case "name":
listOpts.Name = queryTerm
default:
listOpts.ID = queryTerm
}
allPages, err := networks.List(client, listOpts).AllPages()
if err != nil {
return nil, fmt.Errorf("Unable to retrieve networks from the Network API: %s", err)
}
allNetworks, err := networks.ExtractNetworks(allPages)
if err != nil {
return nil, fmt.Errorf("Unable to retrieve networks from the Network API: %s", err)
}
var network networks.Network
switch len(allNetworks) {
case 0:
return nil, fmt.Errorf("Could not find any matching network for %s %s", queryType, queryTerm)
case 1:
network = allNetworks[0]
default:
return nil, fmt.Errorf("More than one network found for %s %s", queryType, queryTerm)
}
v := map[string]interface{}{
"uuid": network.ID,
"name": network.Name,
}
log.Printf("[DEBUG] getInstanceNetworkInfoNeutron: %#v", v)
return v, nil
} | [
"func",
"getInstanceNetworkInfoNeutron",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"queryType",
",",
"queryTerm",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"// If a port was specified, use it to look up the network ID",
"// and then query the network as if a network ID was originally used.",
"if",
"queryType",
"==",
"\"",
"\"",
"{",
"listOpts",
":=",
"ports",
".",
"ListOpts",
"{",
"ID",
":",
"queryTerm",
",",
"}",
"\n",
"allPages",
",",
"err",
":=",
"ports",
".",
"List",
"(",
"client",
",",
"listOpts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allPorts",
",",
"err",
":=",
"ports",
".",
"ExtractPorts",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"port",
"ports",
".",
"Port",
"\n",
"switch",
"len",
"(",
"allPorts",
")",
"{",
"case",
"0",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"queryType",
",",
"queryTerm",
")",
"\n",
"case",
"1",
":",
"port",
"=",
"allPorts",
"[",
"0",
"]",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"queryType",
",",
"queryTerm",
")",
"\n",
"}",
"\n\n",
"queryType",
"=",
"\"",
"\"",
"\n",
"queryTerm",
"=",
"port",
".",
"NetworkID",
"\n",
"}",
"\n\n",
"listOpts",
":=",
"networks",
".",
"ListOpts",
"{",
"Status",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"switch",
"queryType",
"{",
"case",
"\"",
"\"",
":",
"listOpts",
".",
"Name",
"=",
"queryTerm",
"\n",
"default",
":",
"listOpts",
".",
"ID",
"=",
"queryTerm",
"\n",
"}",
"\n\n",
"allPages",
",",
"err",
":=",
"networks",
".",
"List",
"(",
"client",
",",
"listOpts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allNetworks",
",",
"err",
":=",
"networks",
".",
"ExtractNetworks",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"network",
"networks",
".",
"Network",
"\n",
"switch",
"len",
"(",
"allNetworks",
")",
"{",
"case",
"0",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"queryType",
",",
"queryTerm",
")",
"\n",
"case",
"1",
":",
"network",
"=",
"allNetworks",
"[",
"0",
"]",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"queryType",
",",
"queryTerm",
")",
"\n",
"}",
"\n\n",
"v",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"network",
".",
"ID",
",",
"\"",
"\"",
":",
"network",
".",
"Name",
",",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"return",
"v",
",",
"nil",
"\n",
"}"
] | // getInstanceNetworkInfoNeutron will query the neutron API for the network
// information. | [
"getInstanceNetworkInfoNeutron",
"will",
"query",
"the",
"neutron",
"API",
"for",
"the",
"network",
"information",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/compute_instance_v2_networking.go#L259-L330 | train |
terraform-providers/terraform-provider-openstack | openstack/compute_instance_v2_networking.go | getInstanceAddresses | func getInstanceAddresses(addresses map[string]interface{}) []InstanceAddresses {
var allInstanceAddresses []InstanceAddresses
for networkName, v := range addresses {
instanceAddresses := InstanceAddresses{
NetworkName: networkName,
}
for _, v := range v.([]interface{}) {
instanceNIC := InstanceNIC{}
var exists bool
v := v.(map[string]interface{})
if v, ok := v["OS-EXT-IPS-MAC:mac_addr"].(string); ok {
instanceNIC.MAC = v
}
if v["OS-EXT-IPS:type"] == "fixed" || v["OS-EXT-IPS:type"] == nil {
switch v["version"].(float64) {
case 6:
instanceNIC.FixedIPv6 = fmt.Sprintf("[%s]", v["addr"].(string))
default:
instanceNIC.FixedIPv4 = v["addr"].(string)
}
}
// To associate IPv4 and IPv6 on the right NIC,
// key on the mac address and fill in the blanks.
for i, v := range instanceAddresses.InstanceNICs {
if v.MAC == instanceNIC.MAC {
exists = true
if instanceNIC.FixedIPv6 != "" {
instanceAddresses.InstanceNICs[i].FixedIPv6 = instanceNIC.FixedIPv6
}
if instanceNIC.FixedIPv4 != "" {
instanceAddresses.InstanceNICs[i].FixedIPv4 = instanceNIC.FixedIPv4
}
}
}
if !exists {
instanceAddresses.InstanceNICs = append(instanceAddresses.InstanceNICs, instanceNIC)
}
}
allInstanceAddresses = append(allInstanceAddresses, instanceAddresses)
}
log.Printf("[DEBUG] Addresses: %#v", addresses)
log.Printf("[DEBUG] allInstanceAddresses: %#v", allInstanceAddresses)
return allInstanceAddresses
} | go | func getInstanceAddresses(addresses map[string]interface{}) []InstanceAddresses {
var allInstanceAddresses []InstanceAddresses
for networkName, v := range addresses {
instanceAddresses := InstanceAddresses{
NetworkName: networkName,
}
for _, v := range v.([]interface{}) {
instanceNIC := InstanceNIC{}
var exists bool
v := v.(map[string]interface{})
if v, ok := v["OS-EXT-IPS-MAC:mac_addr"].(string); ok {
instanceNIC.MAC = v
}
if v["OS-EXT-IPS:type"] == "fixed" || v["OS-EXT-IPS:type"] == nil {
switch v["version"].(float64) {
case 6:
instanceNIC.FixedIPv6 = fmt.Sprintf("[%s]", v["addr"].(string))
default:
instanceNIC.FixedIPv4 = v["addr"].(string)
}
}
// To associate IPv4 and IPv6 on the right NIC,
// key on the mac address and fill in the blanks.
for i, v := range instanceAddresses.InstanceNICs {
if v.MAC == instanceNIC.MAC {
exists = true
if instanceNIC.FixedIPv6 != "" {
instanceAddresses.InstanceNICs[i].FixedIPv6 = instanceNIC.FixedIPv6
}
if instanceNIC.FixedIPv4 != "" {
instanceAddresses.InstanceNICs[i].FixedIPv4 = instanceNIC.FixedIPv4
}
}
}
if !exists {
instanceAddresses.InstanceNICs = append(instanceAddresses.InstanceNICs, instanceNIC)
}
}
allInstanceAddresses = append(allInstanceAddresses, instanceAddresses)
}
log.Printf("[DEBUG] Addresses: %#v", addresses)
log.Printf("[DEBUG] allInstanceAddresses: %#v", allInstanceAddresses)
return allInstanceAddresses
} | [
"func",
"getInstanceAddresses",
"(",
"addresses",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"[",
"]",
"InstanceAddresses",
"{",
"var",
"allInstanceAddresses",
"[",
"]",
"InstanceAddresses",
"\n\n",
"for",
"networkName",
",",
"v",
":=",
"range",
"addresses",
"{",
"instanceAddresses",
":=",
"InstanceAddresses",
"{",
"NetworkName",
":",
"networkName",
",",
"}",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"v",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"instanceNIC",
":=",
"InstanceNIC",
"{",
"}",
"\n",
"var",
"exists",
"bool",
"\n\n",
"v",
":=",
"v",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"v",
",",
"ok",
":=",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"instanceNIC",
".",
"MAC",
"=",
"v",
"\n",
"}",
"\n\n",
"if",
"v",
"[",
"\"",
"\"",
"]",
"==",
"\"",
"\"",
"||",
"v",
"[",
"\"",
"\"",
"]",
"==",
"nil",
"{",
"switch",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"float64",
")",
"{",
"case",
"6",
":",
"instanceNIC",
".",
"FixedIPv6",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
")",
"\n",
"default",
":",
"instanceNIC",
".",
"FixedIPv4",
"=",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// To associate IPv4 and IPv6 on the right NIC,",
"// key on the mac address and fill in the blanks.",
"for",
"i",
",",
"v",
":=",
"range",
"instanceAddresses",
".",
"InstanceNICs",
"{",
"if",
"v",
".",
"MAC",
"==",
"instanceNIC",
".",
"MAC",
"{",
"exists",
"=",
"true",
"\n",
"if",
"instanceNIC",
".",
"FixedIPv6",
"!=",
"\"",
"\"",
"{",
"instanceAddresses",
".",
"InstanceNICs",
"[",
"i",
"]",
".",
"FixedIPv6",
"=",
"instanceNIC",
".",
"FixedIPv6",
"\n",
"}",
"\n",
"if",
"instanceNIC",
".",
"FixedIPv4",
"!=",
"\"",
"\"",
"{",
"instanceAddresses",
".",
"InstanceNICs",
"[",
"i",
"]",
".",
"FixedIPv4",
"=",
"instanceNIC",
".",
"FixedIPv4",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"exists",
"{",
"instanceAddresses",
".",
"InstanceNICs",
"=",
"append",
"(",
"instanceAddresses",
".",
"InstanceNICs",
",",
"instanceNIC",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"allInstanceAddresses",
"=",
"append",
"(",
"allInstanceAddresses",
",",
"instanceAddresses",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"addresses",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"allInstanceAddresses",
")",
"\n\n",
"return",
"allInstanceAddresses",
"\n",
"}"
] | // getInstanceAddresses parses a Gophercloud server.Server's Address field into
// a structured InstanceAddresses struct. | [
"getInstanceAddresses",
"parses",
"a",
"Gophercloud",
"server",
".",
"Server",
"s",
"Address",
"field",
"into",
"a",
"structured",
"InstanceAddresses",
"struct",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/compute_instance_v2_networking.go#L334-L386 | train |
terraform-providers/terraform-provider-openstack | openstack/compute_instance_v2_networking.go | flattenInstanceNetworks | func flattenInstanceNetworks(
d *schema.ResourceData, meta interface{}) ([]map[string]interface{}, error) {
config := meta.(*Config)
computeClient, err := config.computeV2Client(GetRegion(d, config))
if err != nil {
return nil, fmt.Errorf("Error creating OpenStack compute client: %s", err)
}
server, err := servers.Get(computeClient, d.Id()).Extract()
if err != nil {
return nil, CheckDeleted(d, err, "server")
}
allInstanceAddresses := getInstanceAddresses(server.Addresses)
allInstanceNetworks, err := getAllInstanceNetworks(d, meta)
if err != nil {
return nil, err
}
networks := []map[string]interface{}{}
// If there were no instance networks returned, this means that there
// was not a network specified in the Terraform configuration. When this
// happens, the instance will be launched on a "default" network, if one
// is available. If there isn't, the instance will fail to launch, so
// this is a safe assumption at this point.
if len(allInstanceNetworks) == 0 {
for _, instanceAddresses := range allInstanceAddresses {
for _, instanceNIC := range instanceAddresses.InstanceNICs {
v := map[string]interface{}{
"name": instanceAddresses.NetworkName,
"fixed_ip_v4": instanceNIC.FixedIPv4,
"fixed_ip_v6": instanceNIC.FixedIPv6,
"mac": instanceNIC.MAC,
}
// Use the same method as getAllInstanceNetworks to get the network uuid
networkInfo, err := getInstanceNetworkInfo(d, meta, "name", instanceAddresses.NetworkName)
if err != nil {
log.Printf("[WARN] Error getting default network uuid: %s", err)
} else {
if v["uuid"] != nil {
v["uuid"] = networkInfo["uuid"].(string)
} else {
log.Printf("[WARN] Could not get default network uuid")
}
}
networks = append(networks, v)
}
}
log.Printf("[DEBUG] flattenInstanceNetworks: %#v", networks)
return networks, nil
}
// Loop through all networks and addresses, merge relevant address details.
for _, instanceNetwork := range allInstanceNetworks {
for _, instanceAddresses := range allInstanceAddresses {
// Skip if instanceAddresses has no NICs
if len(instanceAddresses.InstanceNICs) == 0 {
continue
}
if instanceNetwork.Name == instanceAddresses.NetworkName {
// Only use one NIC since it's possible the user defined another NIC
// on this same network in another Terraform network block.
instanceNIC := instanceAddresses.InstanceNICs[0]
copy(instanceAddresses.InstanceNICs, instanceAddresses.InstanceNICs[1:])
v := map[string]interface{}{
"name": instanceAddresses.NetworkName,
"fixed_ip_v4": instanceNIC.FixedIPv4,
"fixed_ip_v6": instanceNIC.FixedIPv6,
"mac": instanceNIC.MAC,
"uuid": instanceNetwork.UUID,
"port": instanceNetwork.Port,
"access_network": instanceNetwork.AccessNetwork,
}
networks = append(networks, v)
}
}
}
log.Printf("[DEBUG] flattenInstanceNetworks: %#v", networks)
return networks, nil
} | go | func flattenInstanceNetworks(
d *schema.ResourceData, meta interface{}) ([]map[string]interface{}, error) {
config := meta.(*Config)
computeClient, err := config.computeV2Client(GetRegion(d, config))
if err != nil {
return nil, fmt.Errorf("Error creating OpenStack compute client: %s", err)
}
server, err := servers.Get(computeClient, d.Id()).Extract()
if err != nil {
return nil, CheckDeleted(d, err, "server")
}
allInstanceAddresses := getInstanceAddresses(server.Addresses)
allInstanceNetworks, err := getAllInstanceNetworks(d, meta)
if err != nil {
return nil, err
}
networks := []map[string]interface{}{}
// If there were no instance networks returned, this means that there
// was not a network specified in the Terraform configuration. When this
// happens, the instance will be launched on a "default" network, if one
// is available. If there isn't, the instance will fail to launch, so
// this is a safe assumption at this point.
if len(allInstanceNetworks) == 0 {
for _, instanceAddresses := range allInstanceAddresses {
for _, instanceNIC := range instanceAddresses.InstanceNICs {
v := map[string]interface{}{
"name": instanceAddresses.NetworkName,
"fixed_ip_v4": instanceNIC.FixedIPv4,
"fixed_ip_v6": instanceNIC.FixedIPv6,
"mac": instanceNIC.MAC,
}
// Use the same method as getAllInstanceNetworks to get the network uuid
networkInfo, err := getInstanceNetworkInfo(d, meta, "name", instanceAddresses.NetworkName)
if err != nil {
log.Printf("[WARN] Error getting default network uuid: %s", err)
} else {
if v["uuid"] != nil {
v["uuid"] = networkInfo["uuid"].(string)
} else {
log.Printf("[WARN] Could not get default network uuid")
}
}
networks = append(networks, v)
}
}
log.Printf("[DEBUG] flattenInstanceNetworks: %#v", networks)
return networks, nil
}
// Loop through all networks and addresses, merge relevant address details.
for _, instanceNetwork := range allInstanceNetworks {
for _, instanceAddresses := range allInstanceAddresses {
// Skip if instanceAddresses has no NICs
if len(instanceAddresses.InstanceNICs) == 0 {
continue
}
if instanceNetwork.Name == instanceAddresses.NetworkName {
// Only use one NIC since it's possible the user defined another NIC
// on this same network in another Terraform network block.
instanceNIC := instanceAddresses.InstanceNICs[0]
copy(instanceAddresses.InstanceNICs, instanceAddresses.InstanceNICs[1:])
v := map[string]interface{}{
"name": instanceAddresses.NetworkName,
"fixed_ip_v4": instanceNIC.FixedIPv4,
"fixed_ip_v6": instanceNIC.FixedIPv6,
"mac": instanceNIC.MAC,
"uuid": instanceNetwork.UUID,
"port": instanceNetwork.Port,
"access_network": instanceNetwork.AccessNetwork,
}
networks = append(networks, v)
}
}
}
log.Printf("[DEBUG] flattenInstanceNetworks: %#v", networks)
return networks, nil
} | [
"func",
"flattenInstanceNetworks",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n",
"computeClient",
",",
"err",
":=",
"config",
".",
"computeV2Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"server",
",",
"err",
":=",
"servers",
".",
"Get",
"(",
"computeClient",
",",
"d",
".",
"Id",
"(",
")",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"CheckDeleted",
"(",
"d",
",",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"allInstanceAddresses",
":=",
"getInstanceAddresses",
"(",
"server",
".",
"Addresses",
")",
"\n",
"allInstanceNetworks",
",",
"err",
":=",
"getAllInstanceNetworks",
"(",
"d",
",",
"meta",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"networks",
":=",
"[",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n\n",
"// If there were no instance networks returned, this means that there",
"// was not a network specified in the Terraform configuration. When this",
"// happens, the instance will be launched on a \"default\" network, if one",
"// is available. If there isn't, the instance will fail to launch, so",
"// this is a safe assumption at this point.",
"if",
"len",
"(",
"allInstanceNetworks",
")",
"==",
"0",
"{",
"for",
"_",
",",
"instanceAddresses",
":=",
"range",
"allInstanceAddresses",
"{",
"for",
"_",
",",
"instanceNIC",
":=",
"range",
"instanceAddresses",
".",
"InstanceNICs",
"{",
"v",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"instanceAddresses",
".",
"NetworkName",
",",
"\"",
"\"",
":",
"instanceNIC",
".",
"FixedIPv4",
",",
"\"",
"\"",
":",
"instanceNIC",
".",
"FixedIPv6",
",",
"\"",
"\"",
":",
"instanceNIC",
".",
"MAC",
",",
"}",
"\n\n",
"// Use the same method as getAllInstanceNetworks to get the network uuid",
"networkInfo",
",",
"err",
":=",
"getInstanceNetworkInfo",
"(",
"d",
",",
"meta",
",",
"\"",
"\"",
",",
"instanceAddresses",
".",
"NetworkName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"if",
"v",
"[",
"\"",
"\"",
"]",
"!=",
"nil",
"{",
"v",
"[",
"\"",
"\"",
"]",
"=",
"networkInfo",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"networks",
"=",
"append",
"(",
"networks",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"networks",
")",
"\n",
"return",
"networks",
",",
"nil",
"\n",
"}",
"\n\n",
"// Loop through all networks and addresses, merge relevant address details.",
"for",
"_",
",",
"instanceNetwork",
":=",
"range",
"allInstanceNetworks",
"{",
"for",
"_",
",",
"instanceAddresses",
":=",
"range",
"allInstanceAddresses",
"{",
"// Skip if instanceAddresses has no NICs",
"if",
"len",
"(",
"instanceAddresses",
".",
"InstanceNICs",
")",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"instanceNetwork",
".",
"Name",
"==",
"instanceAddresses",
".",
"NetworkName",
"{",
"// Only use one NIC since it's possible the user defined another NIC",
"// on this same network in another Terraform network block.",
"instanceNIC",
":=",
"instanceAddresses",
".",
"InstanceNICs",
"[",
"0",
"]",
"\n",
"copy",
"(",
"instanceAddresses",
".",
"InstanceNICs",
",",
"instanceAddresses",
".",
"InstanceNICs",
"[",
"1",
":",
"]",
")",
"\n",
"v",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"instanceAddresses",
".",
"NetworkName",
",",
"\"",
"\"",
":",
"instanceNIC",
".",
"FixedIPv4",
",",
"\"",
"\"",
":",
"instanceNIC",
".",
"FixedIPv6",
",",
"\"",
"\"",
":",
"instanceNIC",
".",
"MAC",
",",
"\"",
"\"",
":",
"instanceNetwork",
".",
"UUID",
",",
"\"",
"\"",
":",
"instanceNetwork",
".",
"Port",
",",
"\"",
"\"",
":",
"instanceNetwork",
".",
"AccessNetwork",
",",
"}",
"\n",
"networks",
"=",
"append",
"(",
"networks",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"networks",
")",
"\n",
"return",
"networks",
",",
"nil",
"\n",
"}"
] | // flattenInstanceNetworks collects instance network information from different
// sources and aggregates it all together into a map array. | [
"flattenInstanceNetworks",
"collects",
"instance",
"network",
"information",
"from",
"different",
"sources",
"and",
"aggregates",
"it",
"all",
"together",
"into",
"a",
"map",
"array",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/compute_instance_v2_networking.go#L406-L492 | train |
terraform-providers/terraform-provider-openstack | openstack/compute_instance_v2_networking.go | getInstanceAccessAddresses | func getInstanceAccessAddresses(
d *schema.ResourceData, networks []map[string]interface{}) (string, string) {
var hostv4, hostv6 string
// Loop through all networks
// If the network has a valid fixed v4 or fixed v6 address
// and hostv4 or hostv6 is not set, set hostv4/hostv6.
// If the network is an "access_network" overwrite hostv4/hostv6.
for _, n := range networks {
var accessNetwork bool
if an, ok := n["access_network"].(bool); ok && an {
accessNetwork = true
}
if fixedIPv4, ok := n["fixed_ip_v4"].(string); ok && fixedIPv4 != "" {
if hostv4 == "" || accessNetwork {
hostv4 = fixedIPv4
}
}
if fixedIPv6, ok := n["fixed_ip_v6"].(string); ok && fixedIPv6 != "" {
if hostv6 == "" || accessNetwork {
hostv6 = fixedIPv6
}
}
}
log.Printf("[DEBUG] OpenStack Instance Network Access Addresses: %s, %s", hostv4, hostv6)
return hostv4, hostv6
} | go | func getInstanceAccessAddresses(
d *schema.ResourceData, networks []map[string]interface{}) (string, string) {
var hostv4, hostv6 string
// Loop through all networks
// If the network has a valid fixed v4 or fixed v6 address
// and hostv4 or hostv6 is not set, set hostv4/hostv6.
// If the network is an "access_network" overwrite hostv4/hostv6.
for _, n := range networks {
var accessNetwork bool
if an, ok := n["access_network"].(bool); ok && an {
accessNetwork = true
}
if fixedIPv4, ok := n["fixed_ip_v4"].(string); ok && fixedIPv4 != "" {
if hostv4 == "" || accessNetwork {
hostv4 = fixedIPv4
}
}
if fixedIPv6, ok := n["fixed_ip_v6"].(string); ok && fixedIPv6 != "" {
if hostv6 == "" || accessNetwork {
hostv6 = fixedIPv6
}
}
}
log.Printf("[DEBUG] OpenStack Instance Network Access Addresses: %s, %s", hostv4, hostv6)
return hostv4, hostv6
} | [
"func",
"getInstanceAccessAddresses",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"networks",
"[",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"string",
",",
"string",
")",
"{",
"var",
"hostv4",
",",
"hostv6",
"string",
"\n\n",
"// Loop through all networks",
"// If the network has a valid fixed v4 or fixed v6 address",
"// and hostv4 or hostv6 is not set, set hostv4/hostv6.",
"// If the network is an \"access_network\" overwrite hostv4/hostv6.",
"for",
"_",
",",
"n",
":=",
"range",
"networks",
"{",
"var",
"accessNetwork",
"bool",
"\n\n",
"if",
"an",
",",
"ok",
":=",
"n",
"[",
"\"",
"\"",
"]",
".",
"(",
"bool",
")",
";",
"ok",
"&&",
"an",
"{",
"accessNetwork",
"=",
"true",
"\n",
"}",
"\n\n",
"if",
"fixedIPv4",
",",
"ok",
":=",
"n",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
";",
"ok",
"&&",
"fixedIPv4",
"!=",
"\"",
"\"",
"{",
"if",
"hostv4",
"==",
"\"",
"\"",
"||",
"accessNetwork",
"{",
"hostv4",
"=",
"fixedIPv4",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"fixedIPv6",
",",
"ok",
":=",
"n",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
";",
"ok",
"&&",
"fixedIPv6",
"!=",
"\"",
"\"",
"{",
"if",
"hostv6",
"==",
"\"",
"\"",
"||",
"accessNetwork",
"{",
"hostv6",
"=",
"fixedIPv6",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"hostv4",
",",
"hostv6",
")",
"\n\n",
"return",
"hostv4",
",",
"hostv6",
"\n",
"}"
] | // getInstanceAccessAddresses determines the best IP address to communicate
// with the instance. It does this by looping through all networks and looking
// for a valid IP address. Priority is given to a network that was flagged as
// an access_network. | [
"getInstanceAccessAddresses",
"determines",
"the",
"best",
"IP",
"address",
"to",
"communicate",
"with",
"the",
"instance",
".",
"It",
"does",
"this",
"by",
"looping",
"through",
"all",
"networks",
"and",
"looking",
"for",
"a",
"valid",
"IP",
"address",
".",
"Priority",
"is",
"given",
"to",
"a",
"network",
"that",
"was",
"flagged",
"as",
"an",
"access_network",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/compute_instance_v2_networking.go#L498-L530 | train |
terraform-providers/terraform-provider-openstack | openstack/types.go | RoundTrip | func (lrt *LogRoundTripper) RoundTrip(request *http.Request) (*http.Response, error) {
defer func() {
if request.Body != nil {
request.Body.Close()
}
}()
// for future reference, this is how to access the Transport struct:
//tlsconfig := lrt.Rt.(*http.Transport).TLSClientConfig
var err error
if lrt.OsDebug {
log.Printf("[DEBUG] OpenStack Request URL: %s %s", request.Method, request.URL)
log.Printf("[DEBUG] OpenStack Request Headers:\n%s", FormatHeaders(request.Header, "\n"))
if request.Body != nil {
request.Body, err = lrt.logRequest(request.Body, request.Header.Get("Content-Type"))
if err != nil {
return nil, err
}
}
}
response, err := lrt.Rt.RoundTrip(request)
// If the first request didn't return a response, retry up to `max_retries`.
retry := 1
for response == nil {
if retry > lrt.MaxRetries {
if lrt.OsDebug {
log.Printf("[DEBUG] OpenStack connection error, retries exhausted. Aborting")
}
err = fmt.Errorf("OpenStack connection error, retries exhausted. Aborting. Last error was: %s", err)
return nil, err
}
if lrt.OsDebug {
log.Printf("[DEBUG] OpenStack connection error, retry number %d: %s", retry, err)
}
response, err = lrt.Rt.RoundTrip(request)
retry += 1
}
if lrt.OsDebug {
log.Printf("[DEBUG] OpenStack Response Code: %d", response.StatusCode)
log.Printf("[DEBUG] OpenStack Response Headers:\n%s", FormatHeaders(response.Header, "\n"))
response.Body, err = lrt.logResponse(response.Body, response.Header.Get("Content-Type"))
}
return response, err
} | go | func (lrt *LogRoundTripper) RoundTrip(request *http.Request) (*http.Response, error) {
defer func() {
if request.Body != nil {
request.Body.Close()
}
}()
// for future reference, this is how to access the Transport struct:
//tlsconfig := lrt.Rt.(*http.Transport).TLSClientConfig
var err error
if lrt.OsDebug {
log.Printf("[DEBUG] OpenStack Request URL: %s %s", request.Method, request.URL)
log.Printf("[DEBUG] OpenStack Request Headers:\n%s", FormatHeaders(request.Header, "\n"))
if request.Body != nil {
request.Body, err = lrt.logRequest(request.Body, request.Header.Get("Content-Type"))
if err != nil {
return nil, err
}
}
}
response, err := lrt.Rt.RoundTrip(request)
// If the first request didn't return a response, retry up to `max_retries`.
retry := 1
for response == nil {
if retry > lrt.MaxRetries {
if lrt.OsDebug {
log.Printf("[DEBUG] OpenStack connection error, retries exhausted. Aborting")
}
err = fmt.Errorf("OpenStack connection error, retries exhausted. Aborting. Last error was: %s", err)
return nil, err
}
if lrt.OsDebug {
log.Printf("[DEBUG] OpenStack connection error, retry number %d: %s", retry, err)
}
response, err = lrt.Rt.RoundTrip(request)
retry += 1
}
if lrt.OsDebug {
log.Printf("[DEBUG] OpenStack Response Code: %d", response.StatusCode)
log.Printf("[DEBUG] OpenStack Response Headers:\n%s", FormatHeaders(response.Header, "\n"))
response.Body, err = lrt.logResponse(response.Body, response.Header.Get("Content-Type"))
}
return response, err
} | [
"func",
"(",
"lrt",
"*",
"LogRoundTripper",
")",
"RoundTrip",
"(",
"request",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"request",
".",
"Body",
"!=",
"nil",
"{",
"request",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"// for future reference, this is how to access the Transport struct:",
"//tlsconfig := lrt.Rt.(*http.Transport).TLSClientConfig",
"var",
"err",
"error",
"\n\n",
"if",
"lrt",
".",
"OsDebug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"request",
".",
"Method",
",",
"request",
".",
"URL",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"FormatHeaders",
"(",
"request",
".",
"Header",
",",
"\"",
"\\n",
"\"",
")",
")",
"\n\n",
"if",
"request",
".",
"Body",
"!=",
"nil",
"{",
"request",
".",
"Body",
",",
"err",
"=",
"lrt",
".",
"logRequest",
"(",
"request",
".",
"Body",
",",
"request",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"response",
",",
"err",
":=",
"lrt",
".",
"Rt",
".",
"RoundTrip",
"(",
"request",
")",
"\n\n",
"// If the first request didn't return a response, retry up to `max_retries`.",
"retry",
":=",
"1",
"\n",
"for",
"response",
"==",
"nil",
"{",
"if",
"retry",
">",
"lrt",
".",
"MaxRetries",
"{",
"if",
"lrt",
".",
"OsDebug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"lrt",
".",
"OsDebug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"retry",
",",
"err",
")",
"\n",
"}",
"\n",
"response",
",",
"err",
"=",
"lrt",
".",
"Rt",
".",
"RoundTrip",
"(",
"request",
")",
"\n",
"retry",
"+=",
"1",
"\n",
"}",
"\n\n",
"if",
"lrt",
".",
"OsDebug",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"response",
".",
"StatusCode",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"FormatHeaders",
"(",
"response",
".",
"Header",
",",
"\"",
"\\n",
"\"",
")",
")",
"\n\n",
"response",
".",
"Body",
",",
"err",
"=",
"lrt",
".",
"logResponse",
"(",
"response",
".",
"Body",
",",
"response",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"err",
"\n",
"}"
] | // RoundTrip performs a round-trip HTTP request and logs relevant information about it. | [
"RoundTrip",
"performs",
"a",
"round",
"-",
"trip",
"HTTP",
"request",
"and",
"logs",
"relevant",
"information",
"about",
"it",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/types.go#L35-L87 | train |
terraform-providers/terraform-provider-openstack | openstack/types.go | logRequest | func (lrt *LogRoundTripper) logRequest(original io.ReadCloser, contentType string) (io.ReadCloser, error) {
defer original.Close()
var bs bytes.Buffer
_, err := io.Copy(&bs, original)
if err != nil {
return nil, err
}
// Handle request contentType
if strings.HasPrefix(contentType, "application/json") {
debugInfo := lrt.formatJSON(bs.Bytes())
log.Printf("[DEBUG] OpenStack Request Body: %s", debugInfo)
}
return ioutil.NopCloser(strings.NewReader(bs.String())), nil
} | go | func (lrt *LogRoundTripper) logRequest(original io.ReadCloser, contentType string) (io.ReadCloser, error) {
defer original.Close()
var bs bytes.Buffer
_, err := io.Copy(&bs, original)
if err != nil {
return nil, err
}
// Handle request contentType
if strings.HasPrefix(contentType, "application/json") {
debugInfo := lrt.formatJSON(bs.Bytes())
log.Printf("[DEBUG] OpenStack Request Body: %s", debugInfo)
}
return ioutil.NopCloser(strings.NewReader(bs.String())), nil
} | [
"func",
"(",
"lrt",
"*",
"LogRoundTripper",
")",
"logRequest",
"(",
"original",
"io",
".",
"ReadCloser",
",",
"contentType",
"string",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"defer",
"original",
".",
"Close",
"(",
")",
"\n\n",
"var",
"bs",
"bytes",
".",
"Buffer",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"&",
"bs",
",",
"original",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Handle request contentType",
"if",
"strings",
".",
"HasPrefix",
"(",
"contentType",
",",
"\"",
"\"",
")",
"{",
"debugInfo",
":=",
"lrt",
".",
"formatJSON",
"(",
"bs",
".",
"Bytes",
"(",
")",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"debugInfo",
")",
"\n",
"}",
"\n\n",
"return",
"ioutil",
".",
"NopCloser",
"(",
"strings",
".",
"NewReader",
"(",
"bs",
".",
"String",
"(",
")",
")",
")",
",",
"nil",
"\n",
"}"
] | // logRequest will log the HTTP Request details.
// If the body is JSON, it will attempt to be pretty-formatted. | [
"logRequest",
"will",
"log",
"the",
"HTTP",
"Request",
"details",
".",
"If",
"the",
"body",
"is",
"JSON",
"it",
"will",
"attempt",
"to",
"be",
"pretty",
"-",
"formatted",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/types.go#L91-L107 | train |
terraform-providers/terraform-provider-openstack | openstack/types.go | formatJSON | func (lrt *LogRoundTripper) formatJSON(raw []byte) string {
var rawData interface{}
err := json.Unmarshal(raw, &rawData)
if err != nil {
log.Printf("[DEBUG] Unable to parse OpenStack JSON: %s", err)
return string(raw)
}
data, ok := rawData.(map[string]interface{})
if !ok {
pretty, err := json.MarshalIndent(rawData, "", " ")
if err != nil {
log.Printf("[DEBUG] Unable to re-marshal OpenStack JSON: %s", err)
return string(raw)
}
return string(pretty)
}
// Mask known password fields
if v, ok := data["auth"].(map[string]interface{}); ok {
if v, ok := v["identity"].(map[string]interface{}); ok {
if v, ok := v["password"].(map[string]interface{}); ok {
if v, ok := v["user"].(map[string]interface{}); ok {
v["password"] = "***"
}
}
if v, ok := v["application_credential"].(map[string]interface{}); ok {
v["secret"] = "***"
}
if v, ok := v["token"].(map[string]interface{}); ok {
v["id"] = "***"
}
}
}
// Ignore the catalog
if v, ok := data["token"].(map[string]interface{}); ok {
if _, ok := v["catalog"]; ok {
return ""
}
}
pretty, err := json.MarshalIndent(data, "", " ")
if err != nil {
log.Printf("[DEBUG] Unable to re-marshal OpenStack JSON: %s", err)
return string(raw)
}
return string(pretty)
} | go | func (lrt *LogRoundTripper) formatJSON(raw []byte) string {
var rawData interface{}
err := json.Unmarshal(raw, &rawData)
if err != nil {
log.Printf("[DEBUG] Unable to parse OpenStack JSON: %s", err)
return string(raw)
}
data, ok := rawData.(map[string]interface{})
if !ok {
pretty, err := json.MarshalIndent(rawData, "", " ")
if err != nil {
log.Printf("[DEBUG] Unable to re-marshal OpenStack JSON: %s", err)
return string(raw)
}
return string(pretty)
}
// Mask known password fields
if v, ok := data["auth"].(map[string]interface{}); ok {
if v, ok := v["identity"].(map[string]interface{}); ok {
if v, ok := v["password"].(map[string]interface{}); ok {
if v, ok := v["user"].(map[string]interface{}); ok {
v["password"] = "***"
}
}
if v, ok := v["application_credential"].(map[string]interface{}); ok {
v["secret"] = "***"
}
if v, ok := v["token"].(map[string]interface{}); ok {
v["id"] = "***"
}
}
}
// Ignore the catalog
if v, ok := data["token"].(map[string]interface{}); ok {
if _, ok := v["catalog"]; ok {
return ""
}
}
pretty, err := json.MarshalIndent(data, "", " ")
if err != nil {
log.Printf("[DEBUG] Unable to re-marshal OpenStack JSON: %s", err)
return string(raw)
}
return string(pretty)
} | [
"func",
"(",
"lrt",
"*",
"LogRoundTripper",
")",
"formatJSON",
"(",
"raw",
"[",
"]",
"byte",
")",
"string",
"{",
"var",
"rawData",
"interface",
"{",
"}",
"\n\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"raw",
",",
"&",
"rawData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"string",
"(",
"raw",
")",
"\n",
"}",
"\n\n",
"data",
",",
"ok",
":=",
"rawData",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"pretty",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"rawData",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"string",
"(",
"raw",
")",
"\n",
"}",
"\n\n",
"return",
"string",
"(",
"pretty",
")",
"\n",
"}",
"\n\n",
"// Mask known password fields",
"if",
"v",
",",
"ok",
":=",
"data",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"if",
"v",
",",
"ok",
":=",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"if",
"v",
",",
"ok",
":=",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"if",
"v",
",",
"ok",
":=",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"v",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"v",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"v",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"v",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Ignore the catalog",
"if",
"v",
",",
"ok",
":=",
"data",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"if",
"_",
",",
"ok",
":=",
"v",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n\n",
"pretty",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"data",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"string",
"(",
"raw",
")",
"\n",
"}",
"\n\n",
"return",
"string",
"(",
"pretty",
")",
"\n",
"}"
] | // formatJSON will try to pretty-format a JSON body.
// It will also mask known fields which contain sensitive information. | [
"formatJSON",
"will",
"try",
"to",
"pretty",
"-",
"format",
"a",
"JSON",
"body",
".",
"It",
"will",
"also",
"mask",
"known",
"fields",
"which",
"contain",
"sensitive",
"information",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/types.go#L132-L183 | train |
terraform-providers/terraform-provider-openstack | openstack/types.go | ToSubnetCreateMap | func (opts SubnetCreateOpts) ToSubnetCreateMap() (map[string]interface{}, error) {
b, err := BuildRequest(opts, "subnet")
if err != nil {
return nil, err
}
if m := b["subnet"].(map[string]interface{}); m["gateway_ip"] == "" {
m["gateway_ip"] = nil
}
return b, nil
} | go | func (opts SubnetCreateOpts) ToSubnetCreateMap() (map[string]interface{}, error) {
b, err := BuildRequest(opts, "subnet")
if err != nil {
return nil, err
}
if m := b["subnet"].(map[string]interface{}); m["gateway_ip"] == "" {
m["gateway_ip"] = nil
}
return b, nil
} | [
"func",
"(",
"opts",
"SubnetCreateOpts",
")",
"ToSubnetCreateMap",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"BuildRequest",
"(",
"opts",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"m",
":=",
"b",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"m",
"[",
"\"",
"\"",
"]",
"==",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"nil",
"\n",
"}",
"\n\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] | // ToSubnetCreateMap casts a CreateOpts struct to a map.
// It overrides subnets.ToSubnetCreateMap to add the ValueSpecs field. | [
"ToSubnetCreateMap",
"casts",
"a",
"CreateOpts",
"struct",
"to",
"a",
"map",
".",
"It",
"overrides",
"subnets",
".",
"ToSubnetCreateMap",
"to",
"add",
"the",
"ValueSpecs",
"field",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/types.go#L253-L264 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_identity_endpoint_v3.go | dataSourceIdentityEndpointV3Read | func dataSourceIdentityEndpointV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
availability := gophercloud.AvailabilityPublic
switch d.Get("interface") {
case "internal":
availability = gophercloud.AvailabilityInternal
case "admin":
availability = gophercloud.AvailabilityAdmin
}
listOpts := endpoints.ListOpts{
Availability: availability,
ServiceID: d.Get("service_id").(string),
}
log.Printf("[DEBUG] openstack_identity_endpoint_v3 list options: %#v", listOpts)
var endpoint endpoints.Endpoint
allPages, err := endpoints.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_endpoint_v3: %s", err)
}
allEndpoints, err := endpoints.ExtractEndpoints(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_endpoint_v3: %s", err)
}
serviceName := d.Get("service_name").(string)
if len(allEndpoints) > 1 && serviceName != "" {
var filteredEndpoints []endpoints.Endpoint
// Query all services to further filter results
allServicePages, err := services.List(identityClient, nil).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_endpoint_v3 services: %s", err)
}
allServices, err := services.ExtractServices(allServicePages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_endpoint_v3 services: %s", err)
}
for _, endpoint := range allEndpoints {
for _, service := range allServices {
if v, ok := service.Extra["name"].(string); ok {
if endpoint.ServiceID == service.ID && serviceName == v {
endpoint.Name = v
filteredEndpoints = append(filteredEndpoints, endpoint)
}
}
}
}
allEndpoints = filteredEndpoints
}
if len(allEndpoints) < 1 {
return fmt.Errorf("Your openstack_identity_endpoint_v3 query returned no results. " +
"Please change your search criteria and try again.")
}
if len(allEndpoints) > 1 {
return fmt.Errorf("Your openstack_identity_endpoint_v3 query returned more than one result")
}
endpoint = allEndpoints[0]
return dataSourceIdentityEndpointV3Attributes(d, &endpoint)
} | go | func dataSourceIdentityEndpointV3Read(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
identityClient, err := config.identityV3Client(GetRegion(d, config))
if err != nil {
return fmt.Errorf("Error creating OpenStack identity client: %s", err)
}
availability := gophercloud.AvailabilityPublic
switch d.Get("interface") {
case "internal":
availability = gophercloud.AvailabilityInternal
case "admin":
availability = gophercloud.AvailabilityAdmin
}
listOpts := endpoints.ListOpts{
Availability: availability,
ServiceID: d.Get("service_id").(string),
}
log.Printf("[DEBUG] openstack_identity_endpoint_v3 list options: %#v", listOpts)
var endpoint endpoints.Endpoint
allPages, err := endpoints.List(identityClient, listOpts).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_endpoint_v3: %s", err)
}
allEndpoints, err := endpoints.ExtractEndpoints(allPages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_endpoint_v3: %s", err)
}
serviceName := d.Get("service_name").(string)
if len(allEndpoints) > 1 && serviceName != "" {
var filteredEndpoints []endpoints.Endpoint
// Query all services to further filter results
allServicePages, err := services.List(identityClient, nil).AllPages()
if err != nil {
return fmt.Errorf("Unable to query openstack_identity_endpoint_v3 services: %s", err)
}
allServices, err := services.ExtractServices(allServicePages)
if err != nil {
return fmt.Errorf("Unable to retrieve openstack_identity_endpoint_v3 services: %s", err)
}
for _, endpoint := range allEndpoints {
for _, service := range allServices {
if v, ok := service.Extra["name"].(string); ok {
if endpoint.ServiceID == service.ID && serviceName == v {
endpoint.Name = v
filteredEndpoints = append(filteredEndpoints, endpoint)
}
}
}
}
allEndpoints = filteredEndpoints
}
if len(allEndpoints) < 1 {
return fmt.Errorf("Your openstack_identity_endpoint_v3 query returned no results. " +
"Please change your search criteria and try again.")
}
if len(allEndpoints) > 1 {
return fmt.Errorf("Your openstack_identity_endpoint_v3 query returned more than one result")
}
endpoint = allEndpoints[0]
return dataSourceIdentityEndpointV3Attributes(d, &endpoint)
} | [
"func",
"dataSourceIdentityEndpointV3Read",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"meta",
"interface",
"{",
"}",
")",
"error",
"{",
"config",
":=",
"meta",
".",
"(",
"*",
"Config",
")",
"\n",
"identityClient",
",",
"err",
":=",
"config",
".",
"identityV3Client",
"(",
"GetRegion",
"(",
"d",
",",
"config",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"availability",
":=",
"gophercloud",
".",
"AvailabilityPublic",
"\n",
"switch",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
"{",
"case",
"\"",
"\"",
":",
"availability",
"=",
"gophercloud",
".",
"AvailabilityInternal",
"\n",
"case",
"\"",
"\"",
":",
"availability",
"=",
"gophercloud",
".",
"AvailabilityAdmin",
"\n",
"}",
"\n\n",
"listOpts",
":=",
"endpoints",
".",
"ListOpts",
"{",
"Availability",
":",
"availability",
",",
"ServiceID",
":",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
",",
"}",
"\n\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"listOpts",
")",
"\n\n",
"var",
"endpoint",
"endpoints",
".",
"Endpoint",
"\n",
"allPages",
",",
"err",
":=",
"endpoints",
".",
"List",
"(",
"identityClient",
",",
"listOpts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allEndpoints",
",",
"err",
":=",
"endpoints",
".",
"ExtractEndpoints",
"(",
"allPages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"serviceName",
":=",
"d",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"string",
")",
"\n",
"if",
"len",
"(",
"allEndpoints",
")",
">",
"1",
"&&",
"serviceName",
"!=",
"\"",
"\"",
"{",
"var",
"filteredEndpoints",
"[",
"]",
"endpoints",
".",
"Endpoint",
"\n\n",
"// Query all services to further filter results",
"allServicePages",
",",
"err",
":=",
"services",
".",
"List",
"(",
"identityClient",
",",
"nil",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"allServices",
",",
"err",
":=",
"services",
".",
"ExtractServices",
"(",
"allServicePages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"endpoint",
":=",
"range",
"allEndpoints",
"{",
"for",
"_",
",",
"service",
":=",
"range",
"allServices",
"{",
"if",
"v",
",",
"ok",
":=",
"service",
".",
"Extra",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"if",
"endpoint",
".",
"ServiceID",
"==",
"service",
".",
"ID",
"&&",
"serviceName",
"==",
"v",
"{",
"endpoint",
".",
"Name",
"=",
"v",
"\n",
"filteredEndpoints",
"=",
"append",
"(",
"filteredEndpoints",
",",
"endpoint",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"allEndpoints",
"=",
"filteredEndpoints",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allEndpoints",
")",
"<",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"allEndpoints",
")",
">",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"endpoint",
"=",
"allEndpoints",
"[",
"0",
"]",
"\n\n",
"return",
"dataSourceIdentityEndpointV3Attributes",
"(",
"d",
",",
"&",
"endpoint",
")",
"\n",
"}"
] | // dataSourceIdentityEndpointV3Read performs the endpoint lookup. | [
"dataSourceIdentityEndpointV3Read",
"performs",
"the",
"endpoint",
"lookup",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_identity_endpoint_v3.go#L57-L130 | train |
terraform-providers/terraform-provider-openstack | openstack/data_source_openstack_identity_endpoint_v3.go | dataSourceIdentityEndpointV3Attributes | func dataSourceIdentityEndpointV3Attributes(d *schema.ResourceData, endpoint *endpoints.Endpoint) error {
log.Printf("[DEBUG] openstack_identity_endpoint_v3 details: %#v", endpoint)
d.SetId(endpoint.ID)
d.Set("interface", endpoint.Availability)
d.Set("region", endpoint.Region)
d.Set("service_id", endpoint.ServiceID)
d.Set("service_name", endpoint.Name)
d.Set("url", endpoint.URL)
return nil
} | go | func dataSourceIdentityEndpointV3Attributes(d *schema.ResourceData, endpoint *endpoints.Endpoint) error {
log.Printf("[DEBUG] openstack_identity_endpoint_v3 details: %#v", endpoint)
d.SetId(endpoint.ID)
d.Set("interface", endpoint.Availability)
d.Set("region", endpoint.Region)
d.Set("service_id", endpoint.ServiceID)
d.Set("service_name", endpoint.Name)
d.Set("url", endpoint.URL)
return nil
} | [
"func",
"dataSourceIdentityEndpointV3Attributes",
"(",
"d",
"*",
"schema",
".",
"ResourceData",
",",
"endpoint",
"*",
"endpoints",
".",
"Endpoint",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"endpoint",
")",
"\n\n",
"d",
".",
"SetId",
"(",
"endpoint",
".",
"ID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"endpoint",
".",
"Availability",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"endpoint",
".",
"Region",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"endpoint",
".",
"ServiceID",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"endpoint",
".",
"Name",
")",
"\n",
"d",
".",
"Set",
"(",
"\"",
"\"",
",",
"endpoint",
".",
"URL",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // dataSourceIdentityEndpointV3Attributes populates the fields of an Endpoint resource. | [
"dataSourceIdentityEndpointV3Attributes",
"populates",
"the",
"fields",
"of",
"an",
"Endpoint",
"resource",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/data_source_openstack_identity_endpoint_v3.go#L133-L144 | train |
terraform-providers/terraform-provider-openstack | openstack/db_instance_v1.go | databaseInstanceV1StateRefreshFunc | func databaseInstanceV1StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
i, err := instances.Get(client, instanceID).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
return i, "DELETED", nil
}
return nil, "", err
}
if i.Status == "error" {
return i, i.Status, fmt.Errorf("There was an error creating the database instance.")
}
return i, i.Status, nil
}
} | go | func databaseInstanceV1StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
i, err := instances.Get(client, instanceID).Extract()
if err != nil {
if _, ok := err.(gophercloud.ErrDefault404); ok {
return i, "DELETED", nil
}
return nil, "", err
}
if i.Status == "error" {
return i, i.Status, fmt.Errorf("There was an error creating the database instance.")
}
return i, i.Status, nil
}
} | [
"func",
"databaseInstanceV1StateRefreshFunc",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"instanceID",
"string",
")",
"resource",
".",
"StateRefreshFunc",
"{",
"return",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"string",
",",
"error",
")",
"{",
"i",
",",
"err",
":=",
"instances",
".",
"Get",
"(",
"client",
",",
"instanceID",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"gophercloud",
".",
"ErrDefault404",
")",
";",
"ok",
"{",
"return",
"i",
",",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"i",
".",
"Status",
"==",
"\"",
"\"",
"{",
"return",
"i",
",",
"i",
".",
"Status",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"i",
",",
"i",
".",
"Status",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // databaseInstanceV1StateRefreshFunc returns a resource.StateRefreshFunc
// that is used to watch a database instance. | [
"databaseInstanceV1StateRefreshFunc",
"returns",
"a",
"resource",
".",
"StateRefreshFunc",
"that",
"is",
"used",
"to",
"watch",
"a",
"database",
"instance",
"."
] | a4c13eee81a7ca8682741b049cb067610bdf45b2 | https://github.com/terraform-providers/terraform-provider-openstack/blob/a4c13eee81a7ca8682741b049cb067610bdf45b2/openstack/db_instance_v1.go#L71-L87 | train |
hashicorp/raft-boltdb | bolt_store.go | New | func New(options Options) (*BoltStore, error) {
// Try to connect
handle, err := bolt.Open(options.Path, dbFileMode, options.BoltOptions)
if err != nil {
return nil, err
}
handle.NoSync = options.NoSync
// Create the new store
store := &BoltStore{
conn: handle,
path: options.Path,
}
// If the store was opened read-only, don't try and create buckets
if !options.readOnly() {
// Set up our buckets
if err := store.initialize(); err != nil {
store.Close()
return nil, err
}
}
return store, nil
} | go | func New(options Options) (*BoltStore, error) {
// Try to connect
handle, err := bolt.Open(options.Path, dbFileMode, options.BoltOptions)
if err != nil {
return nil, err
}
handle.NoSync = options.NoSync
// Create the new store
store := &BoltStore{
conn: handle,
path: options.Path,
}
// If the store was opened read-only, don't try and create buckets
if !options.readOnly() {
// Set up our buckets
if err := store.initialize(); err != nil {
store.Close()
return nil, err
}
}
return store, nil
} | [
"func",
"New",
"(",
"options",
"Options",
")",
"(",
"*",
"BoltStore",
",",
"error",
")",
"{",
"// Try to connect",
"handle",
",",
"err",
":=",
"bolt",
".",
"Open",
"(",
"options",
".",
"Path",
",",
"dbFileMode",
",",
"options",
".",
"BoltOptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"handle",
".",
"NoSync",
"=",
"options",
".",
"NoSync",
"\n\n",
"// Create the new store",
"store",
":=",
"&",
"BoltStore",
"{",
"conn",
":",
"handle",
",",
"path",
":",
"options",
".",
"Path",
",",
"}",
"\n\n",
"// If the store was opened read-only, don't try and create buckets",
"if",
"!",
"options",
".",
"readOnly",
"(",
")",
"{",
"// Set up our buckets",
"if",
"err",
":=",
"store",
".",
"initialize",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"store",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"store",
",",
"nil",
"\n",
"}"
] | // New uses the supplied options to open the BoltDB and prepare it for use as a raft backend. | [
"New",
"uses",
"the",
"supplied",
"options",
"to",
"open",
"the",
"BoltDB",
"and",
"prepare",
"it",
"for",
"use",
"as",
"a",
"raft",
"backend",
"."
] | 6e5ba93211eaf8d9a2ad7e41ffad8c6f160f9fe3 | https://github.com/hashicorp/raft-boltdb/blob/6e5ba93211eaf8d9a2ad7e41ffad8c6f160f9fe3/bolt_store.go#L64-L87 | train |
hashicorp/raft-boltdb | bolt_store.go | initialize | func (b *BoltStore) initialize() error {
tx, err := b.conn.Begin(true)
if err != nil {
return err
}
defer tx.Rollback()
// Create all the buckets
if _, err := tx.CreateBucketIfNotExists(dbLogs); err != nil {
return err
}
if _, err := tx.CreateBucketIfNotExists(dbConf); err != nil {
return err
}
return tx.Commit()
} | go | func (b *BoltStore) initialize() error {
tx, err := b.conn.Begin(true)
if err != nil {
return err
}
defer tx.Rollback()
// Create all the buckets
if _, err := tx.CreateBucketIfNotExists(dbLogs); err != nil {
return err
}
if _, err := tx.CreateBucketIfNotExists(dbConf); err != nil {
return err
}
return tx.Commit()
} | [
"func",
"(",
"b",
"*",
"BoltStore",
")",
"initialize",
"(",
")",
"error",
"{",
"tx",
",",
"err",
":=",
"b",
".",
"conn",
".",
"Begin",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"tx",
".",
"Rollback",
"(",
")",
"\n\n",
"// Create all the buckets",
"if",
"_",
",",
"err",
":=",
"tx",
".",
"CreateBucketIfNotExists",
"(",
"dbLogs",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"tx",
".",
"CreateBucketIfNotExists",
"(",
"dbConf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"tx",
".",
"Commit",
"(",
")",
"\n",
"}"
] | // initialize is used to set up all of the buckets. | [
"initialize",
"is",
"used",
"to",
"set",
"up",
"all",
"of",
"the",
"buckets",
"."
] | 6e5ba93211eaf8d9a2ad7e41ffad8c6f160f9fe3 | https://github.com/hashicorp/raft-boltdb/blob/6e5ba93211eaf8d9a2ad7e41ffad8c6f160f9fe3/bolt_store.go#L90-L106 | train |
hashicorp/raft-boltdb | bolt_store.go | GetLog | func (b *BoltStore) GetLog(idx uint64, log *raft.Log) error {
tx, err := b.conn.Begin(false)
if err != nil {
return err
}
defer tx.Rollback()
bucket := tx.Bucket(dbLogs)
val := bucket.Get(uint64ToBytes(idx))
if val == nil {
return raft.ErrLogNotFound
}
return decodeMsgPack(val, log)
} | go | func (b *BoltStore) GetLog(idx uint64, log *raft.Log) error {
tx, err := b.conn.Begin(false)
if err != nil {
return err
}
defer tx.Rollback()
bucket := tx.Bucket(dbLogs)
val := bucket.Get(uint64ToBytes(idx))
if val == nil {
return raft.ErrLogNotFound
}
return decodeMsgPack(val, log)
} | [
"func",
"(",
"b",
"*",
"BoltStore",
")",
"GetLog",
"(",
"idx",
"uint64",
",",
"log",
"*",
"raft",
".",
"Log",
")",
"error",
"{",
"tx",
",",
"err",
":=",
"b",
".",
"conn",
".",
"Begin",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"tx",
".",
"Rollback",
"(",
")",
"\n\n",
"bucket",
":=",
"tx",
".",
"Bucket",
"(",
"dbLogs",
")",
"\n",
"val",
":=",
"bucket",
".",
"Get",
"(",
"uint64ToBytes",
"(",
"idx",
")",
")",
"\n\n",
"if",
"val",
"==",
"nil",
"{",
"return",
"raft",
".",
"ErrLogNotFound",
"\n",
"}",
"\n",
"return",
"decodeMsgPack",
"(",
"val",
",",
"log",
")",
"\n",
"}"
] | // GetLog is used to retrieve a log from BoltDB at a given index. | [
"GetLog",
"is",
"used",
"to",
"retrieve",
"a",
"log",
"from",
"BoltDB",
"at",
"a",
"given",
"index",
"."
] | 6e5ba93211eaf8d9a2ad7e41ffad8c6f160f9fe3 | https://github.com/hashicorp/raft-boltdb/blob/6e5ba93211eaf8d9a2ad7e41ffad8c6f160f9fe3/bolt_store.go#L146-L160 | train |
mailgun/mailgun-go | domains.go | ListDomains | func (mg *MailgunImpl) ListDomains(opts *ListOptions) *DomainsIterator {
var limit int
if opts != nil {
limit = opts.Limit
}
if limit == 0 {
limit = 100
}
return &DomainsIterator{
mg: mg,
url: generatePublicApiUrl(mg, domainsEndpoint),
domainsListResponse: domainsListResponse{TotalCount: -1},
limit: limit,
}
} | go | func (mg *MailgunImpl) ListDomains(opts *ListOptions) *DomainsIterator {
var limit int
if opts != nil {
limit = opts.Limit
}
if limit == 0 {
limit = 100
}
return &DomainsIterator{
mg: mg,
url: generatePublicApiUrl(mg, domainsEndpoint),
domainsListResponse: domainsListResponse{TotalCount: -1},
limit: limit,
}
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"ListDomains",
"(",
"opts",
"*",
"ListOptions",
")",
"*",
"DomainsIterator",
"{",
"var",
"limit",
"int",
"\n",
"if",
"opts",
"!=",
"nil",
"{",
"limit",
"=",
"opts",
".",
"Limit",
"\n",
"}",
"\n\n",
"if",
"limit",
"==",
"0",
"{",
"limit",
"=",
"100",
"\n",
"}",
"\n",
"return",
"&",
"DomainsIterator",
"{",
"mg",
":",
"mg",
",",
"url",
":",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
",",
"domainsListResponse",
":",
"domainsListResponse",
"{",
"TotalCount",
":",
"-",
"1",
"}",
",",
"limit",
":",
"limit",
",",
"}",
"\n",
"}"
] | // ListDomains retrieves a set of domains from Mailgun. | [
"ListDomains",
"retrieves",
"a",
"set",
"of",
"domains",
"from",
"Mailgun",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/domains.go#L83-L98 | train |
mailgun/mailgun-go | domains.go | GetDomain | func (mg *MailgunImpl) GetDomain(ctx context.Context, domain string) (DomainResponse, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp DomainResponse
err := getResponseFromJSON(ctx, r, &resp)
return resp, err
} | go | func (mg *MailgunImpl) GetDomain(ctx context.Context, domain string) (DomainResponse, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp DomainResponse
err := getResponseFromJSON(ctx, r, &resp)
return resp, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetDomain",
"(",
"ctx",
"context",
".",
"Context",
",",
"domain",
"string",
")",
"(",
"DomainResponse",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"domain",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"var",
"resp",
"DomainResponse",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"resp",
")",
"\n",
"return",
"resp",
",",
"err",
"\n",
"}"
] | // GetDomain retrieves detailed information about the named domain. | [
"GetDomain",
"retrieves",
"detailed",
"information",
"about",
"the",
"named",
"domain",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/domains.go#L235-L242 | train |
mailgun/mailgun-go | domains.go | CreateDomain | func (mg *MailgunImpl) CreateDomain(ctx context.Context, name string, opts *CreateDomainOptions) (DomainResponse, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
payload := newUrlEncodedPayload()
payload.addValue("name", name)
if opts != nil {
if opts.SpamAction != "" {
payload.addValue("spam_action", string(opts.SpamAction))
}
if opts.Wildcard {
payload.addValue("wildcard", boolToString(opts.Wildcard))
}
if opts.ForceDKIMAuthority {
payload.addValue("force_dkim_authority", boolToString(opts.ForceDKIMAuthority))
}
if opts.DKIMKeySize != 0 {
payload.addValue("dkim_key_size", strconv.Itoa(opts.DKIMKeySize))
}
if len(opts.IPS) != 0 {
payload.addValue("ips", strings.Join(opts.IPS, ","))
}
if len(opts.Password) != 0 {
payload.addValue("smtp_password", opts.Password)
}
}
var resp DomainResponse
err := postResponseFromJSON(ctx, r, payload, &resp)
return resp, err
} | go | func (mg *MailgunImpl) CreateDomain(ctx context.Context, name string, opts *CreateDomainOptions) (DomainResponse, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
payload := newUrlEncodedPayload()
payload.addValue("name", name)
if opts != nil {
if opts.SpamAction != "" {
payload.addValue("spam_action", string(opts.SpamAction))
}
if opts.Wildcard {
payload.addValue("wildcard", boolToString(opts.Wildcard))
}
if opts.ForceDKIMAuthority {
payload.addValue("force_dkim_authority", boolToString(opts.ForceDKIMAuthority))
}
if opts.DKIMKeySize != 0 {
payload.addValue("dkim_key_size", strconv.Itoa(opts.DKIMKeySize))
}
if len(opts.IPS) != 0 {
payload.addValue("ips", strings.Join(opts.IPS, ","))
}
if len(opts.Password) != 0 {
payload.addValue("smtp_password", opts.Password)
}
}
var resp DomainResponse
err := postResponseFromJSON(ctx, r, payload, &resp)
return resp, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"CreateDomain",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"opts",
"*",
"CreateDomainOptions",
")",
"(",
"DomainResponse",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n\n",
"payload",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"name",
")",
"\n\n",
"if",
"opts",
"!=",
"nil",
"{",
"if",
"opts",
".",
"SpamAction",
"!=",
"\"",
"\"",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"string",
"(",
"opts",
".",
"SpamAction",
")",
")",
"\n",
"}",
"\n",
"if",
"opts",
".",
"Wildcard",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"boolToString",
"(",
"opts",
".",
"Wildcard",
")",
")",
"\n",
"}",
"\n",
"if",
"opts",
".",
"ForceDKIMAuthority",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"boolToString",
"(",
"opts",
".",
"ForceDKIMAuthority",
")",
")",
"\n",
"}",
"\n",
"if",
"opts",
".",
"DKIMKeySize",
"!=",
"0",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"opts",
".",
"DKIMKeySize",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"opts",
".",
"IPS",
")",
"!=",
"0",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"opts",
".",
"IPS",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"opts",
".",
"Password",
")",
"!=",
"0",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"opts",
".",
"Password",
")",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"resp",
"DomainResponse",
"\n",
"err",
":=",
"postResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"payload",
",",
"&",
"resp",
")",
"\n",
"return",
"resp",
",",
"err",
"\n",
"}"
] | // CreateDomain instructs Mailgun to create a new domain for your account.
// The name parameter identifies the domain.
// The smtpPassword parameter provides an access credential for the domain.
// The spamAction domain must be one of Delete, Tag, or Disabled.
// The wildcard parameter instructs Mailgun to treat all subdomains of this domain uniformly if true,
// and as different domains if false. | [
"CreateDomain",
"instructs",
"Mailgun",
"to",
"create",
"a",
"new",
"domain",
"for",
"your",
"account",
".",
"The",
"name",
"parameter",
"identifies",
"the",
"domain",
".",
"The",
"smtpPassword",
"parameter",
"provides",
"an",
"access",
"credential",
"for",
"the",
"domain",
".",
"The",
"spamAction",
"domain",
"must",
"be",
"one",
"of",
"Delete",
"Tag",
"or",
"Disabled",
".",
"The",
"wildcard",
"parameter",
"instructs",
"Mailgun",
"to",
"treat",
"all",
"subdomains",
"of",
"this",
"domain",
"uniformly",
"if",
"true",
"and",
"as",
"different",
"domains",
"if",
"false",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/domains.go#L271-L302 | train |
mailgun/mailgun-go | domains.go | GetDomainConnection | func (mg *MailgunImpl) GetDomainConnection(ctx context.Context, domain string) (DomainConnection, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain + "/connection")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp domainConnectionResponse
err := getResponseFromJSON(ctx, r, &resp)
return resp.Connection, err
} | go | func (mg *MailgunImpl) GetDomainConnection(ctx context.Context, domain string) (DomainConnection, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain + "/connection")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp domainConnectionResponse
err := getResponseFromJSON(ctx, r, &resp)
return resp.Connection, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetDomainConnection",
"(",
"ctx",
"context",
".",
"Context",
",",
"domain",
"string",
")",
"(",
"DomainConnection",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"domain",
"+",
"\"",
"\"",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"var",
"resp",
"domainConnectionResponse",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"resp",
")",
"\n",
"return",
"resp",
".",
"Connection",
",",
"err",
"\n",
"}"
] | // GetDomainConnection returns delivery connection settings for the defined domain | [
"GetDomainConnection",
"returns",
"delivery",
"connection",
"settings",
"for",
"the",
"defined",
"domain"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/domains.go#L305-L312 | train |
mailgun/mailgun-go | domains.go | UpdateDomainConnection | func (mg *MailgunImpl) UpdateDomainConnection(ctx context.Context, domain string, settings DomainConnection) error {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain + "/connection")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
payload := newUrlEncodedPayload()
payload.addValue("require_tls", boolToString(settings.RequireTLS))
payload.addValue("skip_verification", boolToString(settings.SkipVerification))
_, err := makePutRequest(ctx, r, payload)
return err
} | go | func (mg *MailgunImpl) UpdateDomainConnection(ctx context.Context, domain string, settings DomainConnection) error {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain + "/connection")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
payload := newUrlEncodedPayload()
payload.addValue("require_tls", boolToString(settings.RequireTLS))
payload.addValue("skip_verification", boolToString(settings.SkipVerification))
_, err := makePutRequest(ctx, r, payload)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"UpdateDomainConnection",
"(",
"ctx",
"context",
".",
"Context",
",",
"domain",
"string",
",",
"settings",
"DomainConnection",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"domain",
"+",
"\"",
"\"",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n\n",
"payload",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"boolToString",
"(",
"settings",
".",
"RequireTLS",
")",
")",
"\n",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"boolToString",
"(",
"settings",
".",
"SkipVerification",
")",
")",
"\n",
"_",
",",
"err",
":=",
"makePutRequest",
"(",
"ctx",
",",
"r",
",",
"payload",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Updates the specified delivery connection settings for the defined domain | [
"Updates",
"the",
"specified",
"delivery",
"connection",
"settings",
"for",
"the",
"defined",
"domain"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/domains.go#L315-L325 | train |
mailgun/mailgun-go | domains.go | DeleteDomain | func (mg *MailgunImpl) DeleteDomain(ctx context.Context, name string) error {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + name)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | go | func (mg *MailgunImpl) DeleteDomain(ctx context.Context, name string) error {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + name)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"DeleteDomain",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"name",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"makeDeleteRequest",
"(",
"ctx",
",",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteDomain instructs Mailgun to dispose of the named domain name | [
"DeleteDomain",
"instructs",
"Mailgun",
"to",
"dispose",
"of",
"the",
"named",
"domain",
"name"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/domains.go#L328-L334 | train |
mailgun/mailgun-go | domains.go | GetDomainTracking | func (mg *MailgunImpl) GetDomainTracking(ctx context.Context, domain string) (DomainTracking, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain + "/tracking")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp domainTrackingResponse
err := getResponseFromJSON(ctx, r, &resp)
return resp.Tracking, err
} | go | func (mg *MailgunImpl) GetDomainTracking(ctx context.Context, domain string) (DomainTracking, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain + "/tracking")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp domainTrackingResponse
err := getResponseFromJSON(ctx, r, &resp)
return resp.Tracking, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetDomainTracking",
"(",
"ctx",
"context",
".",
"Context",
",",
"domain",
"string",
")",
"(",
"DomainTracking",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"domain",
"+",
"\"",
"\"",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"var",
"resp",
"domainTrackingResponse",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"resp",
")",
"\n",
"return",
"resp",
".",
"Tracking",
",",
"err",
"\n",
"}"
] | // GetDomainTracking returns tracking settings for a domain | [
"GetDomainTracking",
"returns",
"tracking",
"settings",
"for",
"a",
"domain"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/domains.go#L337-L344 | train |
mailgun/mailgun-go | webhooks.go | ListWebhooks | func (mg *MailgunImpl) ListWebhooks(ctx context.Context) (map[string]string, error) {
r := newHTTPRequest(generateDomainApiUrl(mg, webhooksEndpoint))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var envelope struct {
Webhooks map[string]interface{} `json:"webhooks"`
}
err := getResponseFromJSON(ctx, r, &envelope)
hooks := make(map[string]string, 0)
if err != nil {
return hooks, err
}
for k, v := range envelope.Webhooks {
object := v.(map[string]interface{})
url := object["url"]
hooks[k] = url.(string)
}
return hooks, nil
} | go | func (mg *MailgunImpl) ListWebhooks(ctx context.Context) (map[string]string, error) {
r := newHTTPRequest(generateDomainApiUrl(mg, webhooksEndpoint))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var envelope struct {
Webhooks map[string]interface{} `json:"webhooks"`
}
err := getResponseFromJSON(ctx, r, &envelope)
hooks := make(map[string]string, 0)
if err != nil {
return hooks, err
}
for k, v := range envelope.Webhooks {
object := v.(map[string]interface{})
url := object["url"]
hooks[k] = url.(string)
}
return hooks, nil
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"ListWebhooks",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateDomainApiUrl",
"(",
"mg",
",",
"webhooksEndpoint",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"var",
"envelope",
"struct",
"{",
"Webhooks",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"`json:\"webhooks\"`",
"\n",
"}",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"envelope",
")",
"\n",
"hooks",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"hooks",
",",
"err",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"envelope",
".",
"Webhooks",
"{",
"object",
":=",
"v",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"url",
":=",
"object",
"[",
"\"",
"\"",
"]",
"\n",
"hooks",
"[",
"k",
"]",
"=",
"url",
".",
"(",
"string",
")",
"\n",
"}",
"\n",
"return",
"hooks",
",",
"nil",
"\n",
"}"
] | // ListWebhooks returns the complete set of webhooks configured for your domain.
// Note that a zero-length mapping is not an error. | [
"ListWebhooks",
"returns",
"the",
"complete",
"set",
"of",
"webhooks",
"configured",
"for",
"your",
"domain",
".",
"Note",
"that",
"a",
"zero",
"-",
"length",
"mapping",
"is",
"not",
"an",
"error",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/webhooks.go#L17-L35 | train |
mailgun/mailgun-go | webhooks.go | DeleteWebhook | func (mg *MailgunImpl) DeleteWebhook(ctx context.Context, t string) error {
r := newHTTPRequest(generateDomainApiUrl(mg, webhooksEndpoint) + "/" + t)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | go | func (mg *MailgunImpl) DeleteWebhook(ctx context.Context, t string) error {
r := newHTTPRequest(generateDomainApiUrl(mg, webhooksEndpoint) + "/" + t)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"DeleteWebhook",
"(",
"ctx",
"context",
".",
"Context",
",",
"t",
"string",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateDomainApiUrl",
"(",
"mg",
",",
"webhooksEndpoint",
")",
"+",
"\"",
"\"",
"+",
"t",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"makeDeleteRequest",
"(",
"ctx",
",",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteWebhook removes the specified webhook from your domain's configuration. | [
"DeleteWebhook",
"removes",
"the",
"specified",
"webhook",
"from",
"your",
"domain",
"s",
"configuration",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/webhooks.go#L52-L58 | train |
mailgun/mailgun-go | webhooks.go | GetWebhook | func (mg *MailgunImpl) GetWebhook(ctx context.Context, t string) (string, error) {
r := newHTTPRequest(generateDomainApiUrl(mg, webhooksEndpoint) + "/" + t)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var envelope struct {
Webhook struct {
Url string `json:"url"`
} `json:"webhook"`
}
err := getResponseFromJSON(ctx, r, &envelope)
return envelope.Webhook.Url, err
} | go | func (mg *MailgunImpl) GetWebhook(ctx context.Context, t string) (string, error) {
r := newHTTPRequest(generateDomainApiUrl(mg, webhooksEndpoint) + "/" + t)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var envelope struct {
Webhook struct {
Url string `json:"url"`
} `json:"webhook"`
}
err := getResponseFromJSON(ctx, r, &envelope)
return envelope.Webhook.Url, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetWebhook",
"(",
"ctx",
"context",
".",
"Context",
",",
"t",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateDomainApiUrl",
"(",
"mg",
",",
"webhooksEndpoint",
")",
"+",
"\"",
"\"",
"+",
"t",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"var",
"envelope",
"struct",
"{",
"Webhook",
"struct",
"{",
"Url",
"string",
"`json:\"url\"`",
"\n",
"}",
"`json:\"webhook\"`",
"\n",
"}",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"envelope",
")",
"\n",
"return",
"envelope",
".",
"Webhook",
".",
"Url",
",",
"err",
"\n",
"}"
] | // GetWebhook retrieves the currently assigned webhook URL associated with the provided type of webhook. | [
"GetWebhook",
"retrieves",
"the",
"currently",
"assigned",
"webhook",
"URL",
"associated",
"with",
"the",
"provided",
"type",
"of",
"webhook",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/webhooks.go#L61-L72 | train |
mailgun/mailgun-go | webhooks.go | UpdateWebhook | func (mg *MailgunImpl) UpdateWebhook(ctx context.Context, t string, urls []string) error {
r := newHTTPRequest(generateDomainApiUrl(mg, webhooksEndpoint) + "/" + t)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
for _, url := range urls {
p.addValue("url", url)
}
_, err := makePutRequest(ctx, r, p)
return err
} | go | func (mg *MailgunImpl) UpdateWebhook(ctx context.Context, t string, urls []string) error {
r := newHTTPRequest(generateDomainApiUrl(mg, webhooksEndpoint) + "/" + t)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
for _, url := range urls {
p.addValue("url", url)
}
_, err := makePutRequest(ctx, r, p)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"UpdateWebhook",
"(",
"ctx",
"context",
".",
"Context",
",",
"t",
"string",
",",
"urls",
"[",
"]",
"string",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateDomainApiUrl",
"(",
"mg",
",",
"webhooksEndpoint",
")",
"+",
"\"",
"\"",
"+",
"t",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"p",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"for",
"_",
",",
"url",
":=",
"range",
"urls",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"url",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"makePutRequest",
"(",
"ctx",
",",
"r",
",",
"p",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // UpdateWebhook replaces one webhook setting for another. | [
"UpdateWebhook",
"replaces",
"one",
"webhook",
"setting",
"for",
"another",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/webhooks.go#L75-L85 | train |
mailgun/mailgun-go | webhooks.go | VerifyWebhookSignature | func (mg *MailgunImpl) VerifyWebhookSignature(sig Signature) (verified bool, err error) {
h := hmac.New(sha256.New, []byte(mg.APIKey()))
io.WriteString(h, sig.TimeStamp)
io.WriteString(h, sig.Token)
calculatedSignature := h.Sum(nil)
signature, err := hex.DecodeString(sig.Signature)
if err != nil {
return false, err
}
if len(calculatedSignature) != len(signature) {
return false, nil
}
return subtle.ConstantTimeCompare(signature, calculatedSignature) == 1, nil
} | go | func (mg *MailgunImpl) VerifyWebhookSignature(sig Signature) (verified bool, err error) {
h := hmac.New(sha256.New, []byte(mg.APIKey()))
io.WriteString(h, sig.TimeStamp)
io.WriteString(h, sig.Token)
calculatedSignature := h.Sum(nil)
signature, err := hex.DecodeString(sig.Signature)
if err != nil {
return false, err
}
if len(calculatedSignature) != len(signature) {
return false, nil
}
return subtle.ConstantTimeCompare(signature, calculatedSignature) == 1, nil
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"VerifyWebhookSignature",
"(",
"sig",
"Signature",
")",
"(",
"verified",
"bool",
",",
"err",
"error",
")",
"{",
"h",
":=",
"hmac",
".",
"New",
"(",
"sha256",
".",
"New",
",",
"[",
"]",
"byte",
"(",
"mg",
".",
"APIKey",
"(",
")",
")",
")",
"\n",
"io",
".",
"WriteString",
"(",
"h",
",",
"sig",
".",
"TimeStamp",
")",
"\n",
"io",
".",
"WriteString",
"(",
"h",
",",
"sig",
".",
"Token",
")",
"\n\n",
"calculatedSignature",
":=",
"h",
".",
"Sum",
"(",
"nil",
")",
"\n",
"signature",
",",
"err",
":=",
"hex",
".",
"DecodeString",
"(",
"sig",
".",
"Signature",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"calculatedSignature",
")",
"!=",
"len",
"(",
"signature",
")",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"subtle",
".",
"ConstantTimeCompare",
"(",
"signature",
",",
"calculatedSignature",
")",
"==",
"1",
",",
"nil",
"\n",
"}"
] | // Use this method to parse the webhook signature given as JSON in the webhook response | [
"Use",
"this",
"method",
"to",
"parse",
"the",
"webhook",
"signature",
"given",
"as",
"JSON",
"in",
"the",
"webhook",
"response"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/webhooks.go#L101-L116 | train |
mailgun/mailgun-go | rest_shim.go | newError | func newError(url string, expected []int, got *httpResponse) error {
return &UnexpectedResponseError{
URL: url,
Expected: expected,
Actual: got.Code,
Data: got.Data,
}
} | go | func newError(url string, expected []int, got *httpResponse) error {
return &UnexpectedResponseError{
URL: url,
Expected: expected,
Actual: got.Code,
Data: got.Data,
}
} | [
"func",
"newError",
"(",
"url",
"string",
",",
"expected",
"[",
"]",
"int",
",",
"got",
"*",
"httpResponse",
")",
"error",
"{",
"return",
"&",
"UnexpectedResponseError",
"{",
"URL",
":",
"url",
",",
"Expected",
":",
"expected",
",",
"Actual",
":",
"got",
".",
"Code",
",",
"Data",
":",
"got",
".",
"Data",
",",
"}",
"\n",
"}"
] | // newError creates a new error condition to be returned. | [
"newError",
"creates",
"a",
"new",
"error",
"condition",
"to",
"be",
"returned",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/rest_shim.go#L35-L42 | train |
mailgun/mailgun-go | rest_shim.go | makeRequest | func makeRequest(ctx context.Context, r *httpRequest, method string, p payload) (*httpResponse, error) {
r.addHeader("User-Agent", MailgunGoUserAgent)
rsp, err := r.makeRequest(ctx, method, p)
if (err == nil) && notGood(rsp.Code, expected) {
return rsp, newError(r.URL, expected, rsp)
}
return rsp, err
} | go | func makeRequest(ctx context.Context, r *httpRequest, method string, p payload) (*httpResponse, error) {
r.addHeader("User-Agent", MailgunGoUserAgent)
rsp, err := r.makeRequest(ctx, method, p)
if (err == nil) && notGood(rsp.Code, expected) {
return rsp, newError(r.URL, expected, rsp)
}
return rsp, err
} | [
"func",
"makeRequest",
"(",
"ctx",
"context",
".",
"Context",
",",
"r",
"*",
"httpRequest",
",",
"method",
"string",
",",
"p",
"payload",
")",
"(",
"*",
"httpResponse",
",",
"error",
")",
"{",
"r",
".",
"addHeader",
"(",
"\"",
"\"",
",",
"MailgunGoUserAgent",
")",
"\n",
"rsp",
",",
"err",
":=",
"r",
".",
"makeRequest",
"(",
"ctx",
",",
"method",
",",
"p",
")",
"\n",
"if",
"(",
"err",
"==",
"nil",
")",
"&&",
"notGood",
"(",
"rsp",
".",
"Code",
",",
"expected",
")",
"{",
"return",
"rsp",
",",
"newError",
"(",
"r",
".",
"URL",
",",
"expected",
",",
"rsp",
")",
"\n",
"}",
"\n",
"return",
"rsp",
",",
"err",
"\n",
"}"
] | // makeRequest shim performs a generic request, checking for a positive outcome.
// See simplehttp.MakeRequest for more details. | [
"makeRequest",
"shim",
"performs",
"a",
"generic",
"request",
"checking",
"for",
"a",
"positive",
"outcome",
".",
"See",
"simplehttp",
".",
"MakeRequest",
"for",
"more",
"details",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/rest_shim.go#L61-L68 | train |
mailgun/mailgun-go | rest_shim.go | getResponseFromJSON | func getResponseFromJSON(ctx context.Context, r *httpRequest, v interface{}) error {
r.addHeader("User-Agent", MailgunGoUserAgent)
response, err := r.makeGetRequest(ctx)
if err != nil {
return err
}
if notGood(response.Code, expected) {
return newError(r.URL, expected, response)
}
return response.parseFromJSON(v)
} | go | func getResponseFromJSON(ctx context.Context, r *httpRequest, v interface{}) error {
r.addHeader("User-Agent", MailgunGoUserAgent)
response, err := r.makeGetRequest(ctx)
if err != nil {
return err
}
if notGood(response.Code, expected) {
return newError(r.URL, expected, response)
}
return response.parseFromJSON(v)
} | [
"func",
"getResponseFromJSON",
"(",
"ctx",
"context",
".",
"Context",
",",
"r",
"*",
"httpRequest",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"r",
".",
"addHeader",
"(",
"\"",
"\"",
",",
"MailgunGoUserAgent",
")",
"\n",
"response",
",",
"err",
":=",
"r",
".",
"makeGetRequest",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"notGood",
"(",
"response",
".",
"Code",
",",
"expected",
")",
"{",
"return",
"newError",
"(",
"r",
".",
"URL",
",",
"expected",
",",
"response",
")",
"\n",
"}",
"\n",
"return",
"response",
".",
"parseFromJSON",
"(",
"v",
")",
"\n",
"}"
] | // getResponseFromJSON shim performs a GET request, checking for a positive outcome.
// See simplehttp.GetResponseFromJSON for more details. | [
"getResponseFromJSON",
"shim",
"performs",
"a",
"GET",
"request",
"checking",
"for",
"a",
"positive",
"outcome",
".",
"See",
"simplehttp",
".",
"GetResponseFromJSON",
"for",
"more",
"details",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/rest_shim.go#L72-L82 | train |
mailgun/mailgun-go | rest_shim.go | postResponseFromJSON | func postResponseFromJSON(ctx context.Context, r *httpRequest, p payload, v interface{}) error {
r.addHeader("User-Agent", MailgunGoUserAgent)
response, err := r.makePostRequest(ctx, p)
if err != nil {
return err
}
if notGood(response.Code, expected) {
return newError(r.URL, expected, response)
}
return response.parseFromJSON(v)
} | go | func postResponseFromJSON(ctx context.Context, r *httpRequest, p payload, v interface{}) error {
r.addHeader("User-Agent", MailgunGoUserAgent)
response, err := r.makePostRequest(ctx, p)
if err != nil {
return err
}
if notGood(response.Code, expected) {
return newError(r.URL, expected, response)
}
return response.parseFromJSON(v)
} | [
"func",
"postResponseFromJSON",
"(",
"ctx",
"context",
".",
"Context",
",",
"r",
"*",
"httpRequest",
",",
"p",
"payload",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"r",
".",
"addHeader",
"(",
"\"",
"\"",
",",
"MailgunGoUserAgent",
")",
"\n",
"response",
",",
"err",
":=",
"r",
".",
"makePostRequest",
"(",
"ctx",
",",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"notGood",
"(",
"response",
".",
"Code",
",",
"expected",
")",
"{",
"return",
"newError",
"(",
"r",
".",
"URL",
",",
"expected",
",",
"response",
")",
"\n",
"}",
"\n",
"return",
"response",
".",
"parseFromJSON",
"(",
"v",
")",
"\n",
"}"
] | // postResponseFromJSON shim performs a POST request, checking for a positive outcome.
// See simplehttp.PostResponseFromJSON for more details. | [
"postResponseFromJSON",
"shim",
"performs",
"a",
"POST",
"request",
"checking",
"for",
"a",
"positive",
"outcome",
".",
"See",
"simplehttp",
".",
"PostResponseFromJSON",
"for",
"more",
"details",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/rest_shim.go#L86-L96 | train |
mailgun/mailgun-go | rest_shim.go | GetStatusFromErr | func GetStatusFromErr(err error) int {
obj, ok := err.(*UnexpectedResponseError)
if !ok {
return -1
}
return obj.Actual
} | go | func GetStatusFromErr(err error) int {
obj, ok := err.(*UnexpectedResponseError)
if !ok {
return -1
}
return obj.Actual
} | [
"func",
"GetStatusFromErr",
"(",
"err",
"error",
")",
"int",
"{",
"obj",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"UnexpectedResponseError",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n",
"return",
"obj",
".",
"Actual",
"\n",
"}"
] | // Extract the http status code from error object | [
"Extract",
"the",
"http",
"status",
"code",
"from",
"error",
"object"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/rest_shim.go#L157-L163 | train |
mailgun/mailgun-go | ips.go | ListIPS | func (mg *MailgunImpl) ListIPS(ctx context.Context, dedicated bool) ([]IPAddress, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, ipsEndpoint))
r.setClient(mg.Client())
if dedicated {
r.addParameter("dedicated", "true")
}
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp ipAddressListResponse
if err := getResponseFromJSON(ctx, r, &resp); err != nil {
return nil, err
}
var result []IPAddress
for _, ip := range resp.Items {
result = append(result, IPAddress{IP: ip})
}
return result, nil
} | go | func (mg *MailgunImpl) ListIPS(ctx context.Context, dedicated bool) ([]IPAddress, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, ipsEndpoint))
r.setClient(mg.Client())
if dedicated {
r.addParameter("dedicated", "true")
}
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp ipAddressListResponse
if err := getResponseFromJSON(ctx, r, &resp); err != nil {
return nil, err
}
var result []IPAddress
for _, ip := range resp.Items {
result = append(result, IPAddress{IP: ip})
}
return result, nil
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"ListIPS",
"(",
"ctx",
"context",
".",
"Context",
",",
"dedicated",
"bool",
")",
"(",
"[",
"]",
"IPAddress",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"ipsEndpoint",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"if",
"dedicated",
"{",
"r",
".",
"addParameter",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n\n",
"var",
"resp",
"ipAddressListResponse",
"\n",
"if",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"result",
"[",
"]",
"IPAddress",
"\n",
"for",
"_",
",",
"ip",
":=",
"range",
"resp",
".",
"Items",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"IPAddress",
"{",
"IP",
":",
"ip",
"}",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // ListIPS returns a list of IPs assigned to your account | [
"ListIPS",
"returns",
"a",
"list",
"of",
"IPs",
"assigned",
"to",
"your",
"account"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/ips.go#L22-L39 | train |
mailgun/mailgun-go | ips.go | GetIP | func (mg *MailgunImpl) GetIP(ctx context.Context, ip string) (IPAddress, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, ipsEndpoint) + "/" + ip)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp IPAddress
err := getResponseFromJSON(ctx, r, &resp)
return resp, err
} | go | func (mg *MailgunImpl) GetIP(ctx context.Context, ip string) (IPAddress, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, ipsEndpoint) + "/" + ip)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp IPAddress
err := getResponseFromJSON(ctx, r, &resp)
return resp, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetIP",
"(",
"ctx",
"context",
".",
"Context",
",",
"ip",
"string",
")",
"(",
"IPAddress",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"ipsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"ip",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"var",
"resp",
"IPAddress",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"resp",
")",
"\n",
"return",
"resp",
",",
"err",
"\n",
"}"
] | // GetIP returns information about the specified IP | [
"GetIP",
"returns",
"information",
"about",
"the",
"specified",
"IP"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/ips.go#L42-L49 | train |
mailgun/mailgun-go | ips.go | ListDomainIPS | func (mg *MailgunImpl) ListDomainIPS(ctx context.Context) ([]IPAddress, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + mg.domain + "/ips")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp ipAddressListResponse
if err := getResponseFromJSON(ctx, r, &resp); err != nil {
return nil, err
}
var result []IPAddress
for _, ip := range resp.Items {
result = append(result, IPAddress{IP: ip})
}
return result, nil
} | go | func (mg *MailgunImpl) ListDomainIPS(ctx context.Context) ([]IPAddress, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + mg.domain + "/ips")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp ipAddressListResponse
if err := getResponseFromJSON(ctx, r, &resp); err != nil {
return nil, err
}
var result []IPAddress
for _, ip := range resp.Items {
result = append(result, IPAddress{IP: ip})
}
return result, nil
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"ListDomainIPS",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"IPAddress",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"mg",
".",
"domain",
"+",
"\"",
"\"",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n\n",
"var",
"resp",
"ipAddressListResponse",
"\n",
"if",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"result",
"[",
"]",
"IPAddress",
"\n",
"for",
"_",
",",
"ip",
":=",
"range",
"resp",
".",
"Items",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"IPAddress",
"{",
"IP",
":",
"ip",
"}",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // ListDomainIPS returns a list of IPs currently assigned to the specified domain. | [
"ListDomainIPS",
"returns",
"a",
"list",
"of",
"IPs",
"currently",
"assigned",
"to",
"the",
"specified",
"domain",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/ips.go#L52-L66 | train |
mailgun/mailgun-go | ips.go | AddDomainIP | func (mg *MailgunImpl) AddDomainIP(ctx context.Context, ip string) error {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + mg.domain + "/ips")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
payload := newUrlEncodedPayload()
payload.addValue("ip", ip)
_, err := makePostRequest(ctx, r, payload)
return err
} | go | func (mg *MailgunImpl) AddDomainIP(ctx context.Context, ip string) error {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + mg.domain + "/ips")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
payload := newUrlEncodedPayload()
payload.addValue("ip", ip)
_, err := makePostRequest(ctx, r, payload)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"AddDomainIP",
"(",
"ctx",
"context",
".",
"Context",
",",
"ip",
"string",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"mg",
".",
"domain",
"+",
"\"",
"\"",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n\n",
"payload",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"ip",
")",
"\n",
"_",
",",
"err",
":=",
"makePostRequest",
"(",
"ctx",
",",
"r",
",",
"payload",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Assign a dedicated IP to the domain specified. | [
"Assign",
"a",
"dedicated",
"IP",
"to",
"the",
"domain",
"specified",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/ips.go#L69-L78 | train |
mailgun/mailgun-go | ips.go | DeleteDomainIP | func (mg *MailgunImpl) DeleteDomainIP(ctx context.Context, ip string) error {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + mg.domain + "/ips/" + ip)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | go | func (mg *MailgunImpl) DeleteDomainIP(ctx context.Context, ip string) error {
r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + mg.domain + "/ips/" + ip)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"DeleteDomainIP",
"(",
"ctx",
"context",
".",
"Context",
",",
"ip",
"string",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"domainsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"mg",
".",
"domain",
"+",
"\"",
"\"",
"+",
"ip",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"makeDeleteRequest",
"(",
"ctx",
",",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Unassign an IP from the domain specified. | [
"Unassign",
"an",
"IP",
"from",
"the",
"domain",
"specified",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/ips.go#L81-L87 | train |
mailgun/mailgun-go | credentials.go | CreateCredential | func (mg *MailgunImpl) CreateCredential(ctx context.Context, login, password string) error {
if (login == "") || (password == "") {
return ErrEmptyParam
}
r := newHTTPRequest(generateCredentialsUrl(mg, ""))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
p.addValue("login", login)
p.addValue("password", password)
_, err := makePostRequest(ctx, r, p)
return err
} | go | func (mg *MailgunImpl) CreateCredential(ctx context.Context, login, password string) error {
if (login == "") || (password == "") {
return ErrEmptyParam
}
r := newHTTPRequest(generateCredentialsUrl(mg, ""))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
p.addValue("login", login)
p.addValue("password", password)
_, err := makePostRequest(ctx, r, p)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"CreateCredential",
"(",
"ctx",
"context",
".",
"Context",
",",
"login",
",",
"password",
"string",
")",
"error",
"{",
"if",
"(",
"login",
"==",
"\"",
"\"",
")",
"||",
"(",
"password",
"==",
"\"",
"\"",
")",
"{",
"return",
"ErrEmptyParam",
"\n",
"}",
"\n",
"r",
":=",
"newHTTPRequest",
"(",
"generateCredentialsUrl",
"(",
"mg",
",",
"\"",
"\"",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"p",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"login",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"password",
")",
"\n",
"_",
",",
"err",
":=",
"makePostRequest",
"(",
"ctx",
",",
"r",
",",
"p",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // CreateCredential attempts to create associate a new principle with your domain. | [
"CreateCredential",
"attempts",
"to",
"create",
"associate",
"a",
"new",
"principle",
"with",
"your",
"domain",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/credentials.go#L178-L190 | train |
mailgun/mailgun-go | credentials.go | ChangeCredentialPassword | func (mg *MailgunImpl) ChangeCredentialPassword(ctx context.Context, id, password string) error {
if (id == "") || (password == "") {
return ErrEmptyParam
}
r := newHTTPRequest(generateCredentialsUrl(mg, id))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
p.addValue("password", password)
_, err := makePutRequest(ctx, r, p)
return err
} | go | func (mg *MailgunImpl) ChangeCredentialPassword(ctx context.Context, id, password string) error {
if (id == "") || (password == "") {
return ErrEmptyParam
}
r := newHTTPRequest(generateCredentialsUrl(mg, id))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
p.addValue("password", password)
_, err := makePutRequest(ctx, r, p)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"ChangeCredentialPassword",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
",",
"password",
"string",
")",
"error",
"{",
"if",
"(",
"id",
"==",
"\"",
"\"",
")",
"||",
"(",
"password",
"==",
"\"",
"\"",
")",
"{",
"return",
"ErrEmptyParam",
"\n",
"}",
"\n",
"r",
":=",
"newHTTPRequest",
"(",
"generateCredentialsUrl",
"(",
"mg",
",",
"id",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"p",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"password",
")",
"\n",
"_",
",",
"err",
":=",
"makePutRequest",
"(",
"ctx",
",",
"r",
",",
"p",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // ChangeCredentialPassword attempts to alter the indicated credential's password. | [
"ChangeCredentialPassword",
"attempts",
"to",
"alter",
"the",
"indicated",
"credential",
"s",
"password",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/credentials.go#L193-L204 | train |
mailgun/mailgun-go | credentials.go | DeleteCredential | func (mg *MailgunImpl) DeleteCredential(ctx context.Context, id string) error {
if id == "" {
return ErrEmptyParam
}
r := newHTTPRequest(generateCredentialsUrl(mg, id))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | go | func (mg *MailgunImpl) DeleteCredential(ctx context.Context, id string) error {
if id == "" {
return ErrEmptyParam
}
r := newHTTPRequest(generateCredentialsUrl(mg, id))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"DeleteCredential",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"string",
")",
"error",
"{",
"if",
"id",
"==",
"\"",
"\"",
"{",
"return",
"ErrEmptyParam",
"\n",
"}",
"\n",
"r",
":=",
"newHTTPRequest",
"(",
"generateCredentialsUrl",
"(",
"mg",
",",
"id",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"makeDeleteRequest",
"(",
"ctx",
",",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteCredential attempts to remove the indicated principle from the domain. | [
"DeleteCredential",
"attempts",
"to",
"remove",
"the",
"indicated",
"principle",
"from",
"the",
"domain",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/credentials.go#L207-L216 | train |
mailgun/mailgun-go | template_versions.go | AddTemplateVersion | func (mg *MailgunImpl) AddTemplateVersion(ctx context.Context, templateName string, version *TemplateVersion) error {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
payload := newUrlEncodedPayload()
payload.addValue("template", version.Template)
if version.Tag != "" {
payload.addValue("tag", string(version.Tag))
}
if version.Engine != "" {
payload.addValue("engine", string(version.Engine))
}
if version.Comment != "" {
payload.addValue("comment", version.Comment)
}
if version.Active {
payload.addValue("active", boolToString(version.Active))
}
var resp templateResp
if err := postResponseFromJSON(ctx, r, payload, &resp); err != nil {
return err
}
*version = resp.Item.Version
return nil
} | go | func (mg *MailgunImpl) AddTemplateVersion(ctx context.Context, templateName string, version *TemplateVersion) error {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
payload := newUrlEncodedPayload()
payload.addValue("template", version.Template)
if version.Tag != "" {
payload.addValue("tag", string(version.Tag))
}
if version.Engine != "" {
payload.addValue("engine", string(version.Engine))
}
if version.Comment != "" {
payload.addValue("comment", version.Comment)
}
if version.Active {
payload.addValue("active", boolToString(version.Active))
}
var resp templateResp
if err := postResponseFromJSON(ctx, r, payload, &resp); err != nil {
return err
}
*version = resp.Item.Version
return nil
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"AddTemplateVersion",
"(",
"ctx",
"context",
".",
"Context",
",",
"templateName",
"string",
",",
"version",
"*",
"TemplateVersion",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateApiUrl",
"(",
"mg",
",",
"templatesEndpoint",
")",
"+",
"\"",
"\"",
"+",
"templateName",
"+",
"\"",
"\"",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n\n",
"payload",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"version",
".",
"Template",
")",
"\n\n",
"if",
"version",
".",
"Tag",
"!=",
"\"",
"\"",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"string",
"(",
"version",
".",
"Tag",
")",
")",
"\n",
"}",
"\n",
"if",
"version",
".",
"Engine",
"!=",
"\"",
"\"",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"string",
"(",
"version",
".",
"Engine",
")",
")",
"\n",
"}",
"\n",
"if",
"version",
".",
"Comment",
"!=",
"\"",
"\"",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"version",
".",
"Comment",
")",
"\n",
"}",
"\n",
"if",
"version",
".",
"Active",
"{",
"payload",
".",
"addValue",
"(",
"\"",
"\"",
",",
"boolToString",
"(",
"version",
".",
"Active",
")",
")",
"\n",
"}",
"\n\n",
"var",
"resp",
"templateResp",
"\n",
"if",
"err",
":=",
"postResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"payload",
",",
"&",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"*",
"version",
"=",
"resp",
".",
"Item",
".",
"Version",
"\n",
"return",
"nil",
"\n",
"}"
] | // AddTemplateVersion adds a template version to a template | [
"AddTemplateVersion",
"adds",
"a",
"template",
"version",
"to",
"a",
"template"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/template_versions.go#L26-L53 | train |
mailgun/mailgun-go | template_versions.go | GetTemplateVersion | func (mg *MailgunImpl) GetTemplateVersion(ctx context.Context, templateName, tag string) (TemplateVersion, error) {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions/" + tag)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp templateResp
err := getResponseFromJSON(ctx, r, &resp)
if err != nil {
return TemplateVersion{}, err
}
return resp.Item.Version, nil
} | go | func (mg *MailgunImpl) GetTemplateVersion(ctx context.Context, templateName, tag string) (TemplateVersion, error) {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions/" + tag)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var resp templateResp
err := getResponseFromJSON(ctx, r, &resp)
if err != nil {
return TemplateVersion{}, err
}
return resp.Item.Version, nil
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetTemplateVersion",
"(",
"ctx",
"context",
".",
"Context",
",",
"templateName",
",",
"tag",
"string",
")",
"(",
"TemplateVersion",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateApiUrl",
"(",
"mg",
",",
"templatesEndpoint",
")",
"+",
"\"",
"\"",
"+",
"templateName",
"+",
"\"",
"\"",
"+",
"tag",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n\n",
"var",
"resp",
"templateResp",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"resp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"TemplateVersion",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Item",
".",
"Version",
",",
"nil",
"\n",
"}"
] | // GetTemplateVersion gets a specific version of a template | [
"GetTemplateVersion",
"gets",
"a",
"specific",
"version",
"of",
"a",
"template"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/template_versions.go#L56-L67 | train |
mailgun/mailgun-go | template_versions.go | UpdateTemplateVersion | func (mg *MailgunImpl) UpdateTemplateVersion(ctx context.Context, templateName string, version *TemplateVersion) error {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions/" + version.Tag)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
if version.Comment != "" {
p.addValue("comment", version.Comment)
}
if version.Active {
p.addValue("active", boolToString(version.Active))
}
var resp templateResp
err := putResponseFromJSON(ctx, r, p, &resp)
if err != nil {
return err
}
*version = resp.Item.Version
return nil
} | go | func (mg *MailgunImpl) UpdateTemplateVersion(ctx context.Context, templateName string, version *TemplateVersion) error {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions/" + version.Tag)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
if version.Comment != "" {
p.addValue("comment", version.Comment)
}
if version.Active {
p.addValue("active", boolToString(version.Active))
}
var resp templateResp
err := putResponseFromJSON(ctx, r, p, &resp)
if err != nil {
return err
}
*version = resp.Item.Version
return nil
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"UpdateTemplateVersion",
"(",
"ctx",
"context",
".",
"Context",
",",
"templateName",
"string",
",",
"version",
"*",
"TemplateVersion",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateApiUrl",
"(",
"mg",
",",
"templatesEndpoint",
")",
"+",
"\"",
"\"",
"+",
"templateName",
"+",
"\"",
"\"",
"+",
"version",
".",
"Tag",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"p",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n\n",
"if",
"version",
".",
"Comment",
"!=",
"\"",
"\"",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"version",
".",
"Comment",
")",
"\n",
"}",
"\n",
"if",
"version",
".",
"Active",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"boolToString",
"(",
"version",
".",
"Active",
")",
")",
"\n",
"}",
"\n\n",
"var",
"resp",
"templateResp",
"\n",
"err",
":=",
"putResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"p",
",",
"&",
"resp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"*",
"version",
"=",
"resp",
".",
"Item",
".",
"Version",
"\n",
"return",
"nil",
"\n",
"}"
] | // Update the comment and mark a version of a template active | [
"Update",
"the",
"comment",
"and",
"mark",
"a",
"version",
"of",
"a",
"template",
"active"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/template_versions.go#L70-L90 | train |
mailgun/mailgun-go | template_versions.go | DeleteTemplateVersion | func (mg *MailgunImpl) DeleteTemplateVersion(ctx context.Context, templateName, tag string) error {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions/" + tag)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | go | func (mg *MailgunImpl) DeleteTemplateVersion(ctx context.Context, templateName, tag string) error {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions/" + tag)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"DeleteTemplateVersion",
"(",
"ctx",
"context",
".",
"Context",
",",
"templateName",
",",
"tag",
"string",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateApiUrl",
"(",
"mg",
",",
"templatesEndpoint",
")",
"+",
"\"",
"\"",
"+",
"templateName",
"+",
"\"",
"\"",
"+",
"tag",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"makeDeleteRequest",
"(",
"ctx",
",",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Delete a specific version of a template | [
"Delete",
"a",
"specific",
"version",
"of",
"a",
"template"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/template_versions.go#L93-L99 | train |
mailgun/mailgun-go | template_versions.go | ListTemplateVersions | func (mg *MailgunImpl) ListTemplateVersions(templateName string, opts *ListOptions) *TemplateVersionsIterator {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
if opts != nil {
if opts.Limit != 0 {
r.addParameter("limit", strconv.Itoa(opts.Limit))
}
}
url, err := r.generateUrlWithParameters()
return &TemplateVersionsIterator{
mg: mg,
templateVersionListResp: templateVersionListResp{Paging: Paging{Next: url, First: url}},
err: err,
}
} | go | func (mg *MailgunImpl) ListTemplateVersions(templateName string, opts *ListOptions) *TemplateVersionsIterator {
r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + templateName + "/versions")
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
if opts != nil {
if opts.Limit != 0 {
r.addParameter("limit", strconv.Itoa(opts.Limit))
}
}
url, err := r.generateUrlWithParameters()
return &TemplateVersionsIterator{
mg: mg,
templateVersionListResp: templateVersionListResp{Paging: Paging{Next: url, First: url}},
err: err,
}
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"ListTemplateVersions",
"(",
"templateName",
"string",
",",
"opts",
"*",
"ListOptions",
")",
"*",
"TemplateVersionsIterator",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateApiUrl",
"(",
"mg",
",",
"templatesEndpoint",
")",
"+",
"\"",
"\"",
"+",
"templateName",
"+",
"\"",
"\"",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"if",
"opts",
"!=",
"nil",
"{",
"if",
"opts",
".",
"Limit",
"!=",
"0",
"{",
"r",
".",
"addParameter",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"opts",
".",
"Limit",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"url",
",",
"err",
":=",
"r",
".",
"generateUrlWithParameters",
"(",
")",
"\n",
"return",
"&",
"TemplateVersionsIterator",
"{",
"mg",
":",
"mg",
",",
"templateVersionListResp",
":",
"templateVersionListResp",
"{",
"Paging",
":",
"Paging",
"{",
"Next",
":",
"url",
",",
"First",
":",
"url",
"}",
"}",
",",
"err",
":",
"err",
",",
"}",
"\n",
"}"
] | // List all the versions of a specific template | [
"List",
"all",
"the",
"versions",
"of",
"a",
"specific",
"template"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/template_versions.go#L108-L123 | train |
mailgun/mailgun-go | routes.go | ListRoutes | func (mg *MailgunImpl) ListRoutes(opts *ListOptions) *RoutesIterator {
var limit int
if opts != nil {
limit = opts.Limit
}
if limit == 0 {
limit = 100
}
return &RoutesIterator{
mg: mg,
url: generatePublicApiUrl(mg, routesEndpoint),
routesListResponse: routesListResponse{TotalCount: -1},
limit: limit,
}
} | go | func (mg *MailgunImpl) ListRoutes(opts *ListOptions) *RoutesIterator {
var limit int
if opts != nil {
limit = opts.Limit
}
if limit == 0 {
limit = 100
}
return &RoutesIterator{
mg: mg,
url: generatePublicApiUrl(mg, routesEndpoint),
routesListResponse: routesListResponse{TotalCount: -1},
limit: limit,
}
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"ListRoutes",
"(",
"opts",
"*",
"ListOptions",
")",
"*",
"RoutesIterator",
"{",
"var",
"limit",
"int",
"\n",
"if",
"opts",
"!=",
"nil",
"{",
"limit",
"=",
"opts",
".",
"Limit",
"\n",
"}",
"\n\n",
"if",
"limit",
"==",
"0",
"{",
"limit",
"=",
"100",
"\n",
"}",
"\n\n",
"return",
"&",
"RoutesIterator",
"{",
"mg",
":",
"mg",
",",
"url",
":",
"generatePublicApiUrl",
"(",
"mg",
",",
"routesEndpoint",
")",
",",
"routesListResponse",
":",
"routesListResponse",
"{",
"TotalCount",
":",
"-",
"1",
"}",
",",
"limit",
":",
"limit",
",",
"}",
"\n",
"}"
] | // ListRoutes allows you to iterate through a list of routes returned by the API | [
"ListRoutes",
"allows",
"you",
"to",
"iterate",
"through",
"a",
"list",
"of",
"routes",
"returned",
"by",
"the",
"API"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/routes.go#L43-L59 | train |
mailgun/mailgun-go | routes.go | CreateRoute | func (mg *MailgunImpl) CreateRoute(ctx context.Context, prototype Route) (_ignored Route, err error) {
r := newHTTPRequest(generatePublicApiUrl(mg, routesEndpoint))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
p.addValue("priority", strconv.Itoa(prototype.Priority))
p.addValue("description", prototype.Description)
p.addValue("expression", prototype.Expression)
for _, action := range prototype.Actions {
p.addValue("action", action)
}
var resp createRouteResp
if err = postResponseFromJSON(ctx, r, p, &resp); err != nil {
return _ignored, err
}
return resp.Route, err
} | go | func (mg *MailgunImpl) CreateRoute(ctx context.Context, prototype Route) (_ignored Route, err error) {
r := newHTTPRequest(generatePublicApiUrl(mg, routesEndpoint))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
p.addValue("priority", strconv.Itoa(prototype.Priority))
p.addValue("description", prototype.Description)
p.addValue("expression", prototype.Expression)
for _, action := range prototype.Actions {
p.addValue("action", action)
}
var resp createRouteResp
if err = postResponseFromJSON(ctx, r, p, &resp); err != nil {
return _ignored, err
}
return resp.Route, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"CreateRoute",
"(",
"ctx",
"context",
".",
"Context",
",",
"prototype",
"Route",
")",
"(",
"_ignored",
"Route",
",",
"err",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"routesEndpoint",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"p",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"prototype",
".",
"Priority",
")",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"prototype",
".",
"Description",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"prototype",
".",
"Expression",
")",
"\n",
"for",
"_",
",",
"action",
":=",
"range",
"prototype",
".",
"Actions",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"action",
")",
"\n",
"}",
"\n",
"var",
"resp",
"createRouteResp",
"\n",
"if",
"err",
"=",
"postResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"p",
",",
"&",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"_ignored",
",",
"err",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Route",
",",
"err",
"\n",
"}"
] | // CreateRoute installs a new route for your domain.
// The route structure you provide serves as a template, and
// only a subset of the fields influence the operation.
// See the Route structure definition for more details. | [
"CreateRoute",
"installs",
"a",
"new",
"route",
"for",
"your",
"domain",
".",
"The",
"route",
"structure",
"you",
"provide",
"serves",
"as",
"a",
"template",
"and",
"only",
"a",
"subset",
"of",
"the",
"fields",
"influence",
"the",
"operation",
".",
"See",
"the",
"Route",
"structure",
"definition",
"for",
"more",
"details",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/routes.go#L199-L215 | train |
mailgun/mailgun-go | routes.go | DeleteRoute | func (mg *MailgunImpl) DeleteRoute(ctx context.Context, id string) error {
r := newHTTPRequest(generatePublicApiUrl(mg, routesEndpoint) + "/" + id)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | go | func (mg *MailgunImpl) DeleteRoute(ctx context.Context, id string) error {
r := newHTTPRequest(generatePublicApiUrl(mg, routesEndpoint) + "/" + id)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"DeleteRoute",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"string",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"routesEndpoint",
")",
"+",
"\"",
"\"",
"+",
"id",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"makeDeleteRequest",
"(",
"ctx",
",",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteRoute removes the specified route from your domain's configuration.
// To avoid ambiguity, Mailgun identifies the route by unique ID.
// See the Route structure definition and the Mailgun API documentation for more details. | [
"DeleteRoute",
"removes",
"the",
"specified",
"route",
"from",
"your",
"domain",
"s",
"configuration",
".",
"To",
"avoid",
"ambiguity",
"Mailgun",
"identifies",
"the",
"route",
"by",
"unique",
"ID",
".",
"See",
"the",
"Route",
"structure",
"definition",
"and",
"the",
"Mailgun",
"API",
"documentation",
"for",
"more",
"details",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/routes.go#L220-L226 | train |
mailgun/mailgun-go | routes.go | GetRoute | func (mg *MailgunImpl) GetRoute(ctx context.Context, id string) (Route, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, routesEndpoint) + "/" + id)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var envelope struct {
Message string `json:"message"`
*Route `json:"route"`
}
err := getResponseFromJSON(ctx, r, &envelope)
if err != nil {
return Route{}, err
}
return *envelope.Route, err
} | go | func (mg *MailgunImpl) GetRoute(ctx context.Context, id string) (Route, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, routesEndpoint) + "/" + id)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var envelope struct {
Message string `json:"message"`
*Route `json:"route"`
}
err := getResponseFromJSON(ctx, r, &envelope)
if err != nil {
return Route{}, err
}
return *envelope.Route, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetRoute",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"string",
")",
"(",
"Route",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"routesEndpoint",
")",
"+",
"\"",
"\"",
"+",
"id",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"var",
"envelope",
"struct",
"{",
"Message",
"string",
"`json:\"message\"`",
"\n",
"*",
"Route",
"`json:\"route\"`",
"\n",
"}",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"envelope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Route",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"*",
"envelope",
".",
"Route",
",",
"err",
"\n\n",
"}"
] | // GetRoute retrieves the complete route definition associated with the unique route ID. | [
"GetRoute",
"retrieves",
"the",
"complete",
"route",
"definition",
"associated",
"with",
"the",
"unique",
"route",
"ID",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/routes.go#L229-L243 | train |
mailgun/mailgun-go | routes.go | UpdateRoute | func (mg *MailgunImpl) UpdateRoute(ctx context.Context, id string, route Route) (Route, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, routesEndpoint) + "/" + id)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
if route.Priority != 0 {
p.addValue("priority", strconv.Itoa(route.Priority))
}
if route.Description != "" {
p.addValue("description", route.Description)
}
if route.Expression != "" {
p.addValue("expression", route.Expression)
}
if route.Actions != nil {
for _, action := range route.Actions {
p.addValue("action", action)
}
}
// For some reason, this API function just returns a bare Route on success.
// Unsure why this is the case; it seems like it ought to be a bug.
var envelope Route
err := putResponseFromJSON(ctx, r, p, &envelope)
return envelope, err
} | go | func (mg *MailgunImpl) UpdateRoute(ctx context.Context, id string, route Route) (Route, error) {
r := newHTTPRequest(generatePublicApiUrl(mg, routesEndpoint) + "/" + id)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newUrlEncodedPayload()
if route.Priority != 0 {
p.addValue("priority", strconv.Itoa(route.Priority))
}
if route.Description != "" {
p.addValue("description", route.Description)
}
if route.Expression != "" {
p.addValue("expression", route.Expression)
}
if route.Actions != nil {
for _, action := range route.Actions {
p.addValue("action", action)
}
}
// For some reason, this API function just returns a bare Route on success.
// Unsure why this is the case; it seems like it ought to be a bug.
var envelope Route
err := putResponseFromJSON(ctx, r, p, &envelope)
return envelope, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"UpdateRoute",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"string",
",",
"route",
"Route",
")",
"(",
"Route",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generatePublicApiUrl",
"(",
"mg",
",",
"routesEndpoint",
")",
"+",
"\"",
"\"",
"+",
"id",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"p",
":=",
"newUrlEncodedPayload",
"(",
")",
"\n",
"if",
"route",
".",
"Priority",
"!=",
"0",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"route",
".",
"Priority",
")",
")",
"\n",
"}",
"\n",
"if",
"route",
".",
"Description",
"!=",
"\"",
"\"",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"route",
".",
"Description",
")",
"\n",
"}",
"\n",
"if",
"route",
".",
"Expression",
"!=",
"\"",
"\"",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"route",
".",
"Expression",
")",
"\n",
"}",
"\n",
"if",
"route",
".",
"Actions",
"!=",
"nil",
"{",
"for",
"_",
",",
"action",
":=",
"range",
"route",
".",
"Actions",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"action",
")",
"\n",
"}",
"\n",
"}",
"\n",
"// For some reason, this API function just returns a bare Route on success.",
"// Unsure why this is the case; it seems like it ought to be a bug.",
"var",
"envelope",
"Route",
"\n",
"err",
":=",
"putResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"p",
",",
"&",
"envelope",
")",
"\n",
"return",
"envelope",
",",
"err",
"\n",
"}"
] | // UpdateRoute provides an "in-place" update of the specified route.
// Only those route fields which are non-zero or non-empty are updated.
// All other fields remain as-is. | [
"UpdateRoute",
"provides",
"an",
"in",
"-",
"place",
"update",
"of",
"the",
"specified",
"route",
".",
"Only",
"those",
"route",
"fields",
"which",
"are",
"non",
"-",
"zero",
"or",
"non",
"-",
"empty",
"are",
"updated",
".",
"All",
"other",
"fields",
"remain",
"as",
"-",
"is",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/routes.go#L248-L272 | train |
mailgun/mailgun-go | members.go | GetMember | func (mg *MailgunImpl) GetMember(ctx context.Context, s, l string) (Member, error) {
r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, l) + "/" + s)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
response, err := makeGetRequest(ctx, r)
if err != nil {
return Member{}, err
}
var resp memberResponse
err = response.parseFromJSON(&resp)
return resp.Member, err
} | go | func (mg *MailgunImpl) GetMember(ctx context.Context, s, l string) (Member, error) {
r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, l) + "/" + s)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
response, err := makeGetRequest(ctx, r)
if err != nil {
return Member{}, err
}
var resp memberResponse
err = response.parseFromJSON(&resp)
return resp.Member, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetMember",
"(",
"ctx",
"context",
".",
"Context",
",",
"s",
",",
"l",
"string",
")",
"(",
"Member",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateMemberApiUrl",
"(",
"mg",
",",
"listsEndpoint",
",",
"l",
")",
"+",
"\"",
"\"",
"+",
"s",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"response",
",",
"err",
":=",
"makeGetRequest",
"(",
"ctx",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Member",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"var",
"resp",
"memberResponse",
"\n",
"err",
"=",
"response",
".",
"parseFromJSON",
"(",
"&",
"resp",
")",
"\n",
"return",
"resp",
".",
"Member",
",",
"err",
"\n",
"}"
] | // GetMember returns a complete Member structure for a member of a mailing list,
// given only their subscription e-mail address. | [
"GetMember",
"returns",
"a",
"complete",
"Member",
"structure",
"for",
"a",
"member",
"of",
"a",
"mailing",
"list",
"given",
"only",
"their",
"subscription",
"e",
"-",
"mail",
"address",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/members.go#L160-L171 | train |
mailgun/mailgun-go | members.go | CreateMember | func (mg *MailgunImpl) CreateMember(ctx context.Context, merge bool, addr string, prototype Member) error {
vs, err := json.Marshal(prototype.Vars)
if err != nil {
return err
}
r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, addr))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newFormDataPayload()
p.addValue("upsert", yesNo(merge))
p.addValue("address", prototype.Address)
p.addValue("name", prototype.Name)
p.addValue("vars", string(vs))
if prototype.Subscribed != nil {
p.addValue("subscribed", yesNo(*prototype.Subscribed))
}
_, err = makePostRequest(ctx, r, p)
return err
} | go | func (mg *MailgunImpl) CreateMember(ctx context.Context, merge bool, addr string, prototype Member) error {
vs, err := json.Marshal(prototype.Vars)
if err != nil {
return err
}
r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, addr))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newFormDataPayload()
p.addValue("upsert", yesNo(merge))
p.addValue("address", prototype.Address)
p.addValue("name", prototype.Name)
p.addValue("vars", string(vs))
if prototype.Subscribed != nil {
p.addValue("subscribed", yesNo(*prototype.Subscribed))
}
_, err = makePostRequest(ctx, r, p)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"CreateMember",
"(",
"ctx",
"context",
".",
"Context",
",",
"merge",
"bool",
",",
"addr",
"string",
",",
"prototype",
"Member",
")",
"error",
"{",
"vs",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"prototype",
".",
"Vars",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"r",
":=",
"newHTTPRequest",
"(",
"generateMemberApiUrl",
"(",
"mg",
",",
"listsEndpoint",
",",
"addr",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"p",
":=",
"newFormDataPayload",
"(",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"yesNo",
"(",
"merge",
")",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"prototype",
".",
"Address",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"prototype",
".",
"Name",
")",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"string",
"(",
"vs",
")",
")",
"\n",
"if",
"prototype",
".",
"Subscribed",
"!=",
"nil",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"yesNo",
"(",
"*",
"prototype",
".",
"Subscribed",
")",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"makePostRequest",
"(",
"ctx",
",",
"r",
",",
"p",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // CreateMember registers a new member of the indicated mailing list.
// If merge is set to true, then the registration may update an existing Member's settings.
// Otherwise, an error will occur if you attempt to add a member with a duplicate e-mail address. | [
"CreateMember",
"registers",
"a",
"new",
"member",
"of",
"the",
"indicated",
"mailing",
"list",
".",
"If",
"merge",
"is",
"set",
"to",
"true",
"then",
"the",
"registration",
"may",
"update",
"an",
"existing",
"Member",
"s",
"settings",
".",
"Otherwise",
"an",
"error",
"will",
"occur",
"if",
"you",
"attempt",
"to",
"add",
"a",
"member",
"with",
"a",
"duplicate",
"e",
"-",
"mail",
"address",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/members.go#L176-L195 | train |
mailgun/mailgun-go | members.go | UpdateMember | func (mg *MailgunImpl) UpdateMember(ctx context.Context, s, l string, prototype Member) (Member, error) {
r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, l) + "/" + s)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newFormDataPayload()
if prototype.Address != "" {
p.addValue("address", prototype.Address)
}
if prototype.Name != "" {
p.addValue("name", prototype.Name)
}
if prototype.Vars != nil {
vs, err := json.Marshal(prototype.Vars)
if err != nil {
return Member{}, err
}
p.addValue("vars", string(vs))
}
if prototype.Subscribed != nil {
p.addValue("subscribed", yesNo(*prototype.Subscribed))
}
response, err := makePutRequest(ctx, r, p)
if err != nil {
return Member{}, err
}
var envelope struct {
Member Member `json:"member"`
}
err = response.parseFromJSON(&envelope)
return envelope.Member, err
} | go | func (mg *MailgunImpl) UpdateMember(ctx context.Context, s, l string, prototype Member) (Member, error) {
r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, l) + "/" + s)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
p := newFormDataPayload()
if prototype.Address != "" {
p.addValue("address", prototype.Address)
}
if prototype.Name != "" {
p.addValue("name", prototype.Name)
}
if prototype.Vars != nil {
vs, err := json.Marshal(prototype.Vars)
if err != nil {
return Member{}, err
}
p.addValue("vars", string(vs))
}
if prototype.Subscribed != nil {
p.addValue("subscribed", yesNo(*prototype.Subscribed))
}
response, err := makePutRequest(ctx, r, p)
if err != nil {
return Member{}, err
}
var envelope struct {
Member Member `json:"member"`
}
err = response.parseFromJSON(&envelope)
return envelope.Member, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"UpdateMember",
"(",
"ctx",
"context",
".",
"Context",
",",
"s",
",",
"l",
"string",
",",
"prototype",
"Member",
")",
"(",
"Member",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateMemberApiUrl",
"(",
"mg",
",",
"listsEndpoint",
",",
"l",
")",
"+",
"\"",
"\"",
"+",
"s",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"p",
":=",
"newFormDataPayload",
"(",
")",
"\n",
"if",
"prototype",
".",
"Address",
"!=",
"\"",
"\"",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"prototype",
".",
"Address",
")",
"\n",
"}",
"\n",
"if",
"prototype",
".",
"Name",
"!=",
"\"",
"\"",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"prototype",
".",
"Name",
")",
"\n",
"}",
"\n",
"if",
"prototype",
".",
"Vars",
"!=",
"nil",
"{",
"vs",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"prototype",
".",
"Vars",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Member",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"string",
"(",
"vs",
")",
")",
"\n",
"}",
"\n",
"if",
"prototype",
".",
"Subscribed",
"!=",
"nil",
"{",
"p",
".",
"addValue",
"(",
"\"",
"\"",
",",
"yesNo",
"(",
"*",
"prototype",
".",
"Subscribed",
")",
")",
"\n",
"}",
"\n",
"response",
",",
"err",
":=",
"makePutRequest",
"(",
"ctx",
",",
"r",
",",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Member",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"var",
"envelope",
"struct",
"{",
"Member",
"Member",
"`json:\"member\"`",
"\n",
"}",
"\n",
"err",
"=",
"response",
".",
"parseFromJSON",
"(",
"&",
"envelope",
")",
"\n",
"return",
"envelope",
".",
"Member",
",",
"err",
"\n",
"}"
] | // UpdateMember lets you change certain details about the indicated mailing list member.
// Address, Name, Vars, and Subscribed fields may be changed. | [
"UpdateMember",
"lets",
"you",
"change",
"certain",
"details",
"about",
"the",
"indicated",
"mailing",
"list",
"member",
".",
"Address",
"Name",
"Vars",
"and",
"Subscribed",
"fields",
"may",
"be",
"changed",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/members.go#L199-L229 | train |
mailgun/mailgun-go | members.go | DeleteMember | func (mg *MailgunImpl) DeleteMember(ctx context.Context, member, addr string) error {
r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, addr) + "/" + member)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | go | func (mg *MailgunImpl) DeleteMember(ctx context.Context, member, addr string) error {
r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, addr) + "/" + member)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
_, err := makeDeleteRequest(ctx, r)
return err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"DeleteMember",
"(",
"ctx",
"context",
".",
"Context",
",",
"member",
",",
"addr",
"string",
")",
"error",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateMemberApiUrl",
"(",
"mg",
",",
"listsEndpoint",
",",
"addr",
")",
"+",
"\"",
"\"",
"+",
"member",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"_",
",",
"err",
":=",
"makeDeleteRequest",
"(",
"ctx",
",",
"r",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteMember removes the member from the list. | [
"DeleteMember",
"removes",
"the",
"member",
"from",
"the",
"list",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/members.go#L232-L238 | train |
mailgun/mailgun-go | mock.go | NewMockServer | func NewMockServer() MockServer {
ms := MockServer{}
// Add all our handlers
r := chi.NewRouter()
r.Route("/v3", func(r chi.Router) {
ms.addIPRoutes(r)
ms.addExportRoutes(r)
ms.addDomainRoutes(r)
ms.addMailingListRoutes(r)
ms.addEventRoutes(r)
ms.addMessagesRoutes(r)
ms.addValidationRoutes(r)
ms.addRoutes(r)
})
// Start the server
ms.srv = httptest.NewServer(r)
return ms
} | go | func NewMockServer() MockServer {
ms := MockServer{}
// Add all our handlers
r := chi.NewRouter()
r.Route("/v3", func(r chi.Router) {
ms.addIPRoutes(r)
ms.addExportRoutes(r)
ms.addDomainRoutes(r)
ms.addMailingListRoutes(r)
ms.addEventRoutes(r)
ms.addMessagesRoutes(r)
ms.addValidationRoutes(r)
ms.addRoutes(r)
})
// Start the server
ms.srv = httptest.NewServer(r)
return ms
} | [
"func",
"NewMockServer",
"(",
")",
"MockServer",
"{",
"ms",
":=",
"MockServer",
"{",
"}",
"\n\n",
"// Add all our handlers",
"r",
":=",
"chi",
".",
"NewRouter",
"(",
")",
"\n\n",
"r",
".",
"Route",
"(",
"\"",
"\"",
",",
"func",
"(",
"r",
"chi",
".",
"Router",
")",
"{",
"ms",
".",
"addIPRoutes",
"(",
"r",
")",
"\n",
"ms",
".",
"addExportRoutes",
"(",
"r",
")",
"\n",
"ms",
".",
"addDomainRoutes",
"(",
"r",
")",
"\n",
"ms",
".",
"addMailingListRoutes",
"(",
"r",
")",
"\n",
"ms",
".",
"addEventRoutes",
"(",
"r",
")",
"\n",
"ms",
".",
"addMessagesRoutes",
"(",
"r",
")",
"\n",
"ms",
".",
"addValidationRoutes",
"(",
"r",
")",
"\n",
"ms",
".",
"addRoutes",
"(",
"r",
")",
"\n",
"}",
")",
"\n\n",
"// Start the server",
"ms",
".",
"srv",
"=",
"httptest",
".",
"NewServer",
"(",
"r",
")",
"\n",
"return",
"ms",
"\n",
"}"
] | // Create a new instance of the mailgun API mock server | [
"Create",
"a",
"new",
"instance",
"of",
"the",
"mailgun",
"API",
"mock",
"server"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/mock.go#L30-L50 | train |
mailgun/mailgun-go | mock.go | pageOffsets | func pageOffsets(pivotIdx []string, pivotDir, pivotVal string, limit int) (int, int) {
switch pivotDir {
case "first":
if limit < len(pivotIdx) {
return 0, limit
}
return 0, len(pivotIdx)
case "last":
if limit < len(pivotIdx) {
return len(pivotIdx) - limit, len(pivotIdx)
}
return 0, len(pivotIdx)
case "next":
for i, item := range pivotIdx {
if item == pivotVal {
offset := i + 1 + limit
if offset > len(pivotIdx) {
offset = len(pivotIdx)
}
return i + 1, offset
}
}
return 0, 0
case "prev":
for i, item := range pivotIdx {
if item == pivotVal {
if i == 0 {
return 0, 0
}
offset := i - limit
if offset < 0 {
offset = 0
}
return offset, i
}
}
return 0, 0
}
if limit > len(pivotIdx) {
return 0, len(pivotIdx)
}
return 0, limit
} | go | func pageOffsets(pivotIdx []string, pivotDir, pivotVal string, limit int) (int, int) {
switch pivotDir {
case "first":
if limit < len(pivotIdx) {
return 0, limit
}
return 0, len(pivotIdx)
case "last":
if limit < len(pivotIdx) {
return len(pivotIdx) - limit, len(pivotIdx)
}
return 0, len(pivotIdx)
case "next":
for i, item := range pivotIdx {
if item == pivotVal {
offset := i + 1 + limit
if offset > len(pivotIdx) {
offset = len(pivotIdx)
}
return i + 1, offset
}
}
return 0, 0
case "prev":
for i, item := range pivotIdx {
if item == pivotVal {
if i == 0 {
return 0, 0
}
offset := i - limit
if offset < 0 {
offset = 0
}
return offset, i
}
}
return 0, 0
}
if limit > len(pivotIdx) {
return 0, len(pivotIdx)
}
return 0, limit
} | [
"func",
"pageOffsets",
"(",
"pivotIdx",
"[",
"]",
"string",
",",
"pivotDir",
",",
"pivotVal",
"string",
",",
"limit",
"int",
")",
"(",
"int",
",",
"int",
")",
"{",
"switch",
"pivotDir",
"{",
"case",
"\"",
"\"",
":",
"if",
"limit",
"<",
"len",
"(",
"pivotIdx",
")",
"{",
"return",
"0",
",",
"limit",
"\n",
"}",
"\n",
"return",
"0",
",",
"len",
"(",
"pivotIdx",
")",
"\n",
"case",
"\"",
"\"",
":",
"if",
"limit",
"<",
"len",
"(",
"pivotIdx",
")",
"{",
"return",
"len",
"(",
"pivotIdx",
")",
"-",
"limit",
",",
"len",
"(",
"pivotIdx",
")",
"\n",
"}",
"\n",
"return",
"0",
",",
"len",
"(",
"pivotIdx",
")",
"\n",
"case",
"\"",
"\"",
":",
"for",
"i",
",",
"item",
":=",
"range",
"pivotIdx",
"{",
"if",
"item",
"==",
"pivotVal",
"{",
"offset",
":=",
"i",
"+",
"1",
"+",
"limit",
"\n",
"if",
"offset",
">",
"len",
"(",
"pivotIdx",
")",
"{",
"offset",
"=",
"len",
"(",
"pivotIdx",
")",
"\n",
"}",
"\n",
"return",
"i",
"+",
"1",
",",
"offset",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"0",
",",
"0",
"\n",
"case",
"\"",
"\"",
":",
"for",
"i",
",",
"item",
":=",
"range",
"pivotIdx",
"{",
"if",
"item",
"==",
"pivotVal",
"{",
"if",
"i",
"==",
"0",
"{",
"return",
"0",
",",
"0",
"\n",
"}",
"\n\n",
"offset",
":=",
"i",
"-",
"limit",
"\n",
"if",
"offset",
"<",
"0",
"{",
"offset",
"=",
"0",
"\n",
"}",
"\n",
"return",
"offset",
",",
"i",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"0",
",",
"0",
"\n",
"}",
"\n\n",
"if",
"limit",
">",
"len",
"(",
"pivotIdx",
")",
"{",
"return",
"0",
",",
"len",
"(",
"pivotIdx",
")",
"\n",
"}",
"\n",
"return",
"0",
",",
"limit",
"\n",
"}"
] | // Given the page direction, pivot value and limit, calculate the offsets for the slice | [
"Given",
"the",
"page",
"direction",
"pivot",
"value",
"and",
"limit",
"calculate",
"the",
"offsets",
"for",
"the",
"slice"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/mock.go#L123-L167 | train |
mailgun/mailgun-go | spam_complaints.go | ListComplaints | func (mg *MailgunImpl) ListComplaints(opts *ListOptions) *ComplaintsIterator {
r := newHTTPRequest(generateApiUrl(mg, complaintsEndpoint))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
if opts != nil {
if opts.Limit != 0 {
r.addParameter("limit", strconv.Itoa(opts.Limit))
}
}
url, err := r.generateUrlWithParameters()
return &ComplaintsIterator{
mg: mg,
complaintsResponse: complaintsResponse{Paging: Paging{Next: url, First: url}},
err: err,
}
} | go | func (mg *MailgunImpl) ListComplaints(opts *ListOptions) *ComplaintsIterator {
r := newHTTPRequest(generateApiUrl(mg, complaintsEndpoint))
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
if opts != nil {
if opts.Limit != 0 {
r.addParameter("limit", strconv.Itoa(opts.Limit))
}
}
url, err := r.generateUrlWithParameters()
return &ComplaintsIterator{
mg: mg,
complaintsResponse: complaintsResponse{Paging: Paging{Next: url, First: url}},
err: err,
}
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"ListComplaints",
"(",
"opts",
"*",
"ListOptions",
")",
"*",
"ComplaintsIterator",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateApiUrl",
"(",
"mg",
",",
"complaintsEndpoint",
")",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n",
"if",
"opts",
"!=",
"nil",
"{",
"if",
"opts",
".",
"Limit",
"!=",
"0",
"{",
"r",
".",
"addParameter",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"opts",
".",
"Limit",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"url",
",",
"err",
":=",
"r",
".",
"generateUrlWithParameters",
"(",
")",
"\n",
"return",
"&",
"ComplaintsIterator",
"{",
"mg",
":",
"mg",
",",
"complaintsResponse",
":",
"complaintsResponse",
"{",
"Paging",
":",
"Paging",
"{",
"Next",
":",
"url",
",",
"First",
":",
"url",
"}",
"}",
",",
"err",
":",
"err",
",",
"}",
"\n",
"}"
] | // ListComplaints returns a set of spam complaints registered against your domain.
// Recipients of your messages can click on a link which sends feedback to Mailgun
// indicating that the message they received is, to them, spam. | [
"ListComplaints",
"returns",
"a",
"set",
"of",
"spam",
"complaints",
"registered",
"against",
"your",
"domain",
".",
"Recipients",
"of",
"your",
"messages",
"can",
"click",
"on",
"a",
"link",
"which",
"sends",
"feedback",
"to",
"Mailgun",
"indicating",
"that",
"the",
"message",
"they",
"received",
"is",
"to",
"them",
"spam",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/spam_complaints.go#L28-L43 | train |
mailgun/mailgun-go | spam_complaints.go | GetComplaint | func (mg *MailgunImpl) GetComplaint(ctx context.Context, address string) (Complaint, error) {
r := newHTTPRequest(generateApiUrl(mg, complaintsEndpoint) + "/" + address)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var c Complaint
err := getResponseFromJSON(ctx, r, &c)
return c, err
} | go | func (mg *MailgunImpl) GetComplaint(ctx context.Context, address string) (Complaint, error) {
r := newHTTPRequest(generateApiUrl(mg, complaintsEndpoint) + "/" + address)
r.setClient(mg.Client())
r.setBasicAuth(basicAuthUser, mg.APIKey())
var c Complaint
err := getResponseFromJSON(ctx, r, &c)
return c, err
} | [
"func",
"(",
"mg",
"*",
"MailgunImpl",
")",
"GetComplaint",
"(",
"ctx",
"context",
".",
"Context",
",",
"address",
"string",
")",
"(",
"Complaint",
",",
"error",
")",
"{",
"r",
":=",
"newHTTPRequest",
"(",
"generateApiUrl",
"(",
"mg",
",",
"complaintsEndpoint",
")",
"+",
"\"",
"\"",
"+",
"address",
")",
"\n",
"r",
".",
"setClient",
"(",
"mg",
".",
"Client",
"(",
")",
")",
"\n",
"r",
".",
"setBasicAuth",
"(",
"basicAuthUser",
",",
"mg",
".",
"APIKey",
"(",
")",
")",
"\n\n",
"var",
"c",
"Complaint",
"\n",
"err",
":=",
"getResponseFromJSON",
"(",
"ctx",
",",
"r",
",",
"&",
"c",
")",
"\n",
"return",
"c",
",",
"err",
"\n",
"}"
] | // GetComplaint returns a single complaint record filed by a recipient at the email address provided.
// If no complaint exists, the Complaint instance returned will be empty. | [
"GetComplaint",
"returns",
"a",
"single",
"complaint",
"record",
"filed",
"by",
"a",
"recipient",
"at",
"the",
"email",
"address",
"provided",
".",
"If",
"no",
"complaint",
"exists",
"the",
"Complaint",
"instance",
"returned",
"will",
"be",
"empty",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/spam_complaints.go#L144-L152 | train |
mailgun/mailgun-go | mailgun.go | NewMailgun | func NewMailgun(domain, apiKey string) *MailgunImpl {
return &MailgunImpl{
apiBase: APIBase,
domain: domain,
apiKey: apiKey,
client: http.DefaultClient,
}
} | go | func NewMailgun(domain, apiKey string) *MailgunImpl {
return &MailgunImpl{
apiBase: APIBase,
domain: domain,
apiKey: apiKey,
client: http.DefaultClient,
}
} | [
"func",
"NewMailgun",
"(",
"domain",
",",
"apiKey",
"string",
")",
"*",
"MailgunImpl",
"{",
"return",
"&",
"MailgunImpl",
"{",
"apiBase",
":",
"APIBase",
",",
"domain",
":",
"domain",
",",
"apiKey",
":",
"apiKey",
",",
"client",
":",
"http",
".",
"DefaultClient",
",",
"}",
"\n",
"}"
] | // NewMailGun creates a new client instance. | [
"NewMailGun",
"creates",
"a",
"new",
"client",
"instance",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/mailgun.go#L242-L249 | train |
mailgun/mailgun-go | mailgun.go | NewMailgunFromEnv | func NewMailgunFromEnv() (*MailgunImpl, error) {
apiKey := os.Getenv("MG_API_KEY")
if apiKey == "" {
return nil, errors.New("required environment variable MG_API_KEY not defined")
}
domain := os.Getenv("MG_DOMAIN")
if domain == "" {
return nil, errors.New("required environment variable MG_DOMAIN not defined")
}
mg := NewMailgun(domain, apiKey)
url := os.Getenv("MG_URL")
if url != "" {
mg.SetAPIBase(url)
}
return mg, nil
} | go | func NewMailgunFromEnv() (*MailgunImpl, error) {
apiKey := os.Getenv("MG_API_KEY")
if apiKey == "" {
return nil, errors.New("required environment variable MG_API_KEY not defined")
}
domain := os.Getenv("MG_DOMAIN")
if domain == "" {
return nil, errors.New("required environment variable MG_DOMAIN not defined")
}
mg := NewMailgun(domain, apiKey)
url := os.Getenv("MG_URL")
if url != "" {
mg.SetAPIBase(url)
}
return mg, nil
} | [
"func",
"NewMailgunFromEnv",
"(",
")",
"(",
"*",
"MailgunImpl",
",",
"error",
")",
"{",
"apiKey",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"apiKey",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"domain",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"domain",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"mg",
":=",
"NewMailgun",
"(",
"domain",
",",
"apiKey",
")",
"\n\n",
"url",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"url",
"!=",
"\"",
"\"",
"{",
"mg",
".",
"SetAPIBase",
"(",
"url",
")",
"\n",
"}",
"\n\n",
"return",
"mg",
",",
"nil",
"\n",
"}"
] | // NewMailgunFromEnv returns a new Mailgun client using the environment variables
// MG_API_KEY, MG_DOMAIN, and MG_URL | [
"NewMailgunFromEnv",
"returns",
"a",
"new",
"Mailgun",
"client",
"using",
"the",
"environment",
"variables",
"MG_API_KEY",
"MG_DOMAIN",
"and",
"MG_URL"
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/mailgun.go#L253-L271 | train |
mailgun/mailgun-go | mailgun.go | generateApiUrlWithDomain | func generateApiUrlWithDomain(m Mailgun, endpoint, domain string) string {
return fmt.Sprintf("%s/%s/%s", m.APIBase(), domain, endpoint)
} | go | func generateApiUrlWithDomain(m Mailgun, endpoint, domain string) string {
return fmt.Sprintf("%s/%s/%s", m.APIBase(), domain, endpoint)
} | [
"func",
"generateApiUrlWithDomain",
"(",
"m",
"Mailgun",
",",
"endpoint",
",",
"domain",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"APIBase",
"(",
")",
",",
"domain",
",",
"endpoint",
")",
"\n",
"}"
] | // generateApiUrlWithDomain renders a URL for an API endpoint using a separate domain and endpoint name. | [
"generateApiUrlWithDomain",
"renders",
"a",
"URL",
"for",
"an",
"API",
"endpoint",
"using",
"a",
"separate",
"domain",
"and",
"endpoint",
"name",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/mailgun.go#L309-L311 | train |
mailgun/mailgun-go | mailgun.go | generateMemberApiUrl | func generateMemberApiUrl(m Mailgun, endpoint, address string) string {
return fmt.Sprintf("%s/%s/%s/members", m.APIBase(), endpoint, address)
} | go | func generateMemberApiUrl(m Mailgun, endpoint, address string) string {
return fmt.Sprintf("%s/%s/%s/members", m.APIBase(), endpoint, address)
} | [
"func",
"generateMemberApiUrl",
"(",
"m",
"Mailgun",
",",
"endpoint",
",",
"address",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"APIBase",
"(",
")",
",",
"endpoint",
",",
"address",
")",
"\n",
"}"
] | // generateMemberApiUrl renders a URL relevant for specifying mailing list members.
// The address parameter refers to the mailing list in question. | [
"generateMemberApiUrl",
"renders",
"a",
"URL",
"relevant",
"for",
"specifying",
"mailing",
"list",
"members",
".",
"The",
"address",
"parameter",
"refers",
"to",
"the",
"mailing",
"list",
"in",
"question",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/mailgun.go#L315-L317 | train |
mailgun/mailgun-go | mailgun.go | generateApiUrlWithTarget | func generateApiUrlWithTarget(m Mailgun, endpoint, target string) string {
tail := ""
if target != "" {
tail = fmt.Sprintf("/%s", target)
}
return fmt.Sprintf("%s%s", generateApiUrl(m, endpoint), tail)
} | go | func generateApiUrlWithTarget(m Mailgun, endpoint, target string) string {
tail := ""
if target != "" {
tail = fmt.Sprintf("/%s", target)
}
return fmt.Sprintf("%s%s", generateApiUrl(m, endpoint), tail)
} | [
"func",
"generateApiUrlWithTarget",
"(",
"m",
"Mailgun",
",",
"endpoint",
",",
"target",
"string",
")",
"string",
"{",
"tail",
":=",
"\"",
"\"",
"\n",
"if",
"target",
"!=",
"\"",
"\"",
"{",
"tail",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"target",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"generateApiUrl",
"(",
"m",
",",
"endpoint",
")",
",",
"tail",
")",
"\n",
"}"
] | // generateApiUrlWithTarget works as generateApiUrl,
// but consumes an additional resource parameter called 'target'. | [
"generateApiUrlWithTarget",
"works",
"as",
"generateApiUrl",
"but",
"consumes",
"an",
"additional",
"resource",
"parameter",
"called",
"target",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/mailgun.go#L321-L327 | train |
mailgun/mailgun-go | mailgun.go | generateDomainApiUrl | func generateDomainApiUrl(m Mailgun, endpoint string) string {
return fmt.Sprintf("%s/domains/%s/%s", m.APIBase(), m.Domain(), endpoint)
} | go | func generateDomainApiUrl(m Mailgun, endpoint string) string {
return fmt.Sprintf("%s/domains/%s/%s", m.APIBase(), m.Domain(), endpoint)
} | [
"func",
"generateDomainApiUrl",
"(",
"m",
"Mailgun",
",",
"endpoint",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"APIBase",
"(",
")",
",",
"m",
".",
"Domain",
"(",
")",
",",
"endpoint",
")",
"\n",
"}"
] | // generateDomainApiUrl renders a URL as generateApiUrl, but
// addresses a family of functions which have a non-standard URL structure.
// Most URLs consume a domain in the 2nd position, but some endpoints
// require the word "domains" to be there instead. | [
"generateDomainApiUrl",
"renders",
"a",
"URL",
"as",
"generateApiUrl",
"but",
"addresses",
"a",
"family",
"of",
"functions",
"which",
"have",
"a",
"non",
"-",
"standard",
"URL",
"structure",
".",
"Most",
"URLs",
"consume",
"a",
"domain",
"in",
"the",
"2nd",
"position",
"but",
"some",
"endpoints",
"require",
"the",
"word",
"domains",
"to",
"be",
"there",
"instead",
"."
] | df421608b66e7dd4c03112d5bb01525c51f344a2 | https://github.com/mailgun/mailgun-go/blob/df421608b66e7dd4c03112d5bb01525c51f344a2/mailgun.go#L333-L335 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.