~cgb-cs/appscale/appscale-main

          

          <li><a href="#method-c-setup_app">::setup_app</a></li>

          

          <li><a href="#method-c-shorten_to_n_items">::shorten_to_n_items</a></li>

          

          <li><a href="#method-c-sleep_until_port_is_closed">::sleep_until_port_is_closed</a></li>

        

          <li><a href="./CronHelper.html">CronHelper</a></li>

        

          <li><a href="./Djinn.html">Djinn</a></li>

        

          <li><a href="./DjinnJobData.html">DjinnJobData</a></li>

          <div class="method-source-code"

            id="application_port-source">

<pre>

def self.application_port(app_number, index, num_of_servers)

  <span class="ruby-constant">APP_START_PORT</span> + (app_number * num_of_servers) + index

end</pre>

          <div class="method-source-code"

            id="convert_fqdn_to_ip-source">

<pre>

def self.convert_fqdn_to_ip(host)

  return host if host =~ /#{IP_REGEX}/

 

          <div class="method-source-code"

            id="create_appscale_security_group-source">

<pre>

def self.create_appscale_security_group(infrastructure, group)

  <span class="ruby-constant">Djinn</span>.log_run(&quot;#{infrastructure}-add-group #{group} -d appscale 2&gt;&amp;1&quot;)

  <span class="ruby-constant">Djinn</span>.log_run(&quot;#{infrastructure}-authorize #{group} -p 1-65535 -P udp 2&gt;&amp;1&quot;)

          <div class="method-source-code"

            id="deserialize_info_from_tools-source">

<pre>

def self.deserialize_info_from_tools(ips) 

  nodes = {}

  <span class="ruby-comment"># FIXME: Here we make the string back into a hash using the crappy deserialization</span>

          <div class="method-source-code"

            id="does_image_have_location-3F-source">

<pre>

def self.does_image_have_location?(ip, location, key)

  ret_val = `ssh -i #{key} -o NumberOfPasswordPrompts=0 -o StrictHostkeyChecking=no 2&gt;&amp;1 root@#{ip} 'ls #{location}'; echo $?`.chomp[-1]

  return ret_val.chr == <span class="ruby-string">&quot;0&quot;</span>

          <div class="method-source-code"

            id="encrypt_password-source">

<pre>

def self.encrypt_password(user, pass)

  <span class="ruby-constant">Digest</span>::<span class="ruby-constant">SHA1</span>.hexdigest(user + pass)

end</pre>

          <div class="method-source-code"

            id="ensure_db_is_supported-source">

<pre>

def self.ensure_db_is_supported(ip, db, key)

  if self.does_image_have_location?(ip, &quot;/etc/appscale/#{VER_NUM}/#{db}&quot;, key)

    <span class="ruby-constant">Djinn</span>.log_debug(&quot;Image at #{ip} supports #{db}.&quot;)

          <div class="method-source-code"

            id="ensure_image_is_appscale-source">

<pre>

def self.ensure_image_is_appscale(ip, key)

  if self.does_image_have_location?(ip, <span class="ruby-string">&quot;/etc/appscale&quot;</span>, key)

    <span class="ruby-constant">Djinn</span>.log_debug(&quot;Image at #{ip} is an AppScale image.&quot;)

          <div class="method-source-code"

            id="expires_duration-source">

<pre>

def self.expires_duration input_string

  return nil if input_string.nil? || input_string.empty?

  <span class="ruby-comment"># Start with nil so we can distinguish between it not being set and 0</span>

          <div class="method-source-code"

            id="find_majority_item-source">

<pre>

def self.find_majority_item(array)

  count = {}

  array.each { |item|

          <div class="method-source-code"

            id="generate_location_config-source">

<pre>

def self.generate_location_config handler

  return <span class="ruby-string">&quot;&quot;</span> if !handler.key?(<span class="ruby-string">&quot;static_dir&quot;</span>) &amp;&amp; !handler.key?(<span class="ruby-string">&quot;static_files&quot;</span>)

 

          <div class="method-source-code"

            id="generate_makefile-source">

<pre>

def self.generate_makefile(code, input_loc)

  abort(<span class="ruby-string">&quot;code is nil&quot;</span>) if code.nil?

 

          <div class="method-source-code"

            id="generate_ssh_key-source">

<pre>

def self.generate_ssh_key(outputLocation, name, infrastructure)

  ec2_output = <span class="ruby-string">&quot;&quot;</span>

  loop {

          <div class="method-source-code"

            id="get_app_path-source">

<pre>

def self.get_app_path app_name

  &quot;/var/apps/#{app_name}/&quot;

end</pre>

          <div class="method-source-code"

            id="get_appscale_id-source">

<pre>

def self.get_appscale_id

  <span class="ruby-comment"># This needs to be ec2 or euca 2ools.</span>

  image_info = `ec2-describe-images`

          <div class="method-source-code"

            id="get_cache_path-source">

<pre>

def self.get_cache_path app_name

  <span class="ruby-constant">File</span>.join(get_app_path(app_name),<span class="ruby-string">&quot;cache&quot;</span>)

end</pre>

          <div class="method-source-code"

            id="get_cert-source">

<pre>

def self.get_cert(filename)

  return nil unless <span class="ruby-constant">File</span>.exists?(filename)

  <span class="ruby-constant">OpenSSL</span>::<span class="ruby-constant">X509</span>::<span class="ruby-constant">Certificate</span>.new(<span class="ruby-constant">File</span>.open(filename) { |f|

          <div class="method-source-code"

            id="get_cloud_ips-source">

<pre>

def self.get_cloud_ips(infrastructure, keyname)

  self.log_obscured_env

 

          <div class="method-source-code"

            id="get_hybrid_ips-source">

<pre>

def self.get_hybrid_ips(creds)

  <span class="ruby-constant">Djinn</span>.log_debug(&quot;creds are #{self.obscure_creds(creds).inspect}&quot;)

 

          <div class="method-source-code"

            id="get_ips-source">

<pre>

def self.get_ips(ips)

  abort(<span class="ruby-string">&quot;ips not even length array&quot;</span>) if ips.length % 2 != 0

  reported_public = []

          <div class="method-source-code"

            id="get_key-source">

<pre>

def self.get_key(filename)

  return nil unless <span class="ruby-constant">File</span>.exists?(filename)

  <span class="ruby-constant">OpenSSL</span>::<span class="ruby-constant">PKey</span>::<span class="ruby-constant">RSA</span>.new(<span class="ruby-constant">File</span>.open(filename) { |f|

          <div class="method-source-code"

            id="get_num_cpus-source">

<pre>

def self.get_num_cpus()

  return <span class="ruby-constant">Integer</span>(`cat /proc/cpuinfo | grep 'processor' | wc -l`.chomp)

end</pre>

          <div class="method-source-code"

            id="get_public_ips-source">

<pre>

def self.get_public_ips(ips)

  abort(<span class="ruby-string">&quot;ips not even length array&quot;</span>) if ips.length % 2 != 0

  reported_public = []

          <div class="method-source-code"

            id="get_random_alphanumeric-source">

<pre>

def self.get_random_alphanumeric(length=10)

  random = <span class="ruby-string">&quot;&quot;</span>

  possible = <span class="ruby-string">&quot;0123456789abcdefghijklmnopqrstuvxwyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;</span>

          <div class="method-source-code"

            id="get_relative_filename-source">

<pre>

def self.get_relative_filename filename, app_name

  filename[get_untar_dir(app_name).length..filename.length]

end</pre>

          <div class="method-source-code"

            id="get_remote_appscale_home-source">

<pre>

def self.get_remote_appscale_home(ip, key)

  cat = <span class="ruby-string">&quot;cat /etc/appscale/home&quot;</span>

  remote_cmd = &quot;ssh -i #{key} -o NumberOfPasswordPrompts=0 -o StrictHostkeyChecking=no 2&gt;&amp;1 root@#{ip} '#{cat}'&quot;

          <div class="method-source-code"

            id="get_secret-source">

<pre>

def self.get_secret(filename=&quot;#{APPSCALE_HOME}/.appscale/secret.key&quot;)

  filename = <span class="ruby-constant">File</span>.expand_path(filename)

  return nil unless <span class="ruby-constant">File</span>.exists?(filename)

          <div class="method-source-code"

            id="get_untar_dir-source">

<pre>

def self.get_untar_dir app_name

  <span class="ruby-constant">File</span>.join(get_app_path(app_name),<span class="ruby-string">&quot;app&quot;</span>)

end</pre>

          <div class="method-source-code"

            id="get_usage-source">

<pre>

def self.get_usage

  top_results = `top -n1 -d0 -b`

  usage = {}

          <div class="method-source-code"

            id="is_port_open-3F-source">

<pre>

def self.is_port_open?(ip, port, use_ssl=<span class="ruby-constant">DONT_USE_SSL</span>)

  begin

    <span class="ruby-constant">Timeout</span>::timeout(1) do

          <div class="method-source-code"

            id="kill_process-source">

<pre>

def self.kill_process(name)

  `ps ax | grep #{name} | grep -v grep | awk '{ print $1 }' | xargs -d '\n' kill -9`

end</pre>

          <div class="method-source-code"

            id="local_ip-source">

<pre>

def self.local_ip

  <span class="ruby-constant">UDPSocket</span>.open {|s| s.connect(<span class="ruby-string">&quot;64.233.187.99&quot;</span>, 1); s.addr.last }

end</pre>

          <div class="method-source-code"

            id="log_obscured_env-source">

<pre>

def self.log_obscured_env()

  env = `env`

 

          <div class="method-source-code"

            id="obscure_array-source">

<pre>

def self.obscure_array(array)

  return array.map {|s| 

    if <span class="ruby-constant">CLOUDY_CREDS</span>.include?(s)

          <div class="method-source-code"

            id="obscure_creds-source">

<pre>

def self.obscure_creds(creds)

  obscured = {}

  creds.each { |k, v|

          <div class="method-source-code"

            id="obscure_string-source">

<pre>

def self.obscure_string(string)

  return string if string.nil? or string.length &lt; 4

  last_four = string[string.length-4, string.length]

          <div class="method-source-code"

            id="parse_static_data-source">

<pre>

def self.parse_static_data app_name

  untar_dir = get_untar_dir(app_name)

 

          <div class="method-source-code"

            id="read_file-source">

<pre>

def self.read_file(location, chomp=true)

  file = <span class="ruby-constant">File</span>.open(location) { |f| f.read }

  if chomp

          <div class="method-source-code"

            id="run_app-source">

<pre>

def self.run_app(app_name, port, db_location, public_ip, private_ip, app_version, app_language, nginx_port, xmpp_ip)

  secret = <span class="ruby-constant">HelperFunctions</span>.get_secret    

 

          <div class="method-source-code"

            id="run_remote_command-source">

<pre>

def self.run_remote_command(ip, command, public_key_loc, want_output)

  <span class="ruby-constant">Djinn</span>.log_debug(&quot;ip is [#{ip}], command is [#{command}], public key is [#{public_key_loc}], want output? [#{want_output}]&quot;)

  public_key_loc = <span class="ruby-constant">File</span>.expand_path(public_key_loc)

          <div class="method-source-code"

            id="scp_file-source">

<pre>

def self.scp_file(local_file_loc, remote_file_loc, target_ip, private_key_loc)

  private_key_loc = <span class="ruby-constant">File</span>.expand_path(private_key_loc)

  `chmod 0600 #{private_key_loc}`

          <div class="method-source-code"

            id="set_creds_in_env-source">

<pre>

def self.set_creds_in_env(creds, cloud_num)

  <span class="ruby-constant">ENV</span>[<span class="ruby-string">'EC2_JVM_ARGS'</span>] = nil

 

          <div class="method-source-code"

            id="setup_app-source">

<pre>

def self.setup_app(app_name, untar=true)

  meta_dir = &quot;/var/apps/#{app_name}&quot;

  tar_dir = &quot;#{meta_dir}/app/&quot;

      </div>

 

    

      <div id="shorten_to_n_items-method" class="method-detail ">

        <a name="method-c-shorten_to_n_items"></a>

 

          <div class="method-source-code"

            id="shorten_to_n_items-source">

<pre>

def self.shorten_to_n_items(n, array)

  len = array.length

  if len &lt; n

          <div class="method-source-code"

            id="sleep_until_port_is_closed-source">

<pre>

def self.sleep_until_port_is_closed(ip, port, use_ssl=<span class="ruby-constant">DONT_USE_SSL</span>)

  sleep_time = 1

 

          <div class="method-source-code"

            id="sleep_until_port_is_open-source">

<pre>

def self.sleep_until_port_is_open(ip, port, use_ssl=<span class="ruby-constant">DONT_USE_SSL</span>)

  sleep_time = 1

 

          <div class="method-source-code"

            id="spawn_hybrid_vms-source">

<pre>

def self.spawn_hybrid_vms(creds, nodes)

  info = &quot;Spawning hybrid vms with creds #{self.obscure_creds(creds).inspect} and nodes #{nodes.inspect}&quot;

  <span class="ruby-constant">Djinn</span>.log_debug(info)

          <div class="method-source-code"

            id="spawn_vms-source">

<pre>

def self.spawn_vms(num_of_vms_to_spawn, job, image_id, instance_type, keyname,

  infrastructure, cloud, group)

  return [] if num_of_vms_to_spawn &lt; 1

          <div class="method-source-code"

            id="terminate_all_vms-source">

<pre>

def self.terminate_all_vms(infrastructure, keyname)

  self.log_obscured_env

  desc_instances = `#{infrastructure}-describe-instances`

          <div class="method-source-code"

            id="terminate_hybrid_vms-source">

<pre>

def self.terminate_hybrid_vms(creds)

  <span class="ruby-comment"># TODO: kill my own cloud last</span>

  <span class="ruby-comment"># otherwise could orphan other clouds</span>

          <div class="method-source-code"

            id="terminate_vms-source">

<pre>

def self.terminate_vms(nodes, infrastructure)

  instances = []

  nodes.each { |node|

          <div class="method-source-code"

            id="write_file-source">

<pre>

def self.write_file(location, contents)

  <span class="ruby-constant">File</span>.open(location, <span class="ruby-string">&quot;w+&quot;</span>) { |file| file.write(contents) }

end</pre>